//-----------------------------------------------------------------------------------------
void doTraversal(Node *n, int labelHeight, int* maxHeight,
int* substringStartIndex)
{
if(n == NULL)
{
return;
}
int i=0;
if(n->suffixIndex == -1) //If it is internal node
{
for (i = 0; i < MAX_CHAR; i++)
{
if(n->children[i] != NULL)
{
doTraversal(n->children[i], labelHeight +
edgeLength(n->children[i]), maxHeight,
substringStartIndex);
}
}
}
else if(n->suffixIndex > -1 &&
(*maxHeight < labelHeight - edgeLength(n)))
{
*maxHeight = labelHeight - edgeLength(n);
*substringStartIndex = n->suffixIndex;
}
}
/*
* VasoFilter combines some of the other pre-defined filters to
* determine if a given contour belongs to a plastic glass
*/
int Contours::vasoFilter(){
CvSeq * points=this->c;
CvPoint *longestEdge,*sndLongestEdge,*longestHead,*longestTail;
double longestEdgeLen;
int shorterEdgesCount=0;
if(points->total<4)
return false;
//get longest edge
longestEdge=getLongestEdge(points);
//second longest edge
sndLongestEdge=getLongestEdge2(points,&longestEdge[0],&longestEdge[1],&shorterEdgesCount);
//longest edges should not share a same point
if( equalsCvPoint(&longestEdge[0],&sndLongestEdge[0]) ||
equalsCvPoint(&longestEdge[0],&sndLongestEdge[1]) ||
equalsCvPoint(&longestEdge[1],&sndLongestEdge[1]) ||
equalsCvPoint(&longestEdge[1],&sndLongestEdge[0]))
return false;
//checks that the two edges are separated from each other
if(!minSeparationBetweenLongestEdges(longestEdge[0],longestEdge[1],sndLongestEdge[0],sndLongestEdge[1])){
free(longestEdge);
free(sndLongestEdge);
return false;
}
double l1=edgeLength(longestEdge[0],longestEdge[1]);
double l2=edgeLength(sndLongestEdge[0],sndLongestEdge[1]);
free(longestEdge);
free(sndLongestEdge);
//~ printf(" vaso l2/l1 \n");
//length of the two longest edges should be similar
if(l2/l1 < VASO_LONGEST_EDGE_SIMILARITY)
return false;
//~ printf("eccentricity \n");
double ecc=this->getCircularity();
if(ecc<14 || ecc >18)
return false;
//~ printf("encontro vaso \n");
return true;
}
int walkDown(Node *currNode)
{
/*activePoint change for walk down (APCFWD) using
Skip/Count Trick (Trick 1). If activeLength is greater
than current edge length, set next internal node as
activeNode and adjust activeEdge and activeLength
accordingly to represent same activePoint*/
if (activeLength >= edgeLength(currNode))
{
activeEdge += edgeLength(currNode);
activeLength -= edgeLength(currNode);
activeNode = currNode;
return 1;
}
return 0;
}
//Print the suffix tree as well along with setting suffix index
//So tree will be printed in DFS manner
//Each edge along with it's suffix index will be printed
void setSuffixIndexByDFS(Node *n, int labelHeight)
{
if (n == NULL) return;
if (n->start != -1) //A non-root node
{
//Print the label on edge from parent to current node
print(n->start, *(n->end));
}
int leaf = 1;
int i;
for (i = 0; i < MAX_CHAR; i++)
{
if (n->children[i] != NULL)
{
if (leaf == 1 && n->start != -1)
printf(" [%d]\n", n->suffixIndex);
//Current node is not a leaf as it has outgoing
//edges from it.
leaf = 0;
setSuffixIndexByDFS(n->children[i], labelHeight +
edgeLength(n->children[i]));
}
}
if (leaf == 1)
{
n->suffixIndex = size - labelHeight;
printf(" [%d]\n", n->suffixIndex);
}
}
void FMMMLayout::call(ClusterGraphAttributes &GA)
{
const Graph &G = GA.constGraph();
//compute depth of cluster tree, also sets cluster depth values
const ClusterGraph &CG = GA.constClusterGraph();
int cdepth = CG.treeDepth();
EdgeArray<double> edgeLength(G);
//compute lca of end vertices for each edge
edge e;
forall_edges(e, G)
{
edgeLength[e] = cdepth - CG.clusterDepth(CG.commonCluster(e->source(),e->target())) + 1;
OGDF_ASSERT(edgeLength[e] > 0)
}
Real
OneDFSIFunctionSolverDefinedCompatibility::computeCFL ( const Real& eigenvalue, const Real& timeStep ) const
{
Real cfl = eigenvalue * timeStep / edgeLength (M_fluxPtr->physics()->data()->mesh()->edge ( M_bcElement ) );
#ifdef HAVE_LIFEV_DEBUG
if ( M_bcInternalNode == 1 ) // the edge is on the left of the domain
{
ASSERT ( -1. < cfl && cfl < 0. , "This characteristics is wrong!\nEither it is not outcoming (eigenvalue>0 at the left of the domain),\n or CFL is too high.");
}
else // the edge is on the right of the domain
{
ASSERT ( 0. < cfl && cfl < 1. , "This characteristics is wrong!\nEither it is not outcoming (eigenvalue<0 at the right of the domain),\n or CFL is too high.");
}
#endif
return std::abs (cfl);
}
int doTraversal(Node *n, int labelHeight, int* maxHeight, int* substringStartIndex)
{
if(n == NULL)
{
return -1;
}
int i=0;
int ret = -1;
if(n->suffixIndex < 0) //If it is internal node
{
for (i = 0; i < MAX_CHAR; i++)
{
if(n->children[i] != NULL)
{
ret = doTraversal(n->children[i], labelHeight +
edgeLength(n->children[i]),
maxHeight, substringStartIndex);
if(n->suffixIndex == -1)
n->suffixIndex = ret;
else if((n->suffixIndex == -2 && ret == -3) ||
(n->suffixIndex == -3 && ret == -2) ||
n->suffixIndex == -4)
{
n->suffixIndex = -4;//Mark node as XY
//Keep track of deepest node
if(*maxHeight < labelHeight)
{
*maxHeight = labelHeight;
*substringStartIndex = *(n->end) -
labelHeight + 1;
}
}
}
}
}
else if(n->suffixIndex > -1 && n->suffixIndex < size1)//suffix of X
return -2;//Mark node as X
else if(n->suffixIndex >= size1)//suffix of Y
return -3;//Mark node as Y
return n->suffixIndex;
}
//Print the suffix tree as well along with setting suffix index
//So tree will be printed in DFS manner
//Each edge along with it's suffix index will be printed
void setSuffixIndexByDFS(Node *n, int labelHeight)
{
if (n == NULL) return;
if (n->start != -1) //A non-root node
{
//Print the label on edge from parent to current node
//Uncomment below line to print suffix tree
//print(n->start, *(n->end));
}
int leaf = 1;
int i;
for (i = 0; i < MAX_CHAR; i++)
{
if (n->children[i] != NULL)
{
//Uncomment below two lines to print suffix index
// if (leaf == 1 && n->start != -1)
// printf(" [%d]\n", n->suffixIndex);
//Current node is not a leaf as it has outgoing
//edges from it.
leaf = 0;
setSuffixIndexByDFS(n->children[i], labelHeight +
edgeLength(n->children[i]));
}
}
if (leaf == 1)
{
for(i= n->start; i<= *(n->end); i++)
{
if(text[i] == '#')
{
n->end = (int*) malloc(sizeof(int));
*(n->end) = i;
}
}
n->suffixIndex = size - labelHeight;
//Uncomment below line to print suffix index
// printf(" [%d]\n", n->suffixIndex);
}
}
