// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int EdgeGeom::writeXdmf(QTextStream& out, QString dcName, QString hdfFileName) { herr_t err = 0; // Always start the grid out << " <!-- *************** START OF " << dcName << " *************** -->" << "\n"; out << " <Grid Name=\"" << dcName << "\" GridType=\"Uniform\">" << "\n"; out << " <Topology TopologyType=\"Polyline\" NodesPerElement=\"2\" NumberOfElements=\"" << getNumberOfEdges() << "\">" << "\n"; out << " <DataItem Format=\"HDF\" NumberType=\"Int\" Dimensions=\"" << getNumberOfEdges() << " 2\">" << "\n"; out << " " << hdfFileName << ":/DataContainers/" << dcName << "/" << DREAM3D::Geometry::Geometry << "/" << DREAM3D::Geometry::SharedEdgeList << "\n"; out << " </DataItem>" << "\n"; out << " </Topology>" << "\n"; if (m_VertexList.get() == NULL) { out << "<!-- ********************* GEOMETRY ERROR ****************************************\n"; out << "The Geometry with name '" << getName() << "' in DataContainer '" << dcName << "' \n"; out << "did not have any vertices assigned.\n"; out << "The Geometry types will be missing from the Xdmf which will cause issues when\n"; out << "trying to load the file\n"; out << " ********************************************************************************** -->\n"; } else { out << " <Geometry Type=\"XYZ\">" << "\n"; out << " <DataItem Format=\"HDF\" Dimensions=\"" << getNumberOfVertices() << " 3\" NumberType=\"Float\" Precision=\"4\">" << "\n"; out << " " << hdfFileName << ":/DataContainers/" << dcName << "/" << DREAM3D::Geometry::Geometry << "/" << DREAM3D::Geometry::SharedVertexList << "\n"; out << " </DataItem>" << "\n"; out << " </Geometry>" << "\n"; out << "" << "\n"; } return err; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void QuadGeom::addAttributeMatrix(const QString& name, AttributeMatrix::Pointer data) { if (data->getType() != 0 || data->getType() != 1 || data->getType() != 2) { // QuadGeom can only accept vertex, edge, or face Attribute Matrices return; } if (data->getType() == 0 && static_cast<int64_t>(data->getNumTuples()) != getNumberOfVertices()) { return; } if (data->getType() == 1 && static_cast<int64_t>(data->getNumTuples()) != getNumberOfEdges()) { return; } if (data->getType() == 2 && data->getNumTuples() != getNumberOfElements()) { return; } if (data->getName().compare(name) != 0) { data->setName(name); } m_AttributeMatrices[name] = data; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void EdgeGeom::findDerivatives(DoubleArrayType::Pointer field, DoubleArrayType::Pointer derivatives, Observable* observable) { m_ProgressCounter = 0; int64_t numEdges = getNumberOfEdges(); if (observable) { connect(this, SIGNAL(filterGeneratedMessage(const PipelineMessage&)), observable, SLOT(broadcastPipelineMessage(const PipelineMessage&))); } #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS tbb::task_scheduler_init init; bool doParallel = true; #endif #ifdef SIMPLib_USE_PARALLEL_ALGORITHMS if (doParallel == true) { tbb::parallel_for(tbb::blocked_range<int64_t>(0, numEdges), FindEdgeDerivativesImpl(this, field, derivatives), tbb::auto_partitioner()); } else #endif { FindEdgeDerivativesImpl serial(this, field, derivatives); serial.compute(0, numEdges); } }
/////////////////////////////////////////////////////////////////// // // Function Name: chooseEdge // Description: Randomly chooses an edge based upon the // probabilities. // /////////////////////////////////////////////////////////////////// Edge *Router::chooseEdge(double p) const { if (p <= acoProbs[0]) return getEdgeByIndex(0); for (size_t r = 0; r < getNumberOfEdges(); ++r) { if (p > acoProbs[r] && p <= acoProbs[r + 1]) { return getEdgeByIndex(r + 1); } } return nullptr; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int EdgeGeom::findElementCentroids() { QVector<size_t> cDims(1, 3); m_EdgeCentroids = FloatArrayType::CreateArray(getNumberOfEdges(), cDims, DREAM3D::StringConstants::EdgeCentroids); GeometryHelpers::Topology::FindElementCentroids<int64_t>(m_EdgeList, m_VertexList, m_EdgeCentroids); if (m_EdgeCentroids.get() == NULL) { return -1; } return 1; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- int EdgeGeom::writeGeometryToHDF5(hid_t parentId, bool SIMPL_NOT_USED(writeXdmf)) { herr_t err = 0; if (m_VertexList.get() != NULL) { err = GeometryHelpers::GeomIO::WriteListToHDF5(parentId, m_VertexList); if (err < 0) { return err; } } if (m_EdgeList.get() != NULL) { err = GeometryHelpers::GeomIO::WriteListToHDF5(parentId, m_EdgeList); if (err < 0) { return err; } } if (m_EdgeCentroids.get() != NULL) { err = GeometryHelpers::GeomIO::WriteListToHDF5(parentId, m_EdgeCentroids); if (err < 0) { return err; } } if (m_EdgeNeighbors.get() != NULL) { size_t numEdges = getNumberOfEdges(); err = GeometryHelpers::GeomIO::WriteDynamicListToHDF5<uint16_t, int64_t>(parentId, m_EdgeNeighbors, numEdges, DREAM3D::StringConstants::EdgeNeighbors); if (err < 0) { return err; } } if (m_EdgesContainingVert.get() != NULL) { size_t numVerts = getNumberOfVertices(); err = GeometryHelpers::GeomIO::WriteDynamicListToHDF5<uint16_t, int64_t>(parentId, m_EdgesContainingVert, numVerts, DREAM3D::StringConstants::EdgesContainingVert); if (err < 0) { return err; } } return err; }
void insertEdge(int tail, int head ){ // std::stringstream edgeSample; // edgeSample<<tail<<","<<head; std::map<int,int>::iterator nodeLook = nodeHash_.find(tail); std::map<int,int>::iterator edgeLook = nodeEdgeHash_[nodeLook->second].find(head); // std::cout<<" "<<head; if(edgeLook==nodeEdgeHash_[nodeLook->second].end()){ // not yet in: nodeEdgeHash_[nodeLook->second][head] = getNumberOfEdges(); incrementEdge(); } }
/////////////////////////////////////////////////////////////////// // // Function Name: generateACOProbabilities // Description: Updates the ACO probabilities based upon the // current pheremone levels. // /////////////////////////////////////////////////////////////////// void Router::generateACOProbabilities(size_t dest) { double *destinationTaus = new double[getNumberOfEdges()]; double *destinationEtas = new double[getNumberOfEdges()]; if (acoProbs == nullptr) { acoProbs = new double[getNumberOfEdges()]; } for (size_t e = 0; e < getNumberOfEdges(); ++e) { if (getEdgeByIndex(e)->getSourceIndex() == getIndex()) { destinationTaus[e] = getEdgeByIndex(e)->getPheremone(); if (getEdgeByIndex(e)->getDestinationIndex() != dest) { destinationEtas[e] = 1.0 / double( threadZero->getResourceManager() ->span_distance[getEdgeByIndex(e)->getDestinationIndex() * threadZero->getNumberOfRouters() + dest]); } else { destinationEtas[e] = 1.0; } } else { destinationTaus[e] = 0.0; destinationEtas[e] = 0.0; } } double cumulativeProduct = 0.0; for (size_t e = 0; e < getNumberOfEdges(); ++e) { destinationTaus[e] = pow(destinationTaus[e], double(threadZero->getQualityParams().ACO_alpha)); destinationEtas[e] = pow(destinationEtas[e], double(threadZero->getQualityParams().ACO_beta)); cumulativeProduct += destinationTaus[e] * destinationEtas[e]; } for (size_t e = 0; e < getNumberOfEdges(); ++e) { acoProbs[e] = (destinationTaus[e] * destinationEtas[e]) / cumulativeProduct; if (e > 0) acoProbs[e] += acoProbs[e - 1]; } acoProbs[getNumberOfEdges() - 1] = 1.0; delete[] destinationTaus; delete[] destinationEtas; }
void bellman(int start) { printf("\nBellman's argorithm started\n"); edgeT *edge = getTheEdges(adjMatrix); int nrEdges = getNumberOfEdges(adjMatrix); int *dist = (int*) malloc (nrOfVerteces * sizeof(int)); int *parent = (int*) malloc (nrOfVerteces * sizeof(int)); int i, j; for(i=0; i<nrOfVerteces; i++) { dist[i] = INT_MAX; parent[i] = UNDEFINED; } dist[start] = 0; for(i=0; i<nrOfVerteces; i++) { for(j=0; j<nrEdges; j++) { if(dist[edge[j].destination] > dist[edge[j].source] + edge[j].weight) { dist[edge[j].destination] = dist[edge[j].source] + edge[j].weight; parent[edge[j].destination] = edge[j].source; } } } int ok = 1; for(j=0; j<nrEdges; j++) if(dist[edge[i].destination] > dist[edge[i].source] + edge[i].weight) ok = 0; if(ok == 1) { printf("The distances from vertex %d are: ", start); for(i=0; i<nrOfVerteces; i++) if(i!=start) printf("%d ", dist[i]); printf("\n"); } else printf("Found a negative cycle\n"); printf("Bellman Ford algorithm ended\n"); }
edgeT *getTheEdges(int **adjMatrix) { int i, j, nrEdges = 0; edgeT *edges = (edgeT *) malloc (getNumberOfEdges(adjMatrix) * sizeof(edgeT)); for(i=0; i<nrOfVerteces; i++) for(j=0; j<nrOfVerteces; j++) if(adjMatrix[i][j] != 0 && i<j) { edges[nrEdges].source = i; edges[nrEdges].destination = j; edges[nrEdges].weight = adjMatrix[i][j]; nrEdges +=1; } return edges; }
edgeT* getAllEdges() { int nr=getNumberOfEdges(); edgeT* edges=(edgeT*)malloc(nr*sizeof(edgeT)); int i,j,k=0; for (i=0;i<nrOfVerteces;i++) for(j=0;j<nrOfVerteces;j++) if (adjMatrix[i][j]!=0) { edges[k].source=i; edges[k].destination=j; edges[k].weight=adjMatrix[i][j]; k++; } return edges; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- QString EdgeGeom::getInfoString(DREAM3D::InfoStringFormat format) { QString info; QTextStream ss (&info); if(format == DREAM3D::HtmlFormat) { ss << "<tr bgcolor=\"#D3D8E0\"><th colspan=2>Edge Geometry Info</th></tr>"; ss << "<tr bgcolor=\"#C3C8D0\"><th align=\"right\">Number of Edges</th><td>" << getNumberOfEdges() << "</td></tr>"; ss << "<tr bgcolor=\"#C3C8D0\"><th align=\"right\">Number of Vertices</th><td>" << getNumberOfVertices() << "</td></tr>"; ss << "</tbody></table>"; } else { } return info; }
void TetrahedronSetTopologyContainer::createTetrahedraAroundEdgeArray () { if(!hasEdgesInTetrahedron()) createEdgesInTetrahedronArray(); if(hasTetrahedraAroundEdge()) clearTetrahedraAroundEdge(); m_tetrahedraAroundEdge.resize(getNumberOfEdges()); for (unsigned int i=0; i< getNumberOfTetrahedra(); ++i) { // adding edge i in the edge shell of both points for (unsigned int j=0; j<6; ++j) { m_tetrahedraAroundEdge[ m_edgesInTetrahedron[i][j] ].push_back( i ); } } }
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 TriangleSetTopologyContainer::createElementsOnBorder() { if(!hasTrianglesAroundEdge()) // Use the trianglesAroundEdgeArray. Should check if it is consistent { #ifndef NDEBUG std::cout << "Warning. [TriangleSetTopologyContainer::createElementsOnBorder] Triangle edge shell array is empty." << std::endl; #endif createTrianglesAroundEdgeArray(); } if(!m_trianglesOnBorder.empty()) m_trianglesOnBorder.clear(); if(!m_edgesOnBorder.empty()) m_edgesOnBorder.clear(); if(!m_pointsOnBorder.empty()) m_pointsOnBorder.clear(); const unsigned int nbrEdges = getNumberOfEdges(); bool newTriangle = true; bool newEdge = true; bool newPoint = true; helper::ReadAccessor< Data< sofa::helper::vector<Edge> > > m_edge = d_edge; for (unsigned int i = 0; i < nbrEdges; i++) { if (m_trianglesAroundEdge[i].size() == 1) // I.e this edge is on a border { // --- Triangle case --- for (unsigned int j = 0; j < m_trianglesOnBorder.size(); j++) // Loop to avoid duplicated indices { if (m_trianglesOnBorder[j] == m_trianglesAroundEdge[i][0]) { newTriangle = false; break; } } if(newTriangle) // If index doesn't already exist, add it to the list of triangles On border. { m_trianglesOnBorder.push_back (m_trianglesAroundEdge[i][0]); } // --- Edge case --- for (unsigned int j = 0; j < m_edgesOnBorder.size(); j++) // Loop to avoid duplicated indices { if (m_edgesOnBorder[j] == i) { newEdge = false; break; } } if(newEdge) // If index doesn't already exist, add it to the list of edges On border. { m_edgesOnBorder.push_back (i); } // --- Point case --- PointID firstVertex = m_edge[i][0]; for (unsigned int j = 0; j < m_pointsOnBorder.size(); j++) // Loop to avoid duplicated indices { if (m_pointsOnBorder[j] == firstVertex) { newPoint = false; break; } } if(newPoint) // If index doesn't already exist, add it to the list of points On border. { m_pointsOnBorder.push_back (firstVertex); } newTriangle = true; //reinitialize tests variables newEdge = true; newPoint = true; } } }
void TriangleSetTopologyContainer::createEdgesInTriangleArray() { if(!hasTriangles()) // this method should only be called when triangles exist { #ifndef NDEBUG sout << "Warning. [TriangleSetTopologyContainer::createEdgesInTriangleArray] triangle array is empty." << sendl; #endif createTriangleSetArray(); } // this should never be called : remove existing triangle edges if(hasEdgesInTriangle()) clearEdgesInTriangle(); helper::ReadAccessor< Data< sofa::helper::vector<Triangle> > > m_triangle = d_triangle; if(!hasEdges()) // To optimize, this method should be called without creating edgesArray before. { #ifndef NDEBUG sout << "Warning. [TriangleSetTopologyContainer::createEdgesInTriangleArray] edge array is empty." << sendl; #endif /// create edge array and triangle edge array at the same time const unsigned int numTriangles = getNumberOfTriangles(); m_edgesInTriangle.resize(numTriangles); // create a temporary map to find redundant edges std::map<Edge, unsigned int> edgeMap; helper::WriteAccessor< Data< sofa::helper::vector<Edge> > > m_edge = d_edge; for (unsigned int i=0; i<m_triangle.size(); ++i) { const Triangle &t = m_triangle[i]; for(unsigned int j=0; j<3; ++j) { const unsigned int v1 = t[(j+1)%3]; const unsigned int v2 = t[(j+2)%3]; // sort vertices in lexicographic order const Edge e = ((v1<v2) ? Edge(v1,v2) : Edge(v2,v1)); if(edgeMap.find(e) == edgeMap.end()) { // edge not in edgeMap so create a new one const unsigned int edgeIndex = (unsigned int)edgeMap.size(); /// add new edge edgeMap[e] = edgeIndex; // m_edge.push_back(e); m_edge.push_back(Edge(v1,v2)); } m_edgesInTriangle[i][j] = edgeMap[e]; } } } else { /// there are already existing edges : must use an inefficient method. Parse all triangles and find the edge that match each triangle edge helper::ReadAccessor< Data< sofa::helper::vector<Edge> > > m_edge = d_edge; const unsigned int numTriangles = getNumberOfTriangles(); const unsigned int numEdges = getNumberOfEdges(); m_edgesInTriangle.resize(numTriangles); /// create a multi map where the key is a vertex index and the content is the indices of edges adjacent to that vertex. std::multimap<PointID, EdgeID> edgesAroundVertexMap; std::multimap<PointID, EdgeID>::iterator it; bool foundEdge; for (unsigned int edge=0; edge<numEdges; ++edge) //Todo: check if not better using multimap <PointID ,TriangleID> and for each edge, push each triangle present in both shell { edgesAroundVertexMap.insert(std::pair<PointID, EdgeID> (m_edge[edge][0],edge)); edgesAroundVertexMap.insert(std::pair<PointID, EdgeID> (m_edge[edge][1],edge)); } for(unsigned int i=0; i<numTriangles; ++i) { const Triangle &t = m_triangle[i]; // adding edge i in the edge shell of both points for(unsigned int j=0; j<3; ++j) { //finding edge i in edge array std::pair<std::multimap<PointID, EdgeID>::iterator, std::multimap<PointID, EdgeID>::iterator > itPair=edgesAroundVertexMap.equal_range(t[(j+1)%3]); foundEdge=false; for(it=itPair.first; (it!=itPair.second) && (foundEdge==false); ++it) { unsigned int edge = (*it).second; if ( (m_edge[edge][0] == t[(j+1)%3] && m_edge[edge][1] == t[(j+2)%3]) || (m_edge[edge][0] == t[(j+2)%3] && m_edge[edge][1] == t[(j+1)%3])) { m_edgesInTriangle[i][j] = edge; foundEdge=true; } } #ifndef NDEBUG if (foundEdge==false) sout << "[TriangleSetTopologyContainer::getTriangleArray] cannot find edge for triangle " << i << "and edge "<< j << sendl; #endif } } } }
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(); }
int bellman(int startNode) { printf("\nBellman Ford Algorithm started\n"); int i; int * distances = (int*)malloc(nrOfVerteces * sizeof(int)); int * previous = (int*)malloc(nrOfVerteces * sizeof(int)); for(i=0; i<nrOfVerteces; i++) { distances[i] = MAX; previous[i]=UNDEFINED; } distances[startNode]=0; edgeT* edges=getAllEdges(); int nrOfEdges=getNumberOfEdges(); for(i=1;i<nrOfVerteces;i++) { int j; for(j=0;j<nrOfEdges;j++) { int u=edges[j].source; int v=edges[j].destination; ///relax the edge if (distances[v]>distances[u]+edges[j].weight) { distances[v]=distances[u]+edges[j].weight; previous[v]=u; } } } for(i=0; i<nrOfVerteces; i++) { int u=i; if(i!=startNode) { while(previous[u] != UNDEFINED) { push(u); u = previous[u]; } printf("Path from %c to %c is: %c ",startNode + 65, i+65, startNode + 65); while(!isEmptyStack()) { printf("-> %c ",peekStack()->content + 65); pop(); } printf("\n"); } } for(i=0;i<nrOfEdges;i++) { int u=edges[i].source; int v=edges[i].destination; ///relax the edge if (distances[v]>distances[u]+edges[i].weight) { printf("Bellman Ford Algorithm ended\n"); return 0; } } printf("Bellman Ford Algorithm ended\n"); }