Commit 2cb734d8 authored by untereiner's avatar untereiner

new Polyhedra creation functions (createPrism, createPyramid, createDiamond)

parent 26eef763
......@@ -31,7 +31,7 @@ SimpleGMap2::SimpleGMap2()
{
position = myMap.addAttribute<PFP::VEC3>(VERTEX, "position");
Dart d = Algo::Modelisation::Polyhedron<PFP>::createTetra(myMap);
Dart d = Algo::Modelisation::createTetrahedron<PFP>(myMap);
position[d] = VEC3(0,0,0);
position[myMap.phi1(d)] = VEC3(10,0,15);
position[myMap.phi_1(d)] = VEC3(10,20,15);
......
......@@ -123,7 +123,7 @@ void MyQT::traverseMap()
void MyQT::createMap()
{
Dart d1 = Algo::Modelisation::Polyhedron<PFP>::createTetra(myMap);
Dart d1 = Algo::Modelisation::createTetrahedron<PFP>(myMap);
Dart d2 = d1;
......
......@@ -126,7 +126,7 @@ void MyQT::traverseMap()
void MyQT::createMap()
{
Dart d1 = Algo::Modelisation::Polyhedron<PFP>::createHexa(myMap);
Dart d1 = Algo::Modelisation::createHexahedron<PFP>(myMap);
Dart d2 = d1;
......
......@@ -59,6 +59,8 @@ public:
~ImplicitHierarchicalMap3() ;
void update_topo_shortcuts();
//!
/*!
*
......
......@@ -63,6 +63,16 @@ AttributeHandler_IHM<T> ImplicitHierarchicalMap3::getAttribute(unsigned int orbi
return AttributeHandler_IHM<T>(this, h.getDataVector()) ;
}
inline void ImplicitHierarchicalMap3::update_topo_shortcuts()
{
Map3::update_topo_shortcuts();
m_dartLevel = Map3::getAttribute<unsigned int>(DART, "dartLevel") ;
m_faceId = Map3::getAttribute<unsigned int>(DART, "faceId") ;
m_edgeId = Map3::getAttribute<unsigned int>(DART, "edgeId") ;
}
/***************************************************
* MAP TRAVERSAL *
***************************************************/
......
......@@ -57,7 +57,7 @@ namespace Import
namespace ImportVolumique
{
enum ImportType { UNKNOWNVOLUME ,TET ,TRIANBGZ ,PLY };
enum ImportType { UNKNOWNVOLUME ,TET ,TRIANBGZ ,PLY ,OFF, OBJ };
}
......
......@@ -25,6 +25,7 @@
#include "Topology/generic/attributeHandler.h"
#include "Topology/generic/autoAttributeHandler.h"
#include "Container/fakeAttribute.h"
#include "Algo/Modelisation/polyhedron.h"
namespace CGoGN
{
......@@ -128,6 +129,111 @@ bool importMesh(typename PFP::MAP& map, MeshTablesSurface<PFP>& mts)
return true ;
}
template <typename PFP>
bool importMeshSToV(typename PFP::MAP& map, MeshTablesSurface<PFP>& mts, float dist)
{
AutoAttributeHandler< NoMathIONameAttribute< std::vector<Dart> > > vecDartsPerVertex(map, VERTEX, "incidents");
unsigned nbf = mts.getNbFaces();
int index = 0;
// buffer for tempo faces (used to remove degenerated edges)
std::vector<unsigned int> edgesBuffer;
edgesBuffer.reserve(16);
DartMarkerNoUnmark m(map) ;
AttributeHandler<typename PFP::VEC3> position = map.template getAttribute<typename PFP::VEC3>(VERTEX, "position");
std::vector<unsigned int > backEdgesBuffer(mts.getNbVertices(), EMBNULL);
// for each face of table -> create a prism
for(unsigned int i = 0; i < nbf; ++i)
{
// store face in buffer, removing degenerated edges
unsigned int nbe = mts.getNbEdgesFace(i);
edgesBuffer.clear();
unsigned int prec = EMBNULL;
for (unsigned int j = 0; j < nbe; ++j)
{
unsigned int em = mts.getEmbIdx(index++);
if (em != prec)
{
prec = em;
edgesBuffer.push_back(em);
}
}
// check first/last vertices
if (edgesBuffer.front() == edgesBuffer.back())
edgesBuffer.pop_back();
// create only non degenerated faces
nbe = edgesBuffer.size();
if (nbe > 2)
{
Dart d = Algo::Modelisation::createPrism<PFP>(map, nbe);
//Embed the base faces
for (unsigned int j = 0; j < nbe; ++j)
{
unsigned int em = edgesBuffer[j]; // get embedding
if(backEdgesBuffer[em] == EMBNULL)
{
unsigned int emn = map.newCell(VERTEX);
map.copyCell(VERTEX, emn, em);
backEdgesBuffer[em] = emn;
position[emn] += typename PFP::VEC3(0,0,dist);
}
FunctorSetEmb<typename PFP::MAP> fsetemb(map, VERTEX, em);
foreach_dart_of_orbit_in_parent<typename PFP::MAP>(&map, VERTEX, d, fsetemb) ;
//Embed the other base face
Dart d2 = map.phi1(map.phi1(map.phi2(d)));
unsigned int em2 = backEdgesBuffer[em];
FunctorSetEmb<typename PFP::MAP> fsetemb2(map, VERTEX, em2);
foreach_dart_of_orbit_in_parent<typename PFP::MAP>(&map, VERTEX, d2, fsetemb2) ;
m.mark(d) ; // mark on the fly to unmark on second loop
vecDartsPerVertex[em].push_back(d); // store incident darts for fast adjacency reconstruction
d = map.phi1(d);
}
}
}
// reconstruct neighbourhood
unsigned int nbBoundaryEdges = 0;
for (Dart d = map.begin(); d != map.end(); map.next(d))
{
if (m.isMarked(d))
{
// darts incident to end vertex of edge
std::vector<Dart>& vec = vecDartsPerVertex[map.phi1(d)];
unsigned int embd = map.getEmbedding(VERTEX, d);
Dart good_dart = NIL;
for (typename std::vector<Dart>::iterator it = vec.begin(); it != vec.end() && good_dart == NIL; ++it)
{
if (map.getEmbedding(VERTEX, map.phi1(*it)) == embd)
good_dart = *it;
}
if (good_dart != NIL)
{
map.sewVolumes(map.phi2(d), map.phi2(good_dart), false);
m.unmarkOrbit(EDGE, d);
}
else
{
m.unmark(d);
++nbBoundaryEdges;
}
}
}
return true ;
}
template <typename PFP>
bool importMesh(typename PFP::MAP& map, MeshTablesVolume<PFP>& mtv)
{
......@@ -441,179 +547,40 @@ bool importMesh(typename PFP::MAP& map, const std::string& filename, std::vector
return importMesh<PFP>(map, mts);
}
/*
template <typename PFP>
bool importMesh(typename PFP::MAP& map, const std::string& filename, std::vector<std::string>& attrNames, ImportVolumique::ImportType kind)
{
MeshTablesVolume<PFP> mtv(map);
float dist = 5.0f;
if(!mtv.importMesh(filename, attrNames, kind))
return false;
if(kind == ImportVolumique::OBJ)
{
MeshTablesSurface<PFP> mts(map);
return importMesh<PFP>(map, mtv);
}
*/
//
//
//
// AutoAttributeHandler< NoMathIONameAttribute< std::vector<Dart> > > vecDartsPerVertex(map, VERTEX, "incidents");
//
//
// // Attributes container for vertex orbit
// AttributeContainer& vertexContainer = map.getAttributeContainer(VERTEX);
//
// AttributeHandler<VEC3> positions(idPositions,map);
//
// MeshTablesSurface<VEC3> mts(vertexContainer, positions);
//
// if (!mts.importMesh(filename,kind))
// return false;
//
// // marker for phi2 reconstruction
// m = map.getNewMarker();
//
// unsigned nbf = mts.getNbFaces();
// int index = 0;
// // buffer for tempo faces (used to remove degenerated edges)
// std::vector<unsigned int> edgesBuffer;
// edgesBuffer.reserve(8);
//
// // for each face of table
// for(unsigned int i = 0; i < nbf; ++i)
// {
// // store face in buffer, removing degenerated edges
// unsigned int nbe = mts.getNbEdgesFace(i);
// edgesBuffer.clear();
// unsigned int prec=EMBNULL;
// for (unsigned int j=0; j<nbe; ++j)
// {
// unsigned int em = mts.getEmbIdx(index++);
// if (em!=prec)
// {
// prec = em;
// edgesBuffer.push_back(em);
// }
// }
// // check first/last vertices
// if (edgesBuffer.front() == edgesBuffer.back())
// edgesBuffer.pop_back();
//
// // create only non degenerated faces
// nbe = edgesBuffer.size();
// if (nbe >2)
// {
// Dart d = map.newFace(nbe);
// for (unsigned int j=0; j<nbe; ++j)
// {
// unsigned int em = edgesBuffer[j]; // get embedding
// map.setDartEmbedding(VERTEX, d, em); // associate to dart
// vecDartsPerVertex[em].push_back(d); // store incident darts for fast phi2 reconstruction
// d = map.phi1(d);
// }
// map.markOrbit(FACE,d,m);// mark on the fly to unmark on second loop
// }
// }
//
// unsigned nbnm=0;
// // reconstruct neighbourhood
//
// for (Dart d = map.begin(); d != map.end(); map.next(d))
if(!mts.importMesh(filename, attrNames, ImportSurfacique::OBJ))
return false;
//if (mergeCloseVertices)
// mts.mergeCloseVertices();
return importMeshSToV<PFP>(map, mts, dist);
}
else
return false;
// else
// {
// if (map.isMarkedDart(d, m))
// {
// // darts incident to end vertex of edge
// std::vector<Dart>& vec = vecDartsPerVertex[map.phi1(d)];
// MeshTablesVolume<PFP> mtv(map);
//
// unsigned int embd = map.getEmbedding(VERTEX, d);
// unsigned int nbf=0;
// Dart good_dart;
// for (typename std::vector<Dart>::iterator it = vec.begin(); it != vec.end(); ++it)
// {
// if ( map.getEmbedding(VERTEX,map.phi1(*it))==embd)
// {
// good_dart = *it;
// nbf++;
// }
// }
//
// if (nbf==1)
// {
// if (good_dart == map.phi2(good_dart))
// {
// map.sewFaces(d, good_dart);
// map.unmarkOrbit(EDGE, d, m);
// }
// }
// else
// {
// ++nbnm;
// }
// }
// }
//
//
//// return true;
// if(!mtv.importMesh(filename, attrNames, kind))
// return false;
//
// if (nbnm > 0)
// {
// if (closeObject)
// {
// Marker mb = map.closeMap(true);
//// // for all vertices
//// for (unsigned int index = 0; index < vecDartsEmb.size(); ++index)
//// {
//// // if vertex is on boundary
//// if (vecEmbNbFp[index] > 0)
//// {
//// // find first dart that is sewed to boundary
//// std::vector<Dart>& vd = vecDartsEmb[index];
//// typename std::vector<Dart>::iterator jt = vd.begin();
//// while (!map.isMarkedDart(*jt, m))
//// jt++;
//// unsigned int P = map.getEmbedding(VERTEX, *jt);
//// // while vertex if a "non manifold point"
//// while (vecEmbNbFp[index] > 1)
//// {
//// Dart e = map.phi2(*jt);
//// // turn in boundary until we find same embedding
//// do
//// {
//// e = map.phi1(e);
//// // embedding of boundary darts on the fly
//// unsigned int emb = map.getEmbedding(VERTEX, map.phi1(map.phi2(e)));
//// map.setDartEmbedding(VERTEX, e, emb);
//// } while (map.getEmbedding(VERTEX, map.phi2(e)) != P);
//// // separate the face
//// map.phi1sew(map.phi2(*jt), e);
//// vecEmbNbFp[index]--;
//// }
//// // copy embedding of vertex of boundary of last face
//// Dart e = map.phi2(*jt);
//// Dart d = e;
//// if (map.getEmbedding(VERTEX, d) == EMBNULL)
//// {
//// do
//// {
//// unsigned int emb = map.getEmbedding(VERTEX, map.phi1(map.phi2(d)));
//// map.setDartEmbedding(VERTEX, d, emb);
//// d = map.phi1(d);
//// } while (d != e);
//// }
//// }
//// }
// map.unmarkAll(m);
// map.releaseMarker(m);
// m = mb;
// }
// else
// {
// CGoGNout << "Warning " << nbnm << " darts with phi2 fix points" << CGoGNendl;
// }
// return importMesh<PFP>(map, mtv);
// }
//
// return true;
//}
}
} // namespace Import
......
......@@ -114,7 +114,7 @@ bool importTet(typename PFP::MAP& map, const std::string& filename, std::vector<
oss >> nbe; //number of vertices = 4
assert(nbe == 4);
Dart d = Algo::Modelisation::Polyhedron<PFP>::createPolyhedron(map, 4);
Dart d = Algo::Modelisation::createTetrahedron<PFP>(map);
Geom::Vec4ui pt;
oss >> pt[0];
......
......@@ -132,7 +132,7 @@ bool importTs(typename PFP::MAP& map, const std::string& filename, std::vector<s
// CGoGNout << "tetra number : " << nbe << CGoGNendl;
//Algo::Modelisation::Polyhedron<PFP>::createTetra(map);
Dart d = Algo::Modelisation::Polyhedron<PFP>::createPolyhedron(map,4);
Dart d = Algo::Modelisation::createTetrahedron<PFP>(map);
Geom::Vec4ui pt;
oss >> pt[0];
oss >> pt[1];
......
......@@ -42,7 +42,7 @@ namespace Algo
namespace Modelisation
{
enum { NONE,GRID, CUBE, CYLINDER, CONE, SPHERE, TORE, COMPOSED };
enum { NONE, GRID, CUBE, CYLINDER, CONE, SPHERE, TORE, COMPOSED };
/**
* sudivide the all quads of primtive into 2 triangles
......@@ -70,6 +70,64 @@ enum { NONE,GRID, CUBE, CYLINDER, CONE, SPHERE, TORE, COMPOSED };
template <typename PFP>
void explodPolyhedron(typename PFP::MAP& map, Dart d, typename PFP::TVEC3 position);
/**
* create a n-sided pyramid
*/
template <typename PFP>
Dart createPyramid(typename PFP::MAP& map, unsigned int nbSides);
/**
* create a n-sided prism
*/
template <typename PFP>
Dart createPrism(typename PFP::MAP& map, unsigned int nbSides);
/**
* create a n-sided diamond
*/
template <typename PFP>
Dart createDiamond(typename PFP::MAP& map, unsigned int nbSides);
/**
* create a tetrahedron
*/
template <typename PFP>
Dart createTetrahedron(typename PFP::MAP& map);
/**
* create a hexahedron
*/
template <typename PFP>
Dart createHexahedron(typename PFP::MAP& map);
/**
* create a 3-sided prism
*/
template <typename PFP>
Dart createTriangularPrism(typename PFP::MAP& map);
/**
* create a 3-sided pyramid
*/
template <typename PFP>
Dart createQuadrangularPyramid(typename PFP::MAP& map);
/**
* create 4-sided diamond (i.e. an octahedron)
*/
template <typename PFP>
Dart createOctahedron(typename PFP::MAP& map);
/**
* class of geometric Polyhedron
* It alloaw the creation of:
......@@ -82,7 +140,6 @@ void explodPolyhedron(typename PFP::MAP& map, Dart d, typename PFP::TVEC3 positi
*
* Topological creation methods are separated from embedding to
* easily allow specific embedding.
*/
template <typename PFP>
class Polyhedron
......@@ -167,30 +224,6 @@ public:
*/
Polyhedron(const Polyhedron<PFP>& p1, const Polyhedron<PFP>& p2);
/**
* create simple simple polyhedron (not handled by Polyhedron object)
*/
static Dart createPolyhedron(typename PFP::MAP& the_map, unsigned int nbFaces);
/**
* create simple simple tetrahedron (not handled by Polyhedron object)
*/
static Dart createTetra(typename PFP::MAP& the_map);
/**
* create simple simple pyramid (not handled by Polyhedron object)
*/
static Dart createPyra(typename PFP::MAP& the_map);
/**
* create simple simple hexaedron (not handled by Polyhedron object)
*/
static Dart createHexa(typename PFP::MAP& the_map);
/**
* create simple simple prism (not handled by Polyhedron object)
*/
static Dart createPrism(typename PFP::MAP& the_map);
/*
* get the reference dart
......
......@@ -31,6 +31,170 @@ namespace Algo
namespace Modelisation
{
/**
* create a n-sided pyramid
*/
template <typename PFP>
Dart createPyramid(typename PFP::MAP& map, unsigned int n)
{
Dart dres = Dart::nil();
std::vector<Dart> m_tableVertDarts;
m_tableVertDarts.reserve(n);
// creation of triangles around circunference and storing vertices
for (unsigned int i = 0; i < n; ++i)
{
Dart d = map.newFace(3, false);
m_tableVertDarts.push_back(d);
}
// sewing the triangles
for (unsigned int i = 0; i < n-1; ++i)
{
Dart d = m_tableVertDarts[i];
d = map.phi_1(d);
Dart e = m_tableVertDarts[i+1];
e = map.phi1(e);
map.sewFaces(d, e, false);
}
//sewing the last with the first
map.sewFaces(map.phi1(m_tableVertDarts[0]), map.phi_1(m_tableVertDarts[n-1]), false);
//sewing the bottom face
Dart d1 = map.newFace(n, false);
dres = d1;
for(unsigned int i = 0; i < n ; ++i)
{
map.sewFaces(m_tableVertDarts[i], d1, false);
d1 = map.phi1(d1);
}
//return a dart from the base
return dres;
}
/**
* create a n-sided prism
*/
template <typename PFP>
Dart createPrism(typename PFP::MAP& map, unsigned int n)
{
Dart dres = Dart::nil();
unsigned int nb = n*2;
std::vector<Dart> m_tableVertDarts;
m_tableVertDarts.reserve(nb);
// creation of quads around circunference and storing vertices
for (unsigned int i = 0; i < n; ++i)
{
Dart d = map.newFace(4, false);
m_tableVertDarts.push_back(d);
}
// storing a dart from the vertex pointed by phi1(phi1(d))
for (unsigned int i = 0; i < n; ++i)
{
m_tableVertDarts.push_back(map.phi1(map.phi1(m_tableVertDarts[i])));
}
// sewing the quads
for (unsigned int i = 0; i < n-1; ++i)
{
Dart d = m_tableVertDarts[i];
d = map.phi_1(d);
Dart e = m_tableVertDarts[i+1];
e = map.phi1(e);
map.sewFaces(d, e, false);
}
//sewing the last with the first
map.sewFaces(map.phi1(m_tableVertDarts[0]), map.phi_1(m_tableVertDarts[n-1]), false);
//sewing the top & bottom faces
Dart d1 = map.newFace(n, false);
Dart d2 = map.newFace(n, false);
dres = d1;
for(unsigned int i = 0; i < n ; ++i)
{
map.sewFaces(m_tableVertDarts[i], d1, false);
map.sewFaces(m_tableVertDarts[n+i], d2, false);
d1 = map.phi1(d1);
d2 = map.phi_1(d2);
}
//return a dart from the base
return dres;
}
/**
* create a n-sided diamond
*/
template <typename PFP>
Dart createDiamond(typename PFP::MAP& map, unsigned int nbSides)
{
Dart res = Dart::nil();
Dart firstP = createPyramid<PFP>(map,nbSides);
Dart secondP = createPyramid<PFP>(map,nbSides);
res = map.phi2(firstP);
map.sewVolumes(firstP, secondP);
map.mergeVolumes(firstP);