static void DFS(Status fromS, NFA nfa, Array_T closure, int inverse[], int color[], int set)
{
int i, index, from, to;
Edge e;
Status toS;
from = getStatusID(fromS);
color[from] = 1;
inverse[from] = set;
Array_append(closure, &from);
Array_T edgeArray = getEdgeArray(nfa);
Array_T outEdges_indice = getOutEdges(fromS);
if (!outEdges_indice)
return;
for (i=0; i<Array_length(outEdges_indice); i++)
{
index = *(int*)Array_get(outEdges_indice, i);
e = (Edge)Array_get(edgeArray, index);
if (isEpsilon(e))
{
toS = gettoStatus(e);
to = getStatusID(toS);
if (color[to] == 0)
DFS(toS, nfa, closure, inverse, color, set);
}
}
}
void get_two_StatusSet_Table (NFA nfa, StatusSet_table *T, int inverse[])
{
int i, j, id, n, curr_set_id, e_index;
Edge e;
Status s;
Array_T StatusArray, edgeArray, OutEdges, closure;
T->size = 0;
StatusArray = getStatusArray (nfa);
edgeArray = getEdgeArray (nfa);
n = Array_length (StatusArray);
/* 一开始所有状态不属于任一集合 */
for (i=0; i<n; i++) inverse[i] = -1;
for (i=0; i<n; i++)
{
if (inverse[i] != -1)
continue;
/* 闭包缓存 */
curr_set_id = T->size;
inverse[i] = curr_set_id;
closure = Array_new (0, sizeof(int));
s = Array_get(StatusArray, i);
getEpsilonClosure(s, nfa, closure, inverse, curr_set_id);
for (j=0; j<Array_length(closure); j++)
{
id = *(int*)Array_get(closure, j);
s = Array_get(nfa->statusArray, id);
if (isFinalStatus(s))
T->H[T->size].hasFinalStatus = true;
}
/* 以s为原点进行DFS，找出所有epsilon闭包
* getEpsilonClosure(s, closure, inverse)
*/
T->H[T->size].epsClosure = closure;
//printStatusSet(T->H[T->size]);
//wprintf(L"-------------------------------\n");
T->size++;
}
}
void ManifoldTetrahedronSetTopologyContainer::createTetrahedraAroundEdgeArray ()
{
std::cout << "ManifoldTetrahedronSetTopologyContainer::createTetrahedraAroundEdgeArray ()"<<std::endl;
// Get edge array
sofa::helper::vector<Edge> edges = getEdgeArray();
// Creating Tetrahedrons edges shell unordered
TetrahedronSetTopologyContainer::createTetrahedraAroundEdgeArray();
helper::ReadAccessor< Data< sofa::helper::vector<Tetrahedron> > > m_tetrahedron = d_tetrahedron;
// for (unsigned int i = 0; i < m_tetrahedraAroundEdge.size(); i++)
// std::cout << i << " => " << m_tetrahedraAroundEdge[i] << std::endl;
for (unsigned int edgeIndex =0; edgeIndex<edges.size(); edgeIndex++)
{
sofa::helper::vector <unsigned int> &shell = getTetrahedraAroundEdgeForModification (edgeIndex);
sofa::helper::vector <unsigned int>::iterator it;
sofa::helper::vector < sofa::helper::vector <unsigned int> > vertexTofind;
sofa::helper::vector <unsigned int> goodShell;
unsigned int firstVertex =0;
unsigned int secondVertex =0;
unsigned int cpt = 0;
vertexTofind.resize (shell.size());
// Path to follow creation
for (unsigned int tetraIndex = 0; tetraIndex < shell.size(); tetraIndex++)
{
cpt = 0;
for (unsigned int vertex = 0; vertex < 4; vertex++)
{
if(m_tetrahedron[shell[ tetraIndex]][vertex] != edges[edgeIndex][0] && m_tetrahedron[shell[ tetraIndex]][vertex] != edges[edgeIndex][1] )
{
vertexTofind[tetraIndex].push_back (m_tetrahedron[shell[ tetraIndex]][vertex]);
cpt++;
}
if (cpt == 2)
break;
}
}
Tetrahedron tetra_first = Tetrahedron(edges[edgeIndex][0], edges[edgeIndex][1], vertexTofind[0][0], vertexTofind[0][1]);
int good = getTetrahedronOrientation (m_tetrahedron[shell[ 0]], tetra_first);
if (good == 1) //then tetra is in good order, initialisation.
{
firstVertex = vertexTofind[0][0];
secondVertex = vertexTofind[0][1];
}
else if (good == 0)
{
firstVertex = vertexTofind[0][1];
secondVertex = vertexTofind[0][0];
}
else
{
std::cout << "Error: createTetrahedraAroundEdgeArray: Houston there is a probleme." <<std::endl;
}
goodShell.push_back(shell[0]);
bool testFind = false;
bool reverse = false;
cpt = 0;
// Start following path
for (unsigned int i = 1; i < shell.size(); i++)
{
for (unsigned int j = 1; j < shell.size(); j++)
{
Tetrahedron tetra_test1 = Tetrahedron(edges[edgeIndex][0], edges[edgeIndex][1], secondVertex, vertexTofind[j][1]);
Tetrahedron tetra_test2 = Tetrahedron(edges[edgeIndex][0], edges[edgeIndex][1], secondVertex, vertexTofind[j][0]);
if (vertexTofind[j][0] == secondVertex && getTetrahedronOrientation (m_tetrahedron[shell[ j]], tetra_test1) == 1) //find next tetra, in one or the other order.
{
goodShell.push_back(shell[j]);
secondVertex = vertexTofind[j][1];
testFind = true;
break;
}
else if(vertexTofind[j][1] == secondVertex && getTetrahedronOrientation (m_tetrahedron[shell[ j]], tetra_test2) == 1)
{
goodShell.push_back(shell[j]);
secondVertex = vertexTofind[j][0];
testFind = true;
break;
}
}
if (!testFind) //tetra has not be found, this mean we reach a border, we reverse the method
{
reverse = true;
break;
}
cpt++;
testFind =false;
}
// Reverse path following methode
if(reverse)
{
#ifndef NDEBUG
std::cout << "Edge on border: "<< edgeIndex << std::endl;
#endif
for (unsigned int i = cpt+1; i<shell.size(); i++)
{
for (unsigned int j = 0; j<shell.size(); j++)
{
Tetrahedron tetra_test1 = Tetrahedron(edges[edgeIndex][0], edges[edgeIndex][1], vertexTofind[j][1], firstVertex);
Tetrahedron tetra_test2 = Tetrahedron(edges[edgeIndex][0], edges[edgeIndex][1], vertexTofind[j][0], firstVertex);
if (vertexTofind[j][0] == firstVertex && getTetrahedronOrientation (m_tetrahedron[shell[ j]], tetra_test1) == 1) //find next tetra, in one or the other order.
{
goodShell.insert (goodShell.begin(),shell[j]);
firstVertex = vertexTofind[j][1];
testFind = true;
break;
}
else if(vertexTofind[j][1] == firstVertex && getTetrahedronOrientation (m_tetrahedron[shell[ j]], tetra_test2) == 1)
{
goodShell.insert (goodShell.begin(),shell[j]);
firstVertex = vertexTofind[j][0];
testFind = true;
break;
}
}
}
}
shell = goodShell;
goodShell.clear();
vertexTofind.clear();
}
}
