Skip to content

C
CGoGN
Commit 2f3a34b6 authored by Sylvain Thery's avatar Sylvain Thery
Browse files
Options

Tutos

parent 3235b80c
Hide whitespace changes
Inline Side-by-side
Showing with 669 additions and 21 deletions
Apps/CMakeLists.txt
View file @ 2f3a34b6
......@@ -37,3 +37,6 @@ add_subdirectory(Examples/Tests)
add_subdirectory(Tuto/Traversals)
add_subdirectory(Tuto/Attributes)
add_subdirectory(Tuto/Markers)
add_subdirectory(Tuto/Boundary)
add_subdirectory(Tuto/Modelling)
Apps/Tuto/Boundary/CMakeLists.txt 0 → 100644
View file @ 2f3a34b6
cmake_minimum_required(VERSION 2.8)
project(Tuto_Traversals)
SET (CMAKE_BUILD_TYPE Debug)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNOTOPOWARNING")
include_directories(
${CMAKE_CURRENT_BINARY_DIR}
${CGoGN_ROOT_DIR}/include
${CGoGN_EXT_INCLUDES}
)
# define libs path
IF(WIN32)
link_directories(${CGoGN_ROOT_DIR}/lib/$(ConfigurationName)
${Boost_LIBRARY_DIRS})
ELSE(WIN32)
link_directories(${CGoGN_ROOT_DIR}/lib/Release ${CGoGN_ROOT_DIR}/lib/Debug)
ENDIF(WIN32)
#define exec to compile
add_executable( boundaries boundaries.cpp)
target_link_libraries( boundaries ${CGoGN_LIBS_D} ${CGoGN_EXT_LIBS} )
Apps/Tuto/Boundary/boundaries.cpp 0 → 100644
View file @ 2f3a34b6
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your *
* option) any later version. *
* *
* This library is distributed in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License *
* for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with this library; if not, write to the Free Software Foundation, *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
* *
* Web site: http://cgogn.unistra.fr/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
#include "Topology/generic/parameters.h"
#include "Topology/map/embeddedMap2.h"
#include "Algo/Tiling/Surface/square.h"
using namespace CGoGN ;
/**
* Struct that contains some informations about the types of the manipulated objects
* Mainly here to be used by the algorithms that are parameterized by it
*/
struct PFP: public PFP_STANDARD
{
// definition of the type of the map
typedef EmbeddedMap2 MAP;
};
// some typedef shortcuts
typedef PFP::MAP MAP ; // map type
typedef PFP::MAP::IMPL MAP_IMPL ; // map implementation
typedef PFP::VEC3 VEC3 ; // type of R³ vector
int main()
{
// declare a map to handle the mesh
MAP myMap;
// add position attribute on vertices and get handler on it
VertexAttribute<VEC3, MAP_IMPL> position = myMap.addAttribute<VEC3, VERTEX>("position");
// create a topo grid of 2x2 squares
Algo::Surface::Tilings::Square::Grid<PFP> grid(myMap, 3, 3, true);
// and embed it using position attribute
grid.embedIntoGrid(position, 1.,1.,0.);
// traverse all darts of map and test if they belong to the boundary
for (Dart d = myMap.begin(); d != myMap.end(); myMap.next(d))
{
if (myMap.isBoundaryMarked<2>(d)) // 2 because myMap is Map2 (can use isBoundaryMarkedCurrent)
std::cout << "Dart of boundary" << std::endl;
}
std::cout << std::endl;
// traverse all vertices of mesh and test if they belong to the boundary
foreach_cell<VERTEX>(myMap,[&myMap](Vertex v) // for all edge e of map do
{
if (myMap.isBoundaryVertex(v))
std::cout << "vertex of boundary"<< std::endl;
else
std::cout << "normal vertex"<< std::endl;
});
std::cout << std::endl;
// traverse all edges of mesh and test if they belong to the boundary
foreach_cell<EDGE>(myMap,[&myMap](Edge e) // for all edge e of map do
{
if (myMap.isBoundaryEdge(e))
std::cout << "edge of boundary"<< std::endl;
else
std::cout << "normal edge"<< std::endl;
});
std::cout << std::endl;
//It does not work with FACE because foreach and Traversors do not traverse the boundary faces
foreach_cell<FACE>(myMap,[&myMap](Face v) // for all edge e of map do
{
if (myMap.isBoundaryMarked<2>(v.dart))
std::cout << "boundary face"<< std::endl;
else
std::cout << "normal face"<< std::endl;
});
std::cout << std::endl;
return 0;
}
Apps/Tuto/Markers/CMakeLists.txt 0 → 100644
View file @ 2f3a34b6
cmake_minimum_required(VERSION 2.8)
project(Tuto_Traversals)
SET (CMAKE_BUILD_TYPE Debug)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNOTOPOWARNING")
include_directories(
${CMAKE_CURRENT_BINARY_DIR}
${CGoGN_ROOT_DIR}/include
${CGoGN_EXT_INCLUDES}
)
# define libs path
IF(WIN32)
link_directories(${CGoGN_ROOT_DIR}/lib/$(ConfigurationName)
${Boost_LIBRARY_DIRS})
ELSE(WIN32)
link_directories(${CGoGN_ROOT_DIR}/lib/Release ${CGoGN_ROOT_DIR}/lib/Debug)
ENDIF(WIN32)
#define exec to compile
add_executable( dartmarkers dartmarkers.cpp)
target_link_libraries( dartmarkers ${CGoGN_LIBS_D} ${CGoGN_EXT_LIBS} )
add_executable( cellmarkers cellmarkers.cpp)
target_link_libraries( cellmarkers ${CGoGN_LIBS_D} ${CGoGN_EXT_LIBS} )
Apps/Tuto/Markers/cellmarkers.cpp 0 → 100644
View file @ 2f3a34b6
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your *
* option) any later version. *
* *
* This library is distributed in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License *
* for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with this library; if not, write to the Free Software Foundation, *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
* *
* Web site: http://cgogn.unistra.fr/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
#include "Topology/generic/parameters.h"
#include "Topology/map/embeddedMap2.h"
#include "Algo/Tiling/Surface/square.h"
#include "Topology/generic/cellmarker.h"
using namespace CGoGN ;
/**
* Struct that contains some informations about the types of the manipulated objects
* Mainly here to be used by the algorithms that are parameterized by it
*/
struct PFP: public PFP_STANDARD
{
// definition of the type of the map
typedef EmbeddedMap2 MAP;
};
// some typedef shortcuts
typedef PFP::MAP MAP ; // map type
typedef PFP::MAP::IMPL MAP_IMPL ; // map implementation
typedef PFP::VEC3 VEC3 ; // type of R³ vector
// example of cell marking with CellMarker for a simple traversal
template<unsigned int ORBIT>
void simpleTraversal(MAP& map) // NEVER COPY THE MAP, ALWAYS USE REFERENCE !!
{
CellMarker<MAP,ORBIT> cm(map);
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (!cm.isMarked(d)) // is the cell (of dart d) not marked ?
{
std::cout << orbitName(ORBIT)<< " of dart "<< d << std::endl;
cm.mark(d); // mark the cell
}
}
std::cout << std::endl;
// all cells are unmarked automatically during the destruction of the CellMarker
}
// example of cell marking with CellMarkerNoUnmark for a double traversal
template<unsigned int ORBIT>
void doubleTraversal(MAP& map) // NEVER COPY THE MAP, ALWAYS USE REFERENCE !!
{
CellMarkerNoUnmark<MAP,ORBIT> cm(map);
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (!cm.isMarked(d)) // is the cell (of dart d) not marked ?
{
std::cout << "First Pass" << orbitName(ORBIT)<< " of dart "<< d << std::endl;
cm.mark(d); // mark the cell
}
}
std::cout << std::endl;
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (cm.isMarked(d)) // is the cell (of dart d) marked ?
{
std::cout << "second Pass" << orbitName(ORBIT)<< " of dart "<< d << std::endl;
cm.unmark(d); // unmark the cell
}
}
std::cout << std::endl;
// destructor does not clean the markers
// user MUST ensure that he has unmark all he has marked
}
// example of usage of CellMarkerStore
void negativePositions(MAP& map, VertexAttribute<VEC3,MAP_IMPL>& position) // NEVER COPY THE MAP, ALWAYS USE REFERENCE !!
{
// if user knows that small numbers of cell will be marked
// it is more efficient to store them instead of traverse
// all darts for cleanning. CellMarkerStore do it for you.
CellMarkerStore<MAP,VERTEX> cms(map);
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (!cms.isMarked(d) && (position[d][0]<= 0.0) && (position[d][1]<= 0.0))
{
std::cout << "position["<<d<<"] < (0,0)" << std::endl;
cms.mark(d);
}
}
std::cout << std::endl;
}
int main()
{
// declare a map to handle the mesh
MAP myMap;
// add position attribute on vertices and get handler on it
VertexAttribute<VEC3, MAP_IMPL> position = myMap.addAttribute<VEC3, VERTEX>("position");
// create a topo grid of 2x2 squares
Algo::Surface::Tilings::Square::Grid<PFP> grid(myMap, 2, 2, true);
// and embed it using position attribute
grid.embedIntoGrid(position, 1.,1.,0.);
simpleTraversal<VERTEX>(myMap);
doubleTraversal<FACE>(myMap);
negativePositions(myMap,position);
return 0;
}
Apps/Tuto/Markers/dartmarkers.cpp 0 → 100644
View file @ 2f3a34b6
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your *
* option) any later version. *
* *
* This library is distributed in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License *
* for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with this library; if not, write to the Free Software Foundation, *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
* *
* Web site: http://cgogn.unistra.fr/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
#include "Topology/generic/parameters.h"
#include "Topology/map/embeddedMap2.h"
#include "Algo/Tiling/Surface/square.h"
#include "Topology/generic/dartmarker.h"
using namespace CGoGN ;
/**
* Struct that contains some informations about the types of the manipulated objects
* Mainly here to be used by the algorithms that are parameterized by it
*/
struct PFP: public PFP_STANDARD
{
// definition of the type of the map
typedef EmbeddedMap2 MAP;
};
// some typedef shortcuts
typedef PFP::MAP MAP ; // map type
typedef PFP::MAP::IMPL MAP_IMPL ; // map implementation
typedef PFP::VEC3 VEC3 ; // type of R³ vector
// example of cell marking with CellMarker for a simple traversal
template<unsigned int ORBIT>
void simpleTraversal(MAP& map) // NEVER COPY THE MAP, ALWAYS USE REFERENCE !!
{
DartMarker<MAP> dm(map);
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (!dm.isMarked(d)) // is dart not marked ?
{
std::cout << orbitName(ORBIT)<< " of dart "<< d << std::endl;
dm.markOrbit<ORBIT>(d); // mark all darts of orbit
}
}
std::cout << std::endl;
// all darts are unmarked automatically during the destruction of the DartMarker
}
// example of cell marking with CellMarkerNoUnmark for a double traversal
template<unsigned int ORBIT>
void doubleTraversal(MAP& map) // NEVER COPY THE MAP, ALWAYS USE REFERENCE !!
{
DartMarkerNoUnmark<MAP> dm(map);
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (!dm.isMarked(d)) // is dart not marked ?
{
std::cout << "First Pass" << orbitName(ORBIT)<< " of dart "<< d << std::endl;
dm.markOrbit<ORBIT>(d); // mark the orbit
}
}
std::cout << std::endl;
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (dm.isMarked(d)) // is marked ?
{
std::cout << "second Pass" << orbitName(ORBIT)<< " of dart "<< d << std::endl;
dm.unmarkOrbit<ORBIT>(d); // unmark the orbit
}
}
std::cout << std::endl;
// destructor does not clean the markers
// user MUST ensure that he has unmark all he has marked
}
// example of usage of CellMarkerStore
void negativePositions(MAP& map, VertexAttribute<VEC3,MAP_IMPL>& position) // NEVER COPY THE MAP, ALWAYS USE REFERENCE !!
{
// if user knows that small numbers of cell will be marked
// it is more efficient to store them instead of traverse
// all darts for cleanning. CellMarkerStore do it for you.
DartMarkerStore<MAP> dms(map);
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (!dms.isMarked(d) && (position[d][0]<= 0.0) && (position[d][1]<= 0.0))
{
std::cout << "position["<<d<<"] < (0,0)" << std::endl;
dms.markOrbit<VERTEX>(d);
}
}
std::cout << std::endl;
}
int main()
{
// declare a map to handle the mesh
MAP myMap;
// add position attribute on vertices and get handler on it
VertexAttribute<VEC3, MAP_IMPL> position = myMap.addAttribute<VEC3, VERTEX>("position");
// create a topo grid of 2x2 squares
Algo::Surface::Tilings::Square::Grid<PFP> grid(myMap, 2, 2, true);
// and embed it using position attribute
grid.embedIntoGrid(position, 1.,1.,0.);
simpleTraversal<VERTEX>(myMap);
doubleTraversal<FACE>(myMap);
negativePositions(myMap,position);
return 0;
}
Apps/Tuto/Modelling/CMakeLists.txt 0 → 100644
View file @ 2f3a34b6
cmake_minimum_required(VERSION 2.8)
project(Tuto_Traversals)
SET (CMAKE_BUILD_TYPE Debug)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DNOTOPOWARNING")
include_directories(
${CMAKE_CURRENT_BINARY_DIR}
${CGoGN_ROOT_DIR}/include
${CGoGN_EXT_INCLUDES}
)
# define libs path
IF(WIN32)
link_directories(${CGoGN_ROOT_DIR}/lib/$(ConfigurationName)
${Boost_LIBRARY_DIRS})
ELSE(WIN32)
link_directories(${CGoGN_ROOT_DIR}/lib/Release ${CGoGN_ROOT_DIR}/lib/Debug)
ENDIF(WIN32)
#define exec to compile
add_executable( basics basics.cpp)
target_link_libraries( basics ${CGoGN_LIBS_D} ${CGoGN_EXT_LIBS} )
Apps/Tuto/Modelling/basics.cpp 0 → 100644
View file @ 2f3a34b6
/*******************************************************************************
* CGoGN: Combinatorial and Geometric modeling with Generic N-dimensional Maps *
* version 0.1 *
* Copyright (C) 2009-2012, IGG Team, LSIIT, University of Strasbourg *
* *
* This library is free software; you can redistribute it and/or modify it *
* under the terms of the GNU Lesser General Public License as published by the *
* Free Software Foundation; either version 2.1 of the License, or (at your *
* option) any later version. *
* *
* This library is distributed in the hope that it will be useful, but WITHOUT *
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or *
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License *
* for more details. *
* *
* You should have received a copy of the GNU Lesser General Public License *
* along with this library; if not, write to the Free Software Foundation, *
* Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
* *
* Web site: http://cgogn.unistra.fr/ *
* Contact information: cgogn@unistra.fr *
* *
*******************************************************************************/
#include "Topology/generic/parameters.h"
#include "Topology/map/embeddedMap2.h"
#include "Algo/Tiling/Surface/square.h"
#include "Topology/generic/cellmarker.h"
using namespace CGoGN ;
/**
* Struct that contains some informations about the types of the manipulated objects
* Mainly here to be used by the algorithms that are parameterized by it
*/
struct PFP: public PFP_STANDARD
{
// definition of the type of the map
typedef EmbeddedMap2 MAP;
};
// some typedef shortcuts
typedef PFP::MAP MAP ; // map type
typedef PFP::MAP::IMPL MAP_IMPL ; // map implementation
typedef PFP::VEC3 VEC3 ; // type of R³ vector
// example of cell marking with CellMarker for a simple traversal
template<unsigned int ORBIT>
void simpleTraversal(MAP& map) // NEVER COPY THE MAP, ALWAYS USE REFERENCE !!
{
CellMarker<MAP,ORBIT> cm(map);
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (!cm.isMarked(d)) // is the cell (of dart d) not marked ?
{
std::cout << orbitName(ORBIT)<< " of dart "<< d << std::endl;
cm.mark(d); // mark the cell
}
}
std::cout << std::endl;
// all cells are unmarked automatically during the destruction of the CellMarker
}
// example of cell marking with CellMarkerNoUnmark for a double traversal
template<unsigned int ORBIT>
void doubleTraversal(MAP& map) // NEVER COPY THE MAP, ALWAYS USE REFERENCE !!
{
CellMarkerNoUnmark<MAP,ORBIT> cm(map);
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (!cm.isMarked(d)) // is the cell (of dart d) not marked ?
{
std::cout << "First Pass" << orbitName(ORBIT)<< " of dart "<< d << std::endl;
cm.mark(d); // mark the cell
}
}
std::cout << std::endl;
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (cm.isMarked(d)) // is the cell (of dart d) marked ?
{
std::cout << "second Pass" << orbitName(ORBIT)<< " of dart "<< d << std::endl;
cm.unmark(d); // unmark the cell
}
}
std::cout << std::endl;
// destructor does not clean the markers
// user MUST ensure that he has unmark all he has marked
}
// example of usage of CellMarkerStore
void negativePositions(MAP& map, VertexAttribute<VEC3,MAP_IMPL>& position) // NEVER COPY THE MAP, ALWAYS USE REFERENCE !!
{
// if user knows that small numbers of cell will be marked
// it is more efficient to store them instead of traverse
// all darts for cleanning. CellMarkerStore do it for you.
CellMarkerStore<MAP,VERTEX> cms(map);
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (!cms.isMarked(d) && (position[d][0]<= 0.0) && (position[d][1]<= 0.0))
{
std::cout << "position["<<d<<"] < (0,0)" << std::endl;
cms.mark(d);
}
}
std::cout << std::endl;
}
int main()
{
// declare a map to handle the mesh
MAP myMap;
// add position attribute on vertices and get handler on it
VertexAttribute<VEC3, MAP_IMPL> position = myMap.addAttribute<VEC3, VERTEX>("position");
// create a triangle
Face f1 = myMap.newFace(3);
// create a quad
Face f2 = myMap.newFace(4);
// sew them together
myMap.sewFaces(f1,f2);
// and set the position of the vertices
Dart d1 = f1;
position[d1] = VEC3(0, 0, 0);
d1 = myMap.phi1(d1);
position[d1] = VEC3(2, 0, 0);
d1 = myMap.phi1(d1);
position[d1] = VEC3(1, 2, 0);
position[myMap.phi<11>(f2.dart)] = VEC3(0, -2, 0);
position[myMap.phi_1(f2.dart)] = VEC3(2, -2, 0);
return 0;
}
include/Algo/Geometry/normal.hpp
View file @ 2f3a34b6
......@@ -123,7 +123,7 @@ typename V_ATT::DATA_TYPE vertexBorderNormal(typename PFP::MAP& map, Vertex v, c
for(std::vector<Dart>::iterator it = faces.begin() ; it != faces.end() ; ++it)
{
if(!f.isMarked(*it) && map.isBoundaryFace(*it))
if(!f.isMarked(*it) && map.isBoundaryIncidentFace(*it))
{
f.mark(*it);
VEC3 n = faceNormal<PFP>(map, *it, position);
......
include/Algo/Modelisation/subdivision3.hpp
View file @ 2f3a34b6
......@@ -744,7 +744,7 @@ void sqrt3Vol(typename PFP::MAP& map, VertexAttribute<typename PFP::VEC3, typena
TraversorW<MAP> tWb(map);
for(Dart dit = tWb.begin() ; dit != tWb.end() ; dit = tWb.next())
{
if(map.isBoundaryVolume(dit))
if(map.isBoundaryAdjacentVolume(dit))
{
Traversor3WE<MAP> tWE(map, dit);
for(Dart ditWE = tWE.begin() ; ditWE != tWE.end() ; ditWE = tWE.next())
......
include/Algo/Multiresolution/Map3MR/Filters/lerp.h
View file @ 2f3a34b6
......@@ -678,7 +678,7 @@ public:
{
Dart dit = d;
if(m_map.isBoundaryVolume(d))
if(m_map.isBoundaryAdjacentVolume(d))
{
dit = findDartOfCentralVertex(d);
}
......
include/Algo/Multiresolution/Map3MR/Masks/schemes_Primal.h
View file @ 2f3a34b6
......@@ -920,7 +920,7 @@ public:
for (Dart ditW = trav.begin(); ditW != trav.end(); ditW = trav.next())
{
if(m_map.isBoundaryVolume(ditW))
if(m_map.isBoundaryAdjacentVolume(ditW))
{
typename PFP::VEC3 p = Algo::Geometry::volumeCentroid<PFP>(m_map, ditW, m_position);
......
include/Algo/Multiresolution/Map3MR/map3MR_PrimalRegular.hpp
View file @ 2f3a34b6
......@@ -366,7 +366,7 @@ void Map3MR<PFP>::addNewLevelSqrt3(bool embedNewVertices, VertexAttribute<typena
TraversorW<typename PFP::MAP> tWb(m_map);
for(Dart dit = tWb.begin() ; dit != tWb.end() ; dit = tWb.next())
{
if(m_map.isBoundaryVolume(dit))
if(m_map.isBoundaryAdjacentVolume(dit))
{
Traversor3WE<typename PFP::MAP> tWE(m_map, dit);