void TriangleSetTopologyContainer::createTrianglesAroundEdgeArray ()
{
if(!hasTriangles()) // this method should only be called when triangles exist
{
#ifndef NDEBUG
sout << "Warning. [TriangleSetTopologyContainer::createTrianglesAroundEdgeArray] triangle array is empty." << sendl;
#endif
createTriangleSetArray();
}
if(!hasEdges()) // this method should only be called when edges exist
{
#ifndef NDEBUG
sout << "Warning. [TriangleSetTopologyContainer::createTrianglesAroundEdgeArray] edge array is empty." << sendl;
#endif
createEdgeSetArray();
}
if(!hasEdgesInTriangle())
createEdgesInTriangleArray();
const unsigned int numTriangles = getNumberOfTriangles();
const unsigned int numEdges = getNumberOfEdges();
if(hasTrianglesAroundEdge())
{
clearTrianglesAroundEdge();
}
m_trianglesAroundEdge.resize( numEdges );
for (unsigned int i = 0; i < numTriangles; ++i)
{
// adding triangle i in the triangle shell of all edges
for (unsigned int j=0; j<3; ++j)
{
m_trianglesAroundEdge[ m_edgesInTriangle[i][j] ].push_back( i );
}
}
}
void ManifoldTriangleSetTopologyContainer::createTrianglesAroundEdgeArray()
{
if(!hasTriangles()) // this method should only be called when triangles exist
{
#ifndef NDEBUG
std::cout << "Warning. [ManifoldTriangleSetTopologyContainer::createTrianglesAroundEdgeArray] Triangle array is empty." << std::endl;
#endif
createTriangleSetArray();
}
if(!hasEdges()) // this method should only be called when edges exist
{
#ifndef NDEBUG
std::cout << "Warning. [ManifoldTriangleSetTopologyContainer::createTrianglesAroundEdgeArray] Edge array is empty." << std::endl;
#endif
createEdgeSetArray();
}
if(!hasEdgesInTriangle())
createEdgesInTriangleArray();
if(hasTrianglesAroundEdge())
clearTrianglesAroundEdge();
//Number of different elements needed for this function
const unsigned int nbrEdges = getNumberOfEdges();
const unsigned int nbrTriangles = getNumberOfTriangles();
//Temporary objects
Triangle vertexTriangle;
int cpt;
int firstVertex;
int vertexInTriangle;
//Temporary containers
std::multimap<unsigned int, unsigned int> map_edgesInTriangle;
std::multimap<unsigned int, unsigned int>::iterator it;
std::pair< std::multimap <unsigned int, unsigned int>::iterator, std::multimap <unsigned int, unsigned int>::iterator> pair_equal_range;
helper::ReadAccessor< Data< sofa::helper::vector<Edge> > > m_edge = d_edge;
helper::ReadAccessor< Data< sofa::helper::vector<Triangle> > > m_triangle = d_triangle;
m_trianglesAroundEdge.resize(nbrEdges);
for (unsigned int triangleIndex = 0; triangleIndex < nbrTriangles; ++triangleIndex)
{
// adding triangle i in the triangle shell of all edges
for (unsigned int indexEdge = 0; indexEdge<3 ; ++indexEdge)
{
map_edgesInTriangle.insert(std::pair < unsigned int, unsigned int> (m_edgesInTriangle[triangleIndex][indexEdge], triangleIndex));
}
}
for (unsigned int indexEdge = 0; indexEdge < nbrEdges; indexEdge++)
{
cpt = map_edgesInTriangle.count(indexEdge);
if (cpt > 2)
{
#ifndef NDEBUG
std::cout << "Error. [ManifoldTriangleSetTopologyContainer::createTrianglesAroundEdgeArray] The mapping is not manifold.";
std::cout << "There are more than 2 triangles adjacents to the Edge: " << indexEdge << std::endl;
#endif
//Even if this structure is not Manifold, we chosed to fill the shell with all the triangles:
pair_equal_range = map_edgesInTriangle.equal_range(indexEdge);
for (it = pair_equal_range.first; it != pair_equal_range.second; ++it)
m_trianglesAroundEdge[indexEdge].push_back((*it).second);
}
else if (cpt == 1)
{
it = map_edgesInTriangle.find(indexEdge);
m_trianglesAroundEdge[indexEdge].push_back((*it).second);
}
else if (cpt == 2)
{
pair_equal_range = map_edgesInTriangle.equal_range(indexEdge);
it = pair_equal_range.first;
firstVertex = m_edge[indexEdge][0];
vertexTriangle = m_triangle[(*it).second];
vertexInTriangle = getVertexIndexInTriangle (vertexTriangle, firstVertex);
if ((unsigned int)m_edge[indexEdge][1] == (unsigned int)vertexTriangle[(vertexInTriangle+1)%3])
{
m_trianglesAroundEdge[indexEdge].push_back((*it).second);
it++;
m_trianglesAroundEdge[indexEdge].push_back((*it).second);
}
else
{
it++;
m_trianglesAroundEdge[indexEdge].push_back((*it).second);
it--;
m_trianglesAroundEdge[indexEdge].push_back((*it).second);
}
}
}
}
void ManifoldTriangleSetTopologyContainer::createEdgesAroundVertexArray()
{
if(!hasEdges()) // this method should only be called when edges exist
{
#ifndef NDEBUG
std::cout << "Warning. [ManifoldTriangleSetTopologyContainer::createEdgesAroundVertexArray] edge array is empty." << std::endl;
#endif
createEdgeSetArray();
}
if(hasEdgesAroundVertex())
{
clearEdgesAroundVertex();
}
//Number of different elements needed for this function
const unsigned int nbrVertices = getNbPoints();
const unsigned int nbrEdges = getNumberOfEdges();
const unsigned int nbrTriangles = getNumberOfTriangles();
//Temporary objects
Triangle vertexTriangle;
EdgesInTriangle edgeTriangle;
int cpt;
int firstVertex;
int nextVertex;
//Temporary containers
sofa::helper::vector< std::multimap<unsigned int, unsigned int> > map_Adjacents;
sofa::helper::vector< std::map<unsigned int, unsigned int> > map_NextEdgeVertex;
sofa::helper::vector< std::map<unsigned int, unsigned int> > map_OppositeEdgeVertex;
std::multimap<unsigned int, unsigned int>::iterator it_multimap;
std::map<unsigned int, unsigned int>::iterator it_map;
helper::ReadAccessor< Data< sofa::helper::vector<Edge> > > m_edge = d_edge;
m_edgesAroundVertex.resize(nbrVertices);
map_Adjacents.resize(nbrVertices);
map_NextEdgeVertex.resize(nbrVertices);
map_OppositeEdgeVertex.resize(nbrVertices);
/* Creation of the differents maps: For each vertex i of each triangles:
- map_NextEdgeVertex: key = vertex i+1, value = Edge i+2
- map_OppositeEdgeVertex: key = vertex i+1, value = vertex i+2
- map_Adjacents: key = vertex i+1 et i+2, value = Edge i */
for (unsigned int triangleIndex = 0; triangleIndex < nbrTriangles; triangleIndex++)
{
vertexTriangle = getTriangleArray()[triangleIndex];
edgeTriangle = getEdgesInTriangle(triangleIndex);
for (unsigned int i=0; i<3; ++i)
{
map_NextEdgeVertex[vertexTriangle[i]].insert(std::pair<unsigned int,unsigned int> (vertexTriangle[(i+1)%3], edgeTriangle[(i+2)%3]));
map_OppositeEdgeVertex[vertexTriangle[i]].insert(std::pair<unsigned int,unsigned int> (vertexTriangle[(i+1)%3], vertexTriangle[(i+2)%3]));
map_Adjacents[vertexTriangle[i]].insert(std::pair<unsigned int,unsigned int> (vertexTriangle[(i+1)%3], edgeTriangle[i]));
map_Adjacents[vertexTriangle[i]].insert(std::pair<unsigned int,unsigned int> (vertexTriangle[(i+2)%3], edgeTriangle[i]));
}
}
for (unsigned int vertexIndex = 0; vertexIndex < nbrVertices; vertexIndex++)
{
it_map = map_OppositeEdgeVertex[vertexIndex].begin();
firstVertex = (*it_map).first;
for (it_multimap = map_Adjacents[vertexIndex].begin(); it_multimap != map_Adjacents[vertexIndex].end(); it_multimap++)
{
cpt = (int)map_Adjacents[vertexIndex].count((*it_multimap).first);
if( cpt > 2)
{
//#ifndef NDEBUG
std::cout << "Error. [ManifoldTriangleSetTopologyContainer::createEdgesAroundVertexArray] The mapping is not manifold. ";
std::cout << "In the neighborhood of the vertex: " << vertexIndex;
std::cout << ". There are " << cpt << " edges connected to the vertex: " << (*it_multimap).first << std::endl;
//#endif
}
else if ( cpt == 1)
{
it_map = map_OppositeEdgeVertex[vertexIndex].find( (*it_multimap).first );
if(it_map != map_OppositeEdgeVertex[vertexIndex].end())
{
firstVertex = (*it_map).first;
}
}
}
m_edgesAroundVertex[vertexIndex].push_back(map_NextEdgeVertex[vertexIndex][firstVertex]);
nextVertex = (*(it_map = map_OppositeEdgeVertex[vertexIndex].find(firstVertex))).second;
for (unsigned int indexEdge = 1; indexEdge < map_OppositeEdgeVertex[vertexIndex].size(); indexEdge++)
{
m_edgesAroundVertex[vertexIndex].push_back(map_NextEdgeVertex[vertexIndex][nextVertex]);
nextVertex = (*(it_map = map_OppositeEdgeVertex[vertexIndex].find(nextVertex))).second;
//std::cout << "nextVertex: " << nextVertex << std::endl;
//si different de fin
}
if (nextVertex != firstVertex)
{
const Edge lastEdge = Edge(nextVertex,vertexIndex);
for ( unsigned int i = 0; i < nbrEdges; ++i)
{
if( m_edge[i][0] == lastEdge[0] && m_edge[i][1] == lastEdge[1])
{
m_edgesAroundVertex[vertexIndex].push_back(i);
break;
}
}
}
}
map_Adjacents.clear();
map_NextEdgeVertex.clear();
map_OppositeEdgeVertex.clear();
}
