// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
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");
}
