//----------------------------------------------------------------------------
void CIsoSurface::MakeUnique (std::vector<TVector3D>& rkVA,
std::vector<TriangleKey>& rkTA)
{
int iVQuantity = (int)rkVA.size();
int iTQuantity = (int)rkTA.size();
if ( iVQuantity == 0 || iTQuantity == 0 )
return;
// use a hash table to generate unique storage
VMap kVMap;
VMapIterator pkVIter;
for (int iV = 0, iNextVertex = 0; iV < iVQuantity; iV++)
{
// keep only unique vertices
std::pair<VMapIterator,bool> kResult = kVMap.insert( std::make_pair(rkVA[iV],iNextVertex) );
if ( kResult.second == true )
iNextVertex++;
}
std::cerr << "Found " << kVMap.size() << " vertices" << std::endl;
// use a hash table to generate unique storage
TMap kTMap;
TMapIterator pkTIter;
for (int iT = 0, iNextTriangle = 0; iT < iTQuantity; iT++)
{
// replace old vertex indices by new ones
TriangleKey& rkTri = rkTA[iT];
pkVIter = kVMap.find(rkVA[rkTri.V[0]]);
assert( pkVIter != kVMap.end() );
rkTri.V[0] = pkVIter->second;
pkVIter = kVMap.find(rkVA[rkTri.V[1]]);
assert( pkVIter != kVMap.end() );
rkTri.V[1] = pkVIter->second;
pkVIter = kVMap.find(rkVA[rkTri.V[2]]);
assert( pkVIter != kVMap.end() );
rkTri.V[2] = pkVIter->second;
// keep only unique triangles
std::pair<TMapIterator,bool> kResult = kTMap.insert(
std::make_pair(rkTri,iNextTriangle));
if ( kResult.second == true )
iNextTriangle++;
}
// pack the vertices
rkVA.resize(kVMap.size());
for (pkVIter = kVMap.begin(); pkVIter != kVMap.end(); pkVIter++)
rkVA[pkVIter->second] = pkVIter->first;
// pack the triangles
rkTA.resize(kTMap.size());
for (pkTIter = kTMap.begin(); pkTIter != kTMap.end(); pkTIter++)
rkTA[pkTIter->second] = pkTIter->first;
}
//----------------------------------------------------------------------------
void ExtractCurveTris::MakeUnique (std::vector<Vector2f>& vertices,
std::vector<EdgeKey>& edges)
{
int numVertices = (int)vertices.size();
if (numVertices == 0)
{
return;
}
// Use maps to generate unique storage.
typedef std::map<Vector2f, int> VMap;
typedef std::map<Vector2f, int>::iterator VIterator;
VMap vertexMap;
for (int v = 0, nextVertex = 0; v < numVertices; ++v)
{
std::pair<VIterator, bool> result = vertexMap.insert(
std::make_pair(vertices[v], nextVertex));
if (result.second == true)
{
++nextVertex;
}
}
typedef std::map<EdgeKey, int> EMap;
typedef std::map<EdgeKey, int>::iterator EIterator;
EMap* edgeMap = 0;
int e;
VIterator vIter;
int numEdges = (int)edges.size();
if (numEdges)
{
edgeMap = new0 EMap();
int nextEdge = 0;
for (e = 0; e < numEdges; ++e)
{
// Replace old vertex indices by new ones.
vIter = vertexMap.find(vertices[edges[e].V[0]]);
assertion(vIter != vertexMap.end(), "Unexpected condition\n");
edges[e].V[0] = vIter->second;
vIter = vertexMap.find(vertices[edges[e].V[1]]);
assertion(vIter != vertexMap.end(), "Unexpected condition\n");
edges[e].V[1] = vIter->second;
// Keep only unique edges.
std::pair<EIterator, bool> result = edgeMap->insert(
std::make_pair(edges[e], nextEdge));
if (result.second == true)
{
++nextEdge;
}
}
}
// Pack the vertices into an array.
numVertices = (int)vertexMap.size();
vertices.resize(numVertices);
for (vIter = vertexMap.begin(); vIter != vertexMap.end(); ++vIter)
{
vertices[vIter->second] = vIter->first;
}
// Pack the edges into an array.
if (numEdges > 0)
{
numEdges = (int)edgeMap->size();
edges.resize(numEdges);
EIterator eIter;
for (eIter = edgeMap->begin(); eIter != edgeMap->end(); ++eIter)
{
edges[eIter->second] = eIter->first;
}
delete0(edgeMap);
}
else
{
edges.clear();
}
}
