void CRichModel::ComputeMaxEdgeLength()
{
maxEdgeLength = 0;
for(int i = 0; i < GetNumOfEdges();++i){
maxEdgeLength = max(maxEdgeLength,Edge(i).length );
}
meanEdgeLength = 0;
for(int i = 0; i < GetNumOfEdges();++i){
meanEdgeLength += Edge(i).length;
}
meanEdgeLength /= GetNumOfEdges();
}
bool CPlanarGraph::CheckDuplicatedEdge(const CGraphEdge& edge)
{
int idx10 = edge.GetIdx0();
int idx11 = edge.GetIdx1();
for ( int i=0; i<GetNumOfEdges(); i++ )
{
CGraphEdge& edge0 = GetEdge(i);
int idx00 = edge0.GetIdx0();
int idx01 = edge0.GetIdx1();
if ( (idx00 == idx10 && idx01 == idx11) || (idx00 == idx11 && idx01 == idx10) )
{
return true;
}
}
return false;
}
void CRichModel::ComputePlanarCoordsOfIncidentVertForEdges()
{
for (int i = 0; i < GetNumOfEdges(); ++i)
{
if (IsExtremeEdge(i))
continue;
double bottom = Edge(i).length;
double leftLen = Edge(Edge(i).indexOfLeftEdge).length;
double squareOfLeftLen = leftLen * leftLen;
double rightLen = Edge(Edge(i).indexOfRightEdge).length;
double x = (squareOfLeftLen - rightLen * rightLen) / bottom + bottom;
x /= 2.0;
m_Edges[i].xOfPlanarCoordOfOppositeVert = x;
m_Edges[i].yOfPlanarCoordOfOppositeVert = sqrt(max(0.0, squareOfLeftLen - x * x));
}
}
void CPlanarGraph::RemoveIndividualNodes()
{
int numOfNodes = GetNumOfNodes();
std::vector<bool> vecKeepFlags(numOfNodes, false);
std::vector<int> vecNewIndices(numOfNodes, -1);
std::vector<CGraphNode> nodesToKeep;
int keepCount = 0;
for ( int i=0; i<numOfNodes; i++ )
{
CGraphNode& node = GetNode(i);
if ( node.GetNeighbors().empty() == false )
{
nodesToKeep.push_back(node);
vecKeepFlags[i] = true;
vecNewIndices[i] = keepCount;
keepCount ++;
}
}
if ( keepCount == numOfNodes )
{
return;
}
m_nodes = nodesToKeep;
for ( int i=0; i<GetNumOfEdges(); i++ )
{
CGraphEdge& edge = GetEdge(i);
int idx0 = edge.GetIdx0();
int idx1 = edge.GetIdx1();
idx0 = vecNewIndices[idx0];
idx1 = vecNewIndices[idx1];
edge.SetIdx0(idx0);
edge.SetIdx1(idx1);
}
SetNodeNeighbors();
}
void CPlanarGraph::DetectFaces()
{
// Based on the example in (http://www.boost.org/doc/libs/1_47_0/libs/graph/example/planar_face_traversal.cpp)
int numOfNodes = GetNumOfNodes();
Graph g(numOfNodes);
int numOfEdges = GetNumOfEdges();
for ( int i=0; i<numOfEdges; i++ )
{
int idx0 = GetEdge(i).GetIdx0();
int idx1 = GetEdge(i).GetIdx1();
add_edge(idx0, idx1, g);
}
// Initialize the interior edge index
property_map<Graph, edge_index_t>::type e_index = get(edge_index, g);
graph_traits<Graph>::edges_size_type edge_count = 0;
graph_traits<Graph>::edge_iterator ei, ei_end;
for ( boost::tuples::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei )
{
put(e_index, *ei, edge_count++);
}
typedef std::vector< graph_traits<Graph>::edge_descriptor > vec_t;
std::vector<vec_t> embedding(num_vertices(g));
#if 0
// Test for planarity - we know it is planar, we just want to
// compute the planar embedding as a side-effect
if ( boyer_myrvold_planarity_test(boyer_myrvold_params::graph = g,
boyer_myrvold_params::embedding = &embedding[0] ) )
{
std::cout << "Input graph is planar" << std::endl;
}
else
{
std::cout << "Input graph is not planar" << std::endl;
}
#else
// Compute the planar embedding based on node positions...
VertexIterator vi, vi_end;
for ( boost::tie(vi, vi_end) = boost::vertices(g); vi != vi_end; ++vi )
{
OutEdgeIterator ei, ei_end;
std::vector<EdgeDescriptor> adjacentEdges;
for ( boost::tie(ei, ei_end) = boost::out_edges(*vi, g); ei != ei_end; ++ei )
{
VertexDescriptor v1 = boost::source(*ei, g);
VertexDescriptor v2 = boost::target(*ei, g);
adjacentEdges.push_back(*ei);
}
SortAdjacentVertices(g, *vi, adjacentEdges);
for(int i = 0; i < adjacentEdges.size(); ++i)
{
std::cout << *vi << " -> " << adjacentEdges[i] << std::endl;
}
if(adjacentEdges.size()>0)
std::cout << std::endl;
embedding[*vi] = adjacentEdges;
}
#endif
std::cout << std::endl << "Vertices on the faces: " << std::endl;
vertex_output_visitor v_vis;
planar_face_traversal(g, &embedding[0], v_vis);
std::cout << std::endl << "Edges on the faces: " << std::endl;
edge_output_visitor e_vis;
planar_face_traversal(g, &embedding[0], e_vis);
RemoveTheOutsideFace();
}
void CRichModel::CollectAndArrangeNeighs()
{
m_nIsolatedVerts = 0;
vector<int> sequenceOfDegrees(GetNumOfVerts(), 0);
m_NeighsAndAngles.resize(GetNumOfVerts());
for (int i = 0; i < (int)m_NeighsAndAngles.size(); ++i)
{
m_NeighsAndAngles[i].resize(1, make_pair(-1, 0));
}
for (int i = 0; i < (int)GetNumOfEdges(); ++i)
{
const CEdge& edge = Edge(i);
++sequenceOfDegrees[edge.indexOfLeftVert];
int &indexOfStartEdge = m_NeighsAndAngles[edge.indexOfLeftVert][0].first;
if (indexOfStartEdge == -1 || !IsStartEdge(indexOfStartEdge))
{
indexOfStartEdge = i;
}
else if (IsStartEdge(i))
{
m_NeighsAndAngles[edge.indexOfLeftVert].push_back(make_pair(i, 0));
}
}
for (int i = 0; i < GetNumOfVerts(); ++i)
{
if (m_NeighsAndAngles[i][0].first == -1)
{
m_NeighsAndAngles[i].clear();
m_nIsolatedVerts++;
continue;
}
vector<int> startEdges;
for (int j = 0; j < (int)Neigh(i).size(); ++j)
{
startEdges.push_back(Neigh(i)[j].first);
}
m_NeighsAndAngles[i].resize(sequenceOfDegrees[i], make_pair(0, 0));
int num(0);
for (int j = 0; j < (int)startEdges.size(); ++j)
{
int curEdge = startEdges[j];
while (1)
{
m_NeighsAndAngles[i][num].first = curEdge;
++num;
if (num >= sequenceOfDegrees[i])
break;
if (IsExtremeEdge(curEdge))
break;
curEdge = Edge(curEdge).indexOfLeftEdge;
if (curEdge == startEdges[j])
{
break;
}
}
}
if (num != sequenceOfDegrees[i])
{
printf("vertex id %d\n" , i );
//throw "Complex vertices";
printf("COmplex vertices\n");
}
}
}
