void create_new_leaf_here(int ch)
{
assert (!can_go(ch));
if (current_vertex != -1)
edges[current_vertex][ch] = newEdge(current_vertex, current_letter);
else if (current_edge != -1)
{
vertex new_vertex = newVertex(vdepth[from[current_edge]] + depth);
if (last_vertex != -1)
{
suf[last_vertex] = new_vertex;
last_vertex = -1;
}
edge new_edge = newEdge2(new_vertex, to[current_edge], left[current_edge] + depth, right[current_edge]);
int old_symbol = s[left[new_edge]];
edges[new_vertex][old_symbol] = new_edge;
edges[new_vertex][ch] = newEdge(new_vertex, current_letter);
to[current_edge] = new_vertex;
right[current_edge] = left[current_edge] + depth;
current_vertex = new_vertex;
last_edge = current_edge;
last_depth = depth;
current_edge = -1;
depth = 0;
last_vertex = new_vertex;
}
}
void PlanRep::restoreDeg1Nodes(Stack<Deg1RestoreInfo> &S, List<node> °1s)
{
while(!S.empty())
{
Deg1RestoreInfo info = S.pop();
adjEntry adjRef = info.m_adjRef;
node vOrig = info.m_deg1Original;
edge eOrig = info.m_eOriginal;
node v = newNode(vOrig);
if(adjRef) {
if(vOrig == eOrig->source())
newEdge(eOrig, v, adjRef);
else
newEdge(eOrig, adjRef, v);
} else {
if(vOrig == eOrig->source())
newEdge(eOrig);
else
newEdge(eOrig);
}
deg1s.pushBack(v);
}
}
// Create edges
forall_nodes(v,G) {
node vH = m_copy[v];
cluster c = CG.clusterOf(v);
newEdge(m_topNode[c], vH);
newEdge(vH, m_bottomNode[c]);
}
typename PolygonMesh<PointType>::VertexIterator PolygonMesh<PointType>::splitFace(const typename PolygonMesh<PointType>::FaceIterator& faceIt,typename PolygonMesh<PointType>::Vertex* facePoint)
{
/* Link the face point to the mesh: */
facePoint->pred=lastVertex;
facePoint->succ=0;
if(lastVertex!=0)
lastVertex->succ=facePoint;
else
vertices=facePoint;
lastVertex=facePoint;
/* Create a fan of triangles around the face point: */
Edge* firstOuterEdge=faceIt->getEdge();
deleteFace(faceIt.face);
Edge* outerEdge=firstOuterEdge;
Edge* firstInnerEdge;
Edge* lastInnerEdge=0;
do
{
Edge* nextOuterEdge=outerEdge->getFaceSucc();
/* Create a new triangle: */
Face* triangle=newFace();
Edge* innerEdge1=newEdge();
Edge* innerEdge2=newEdge();
facePoint->setEdge(innerEdge1);
innerEdge1->set(facePoint,triangle,innerEdge2,outerEdge,lastInnerEdge);
innerEdge1->sharpness=0;
if(lastInnerEdge!=0)
lastInnerEdge->setOpposite(innerEdge1);
else
firstInnerEdge=innerEdge1;
innerEdge2->set(outerEdge->getEnd(),triangle,outerEdge,innerEdge1,0);
innerEdge2->sharpness=0;
outerEdge->setFace(triangle);
outerEdge->setFacePred(innerEdge1);
outerEdge->setFaceSucc(innerEdge2);
triangle->setEdge(outerEdge);
#ifndef NDEBUG
triangle->checkFace();
#endif
lastInnerEdge=innerEdge2;
outerEdge=nextOuterEdge;
}
while(outerEdge!=firstOuterEdge);
/* Close the fan by connecting the first and last inner edges: */
lastInnerEdge->setOpposite(firstInnerEdge);
firstInnerEdge->setOpposite(lastInnerEdge);
#ifndef NDEBUG
facePoint->checkVertex();
#endif
return VertexIterator(facePoint);
}
/**
* Constructs the dihedron
* @param vertex the dihedron
*/
void ConvexHull::constDihedron(int iv) {
int kv[] = { iv, iv+1, iv+2 };
// entries cyclic list of vertices
for (int i = 0; i < NDV; i++) {
int nxv = kv[(i+1)%NDV];
khnv[kv[i]] = nxv;
khpv[nxv] = kv[i];
}
// gets index of new edges and faces
int ke[] = { newEdge(), newEdge(), newEdge() };
int kf[] = { newFace(), newFace() };
// connects faces to edges
kfe[kf[0]] = ke[0];
kfe[kf[1]] = ke[0];
// connects vertices to edges
kve[kv[0]] = ke[0];
kve[kv[1]] = ke[1];
kve[kv[2]] = ke[2];
// connects edges to start and end vertices
ksv[ke[0]] = kv[0];
ksv[ke[1]] = kv[1];
ksv[ke[2]] = kv[2];
kev[ke[0]] = kv[1];
kev[ke[1]] = kv[2];
kev[ke[2]] = kv[0];
// connects edges to left and right faces
klf[ke[0]] = kf[1];
klf[ke[1]] = kf[1];
klf[ke[2]] = kf[1];
krf[ke[0]] = kf[0];
krf[ke[1]] = kf[0];
krf[ke[2]] = kf[0];
// connects edges to contiguous edges
ksce[ke[0]] = ke[2];
ksce[ke[1]] = ke[0];
ksce[ke[2]] = ke[1];
kscce[ke[0]] = ke[2];
kscce[ke[1]] = ke[0];
kscce[ke[2]] = ke[1];
kece[ke[0]] = ke[1];
kece[ke[1]] = ke[2];
kece[ke[2]] = ke[0];
kecce[ke[0]] = ke[1];
kecce[ke[1]] = ke[2];
kecce[ke[2]] = ke[0];
// entries cyclic list of vertices on the silhouette of the convex hull
// entries a left most vertex
kch.push_back(searchSilhouette(NDV, kv));
}
forall_clusters(c,CG) {
if(c != CG.rootCluster()) {
cluster u = c->parent();
newEdge(m_topNode[u], m_topNode[c]);
newEdge(m_bottomNode[c], m_bottomNode[u]);
newEdge(m_topNode[c], m_bottomNode[c]);
}
}
// embeds constraint graph such that all sources and sinks lie in a common
// face
void CompactionConstraintGraphBase::embed()
{
NodeArray<bool> onExternal(*this,false);
const CombinatorialEmbedding &E = *m_pOR;
face fExternal = E.externalFace();
for(adjEntry adj : fExternal->entries)
onExternal[m_pathNode[adj->theNode()]] = true;
// compute lists of sources and sinks
SList<node> sources, sinks;
for(node v : nodes) {
if (onExternal[v]) {
if (v->indeg() == 0)
sources.pushBack(v);
if (v->outdeg() == 0)
sinks.pushBack(v);
}
}
// determine super source and super sink
node s,t;
if (sources.size() > 1)
{
s = newNode();
for (node v : sources)
newEdge(s,v);
}
else
s = sources.front();
if (sinks.size() > 1)
{
t = newNode();
for (node v : sinks)
newEdge(v,t);
}
else
t = sinks.front();
edge st = newEdge(s,t);
bool isPlanar = planarEmbed(*this);
if (!isPlanar) OGDF_THROW(AlgorithmFailureException);
delEdge(st);
if (sources.size() > 1)
delNode(s);
if (sinks.size() > 1)
delNode(t);
}
/* Draws a triangle with bottom vertex b, top vertex t, and point
m to the right of line from b to t */
void drawRightTriangle(vertex* b, vertex* t, vertex* m) {
edge* lEdge;
edge* rEdge;
int y;
/* Draw rows from bottom-top edge to bottom-middle edge */
lEdge = newEdge(b,t);
rEdge = newEdge(b,m);
for (y=b->y; y<m->y; y++) {
vertex* result = (vertex*)malloc(sizeof(vertex));
vertex* result1 = (vertex*)malloc(sizeof(vertex));
// result->v_color = *(interpolate(t, b, lEdge->x));
// result1->v_color = *(interpolate(m, b, rEdge->x));
result->v_color = *(integerInt(t, b, lEdge->x, y));
result1->v_color = *(integerInt(m, b, rEdge->x, y));
result->y = y;
result1->y = y;
result->x = lEdge->x;
result1->x = rEdge->x;
drawIRow(result,result1,y);
free(result);
free(result1);
yInc(lEdge);
yInc(rEdge);
}
free(rEdge);
/* Draw rows from bottom-top edge to middle-top edge */
rEdge = newEdge(m,t);
for (; y<=t->y;y++) {
vertex* result = (vertex*)malloc(sizeof(vertex));
vertex* result1 = (vertex*)malloc(sizeof(vertex));
// result->v_color = *(interpolate(t, b, lEdge->x));
// result1->v_color = *(interpolate(t, m, rEdge->x));
result->v_color = *(integerInt(t, b, lEdge->x, y));
result1->v_color = *(integerInt(t, m, rEdge->x, y));
result->y = y;
result1->y = y;
result->x = lEdge->x;
result1->x = rEdge->x;
drawIRow(result,result1,y);
free(result);
free(result1);
//drawRow(lEdge->x,rEdge->x, y);
yInc(lEdge);
yInc(rEdge);
}
free(lEdge);
free(rEdge);
}
/////////////MAKEMIDPOINTS////////////////////////////////
// makeMidPoints: interface to this class. Set midpoints of every
// node in this layer.
void
SpatialEdge::makeMidPoints()
{
size_t c=0;
size_t index;
// build up the new edges
index = (size_t)LAYER.firstIndex_;
for(size_t i=0; i < LAYER.nNode_; i++,index++){
c = newEdge(c,index,0);
c = newEdge(c,index,1);
c = newEdge(c,index,2);
}
}
void addSubgraph(Graph* graph, nodeid_t node_id, xid_t* xids, int n_xids)
{
xid_t *last = xids + n_xids;
Edge *e, *next, *edges = NULL;
Node* node = findNode(&cluster, node_id);
while (xids != last) {
Vertex* src = findVertex(graph, *xids++);
xid_t xid;
while ((xid = *xids++) != 0) {
Vertex* dst = findVertex(graph, xid);
e = newEdge(graph);
dst->nIncomingEdges += 1;
e->dst = dst;
e->src = src;
e->next = edges;
edges = e;
l2_list_link(&src->outgoingEdges, &e->node);
}
}
for (e = node->edges; e != NULL; e = next) {
next = e->next;
l2_list_unlink(&e->node);
if (--e->dst->nIncomingEdges == 0 && l2_list_is_empty(&e->dst->outgoingEdges)) {
freeVertex(graph, e->dst);
}
if (e->dst != e->src && e->src->nIncomingEdges == 0 && l2_list_is_empty(&e->src->outgoingEdges)) {
freeVertex(graph, e->src);
}
freeEdge(graph, e);
}
node->edges = edges;
}
/**
* Merges 2 adjacent convex hulls
* @param vertex of the left convex hull
* @param vertex of the right convex hull
*/
void ConvexHull::merge2Hulls(int liv0, int riv0) {
int liv = liv0;
int livr = liv0;
// searches the right most vertex of the left convex hull
do {
liv = kcnxv[liv];
if (hva[livr].x() < hva[liv].x()) {
livr = liv;
}
} while (liv != liv0);
int liv1 = livr; int liv2 = livr;
int riv1 = riv0; int riv2 = riv0;
// searches the common tangent edge
searchCTEdge(liv1, kccnxv, riv1, kcnxv , false);
searchCTEdge(liv2, kcnxv , riv2, kccnxv, true);
kcnxv[liv1] = riv1;
kccnxv[riv1] = liv1;
kcnxv[riv2] = liv2;
kccnxv[liv2] = riv2;
int cte = newEdge();
ksv[cte] = liv1;
kev[cte] = riv1;
kep[cte] = PrimProperty::NEW;
// wraps 2 convex hulls in cylindrical
wrapInCylindrical(cte);
// deletes non convex hull primitives
deleteNonHullPrims(liv1, cte, ScanDir::CW);
deleteNonHullPrims(riv1, cte, ScanDir::CCW);
// updates convex hull primitives
updatePrimitives(cte);
}
struct Edge *Graph_addEdge(struct Graph *self, int idSource, int idSink, double cost){
struct Edge *edge = NULL;
struct EdgeLink *edgeLinkToSet, *edgeLinkToList, *edgeLink;
if (idSource >= self->nodeNum || idSink >= self->nodeNum) {
return NULL;
}
edge = newEdge(idSource, idSink, cost);
edgeLinkToSet = (struct EdgeLink*)malloc(sizeof(struct EdgeLink));
edgeLinkToSet->edge = edge;
edgeLinkToList = (struct EdgeLink*)malloc(sizeof(struct EdgeLink));
edgeLinkToList->edge = edge;
//add to edgeSet
edgeLink = self->edgeSet;
self->edgeSet = edgeLinkToSet;
edgeLinkToSet->next = edgeLink;
//add to node edge List
edgeLink = self->nodeEdgeList[idSource];
self->nodeEdgeList[idSource] = edgeLinkToList;
edgeLinkToList->next = edgeLink;
return edge;
}
std::shared_ptr<WindowEdge> WindowEdge::split(size_t nPreceding, size_t nFollowing)
{
assert(_instanceIDs.size() == _valueCoords.size() && _values.size()>=_valueCoords.size() && _values.size() == nPreceding + nFollowing);
std::shared_ptr<WindowEdge> newEdge ( new WindowEdge());
newEdge->_values.assign(_values.begin(), _values.end());
newEdge->_valueCoords.assign(_valueCoords.begin() + nPreceding, _valueCoords.end());
newEdge->_instanceIDs.assign(_instanceIDs.begin() + nPreceding, _instanceIDs.end());
if(newEdge->_valueCoords.size())
{
newEdge->_numFollowing = safe_static_cast<uint32_t>(newEdge->_valueCoords.size() -1);
}
else
{
newEdge->_numFollowing =0;
}
_valueCoords.erase(_valueCoords.begin() + nPreceding, _valueCoords.end());
_instanceIDs.erase(_instanceIDs.begin() + nPreceding, _instanceIDs.end());
if(_valueCoords.size())
{
_numFollowing = safe_static_cast<uint32_t>(_values.size()-1);
}
else
{
_numFollowing = safe_static_cast<uint32_t>(_values.size());
}
return newEdge;
}
int ChainSilhouetteIterator::traverse(const AdjacencyIterator& ait)
{
AdjacencyIterator it(ait);
ViewVertex *nextVertex = getVertex();
// we can't get a NULL nextVertex here, it was intercepted before
if (nextVertex->getNature() & Nature::T_VERTEX) {
TVertex *tvertex = (TVertex *)nextVertex;
ViewEdge *mate = (tvertex)->mate(getCurrentEdge());
while (!it.isEnd()) {
ViewEdge *ve = *it;
if (ve == mate) {
result = ve;
return 0;
}
++it;
}
result = 0;
return 0;
}
if (nextVertex->getNature() & Nature::NON_T_VERTEX) {
//soc NonTVertex *nontvertex = (NonTVertex*)nextVertex;
ViewEdge *newEdge(0);
// we'll try to chain the edges by keeping the same nature...
// the preseance order is : SILHOUETTE, BORDER, CREASE, SUGGESTIVE, VALLEY, RIDGE
Nature::EdgeNature natures[6] = {
Nature::SILHOUETTE,
Nature::BORDER,
Nature::CREASE,
Nature::SUGGESTIVE_CONTOUR,
Nature::VALLEY,
Nature::RIDGE
};
for (unsigned int i = 0; i < 6; ++i) {
if (getCurrentEdge()->getNature() & natures[i]) {
int n = 0;
while (!it.isEnd()) {
ViewEdge *ve = *it;
if (ve->getNature() & natures[i]) {
++n;
newEdge = ve;
}
++it;
}
if (n == 1) {
result = newEdge;
}
else {
result = 0;
}
return 0;
}
}
}
result = 0;
return 0;
}
// builds expansion graph of i-th biconnected component of the original graph
void ExpansionGraph::init(int i)
{
OGDF_ASSERT(0 <= i);
OGDF_ASSERT(i <= m_component.high());
// remove previous component
for(node v : nodes) {
node vOrig = m_vOrig[v];
if (vOrig)
m_vCopy[vOrig] = nullptr;
}
clear();
// create new component
SListConstIterator<edge> it;
for(it = m_component[i].begin(); it.valid(); ++it)
{
edge e = *it;
edge eCopy = newEdge(getCopy(e->source()),getCopy(e->target()));
m_eOrig[eCopy] = e;
}
// expand vertices
for(node v : nodes)
{
if (original(v) && v->indeg() >= 1 && v->outdeg() >= 1) {
node vPrime = newNode();
m_vRep[vPrime] = m_vOrig[v];
SListPure<edge> edges;
v->outEdges(edges);
SListConstIterator<edge> it;
for(it = edges.begin(); it.valid(); ++it)
moveSource(*it,vPrime);
newEdge(v,vPrime);
}
}
}
void PolygonMesh<PointType>::triangulateFace(const typename PolygonMesh<PointType>::FaceIterator& fIt)
{
/* Set up an initial triangle at the face's base point: */
Face* f=&(*fIt);
Edge* e1=f->getEdge();
Vertex* v0=e1->getStart();
Edge* e2=e1->getFaceSucc();
Vertex* v1=e2->getStart();
Edge* e3=e2->getFaceSucc();
Vertex* v2=e3->getStart();
Edge* lastEdge=e1->getFacePred();
/* Walk around face: */
while(e3!=lastEdge)
{
/* Chop triangle (v0,v1,v2) off face: */
Edge* ne1=newEdge();
Edge* ne2=newEdge();
Face* nf=newFace();
nf->setEdge(e1);
e1->setFace(nf);
e1->setFacePred(ne1);
e2->setFace(nf);
e2->setFaceSucc(ne1);
ne1->set(v2,nf,e2,e1,ne2);
ne1->sharpness=0;
f->setEdge(ne2);
/* Reconnect old face: */
ne2->set(v0,f,lastEdge,e3,ne1);
ne2->sharpness=0;
e3->setFacePred(ne2);
lastEdge->setFaceSucc(ne2);
/* Move to next triangle: */
e1=ne2;
v1=v2;
e2=e3;
e3=e3->getFaceSucc();
v2=e3->getStart();
}
}
/**
* Wraps 2 convex hulls in cylindrical
* @param common tangent edge
*/
void ConvexHull::wrapInCylindrical(int cte0) {
int cte1 = cte0;
int cte2 = cte0;
int liv0 = ksv[cte0];
int riv0 = kev[cte0];
int liv1 = liv0;
int riv1 = riv0;
do {
cte1 = cte2;
// searches the edge of the common tangent face
int le = searchEdgeOfCTFace(liv1, riv1, ScanDir::CW);
int re = searchEdgeOfCTFace(riv1, liv1, ScanDir::CCW);
int liv2 = (liv1 == ksv[le] ? kev[le] : ksv[le]);
int riv2 = (riv1 == ksv[re] ? kev[re] : ksv[re]);
// searches the exterior edge of the common tangent face
int kv[] = { riv1, liv1, riv2, liv2 };
Vector3d va[] = { hva[kv[0]], hva[kv[1]], hva[kv[2]], hva[kv[3]] };
bool lext = determ(kv, va);
if (lext) {
kep[le] = PrimProperty::BOUNDARY;
liv1 = liv2;
} else {
kep[re] = PrimProperty::BOUNDARY;
riv1 = riv2;
}
// entries new common tangent face
int f = newFace();
kfp[f] = PrimProperty::NEW;
if (liv1 == liv0 && riv1 == riv0) {
cte2 = cte0;
} else {
cte2 = newEdge();
kep[cte2] = PrimProperty::NEW;
}
klf[cte2] = f;
krf[cte1] = f;
kfe[f] = cte2;
ksv[cte2] = liv1;
kev[cte2] = riv1;
if (lext) {
kscce[cte2] = le;
ksce[cte1] = le;
kece[cte2] = cte1;
kecce[cte1] = cte2;
} else {
kece[cte2] = re;
kecce[cte1] = re;
kscce[cte2] = cte1;
ksce[cte1] = cte2;
}
} while (cte2 != cte0);
}
static struct phyloTree *parseSubTree(char **ptrPtr)
/* the recursive workhorse function, parses a tree from ptr */
{
struct phyloTree *node = NULL;
char *ptr = *ptrPtr;
/* trees are terminated by one of these three chars */
if ((*ptr == ';') || (*ptr == ',') || (*ptr == ')') )
return NULL;
AllocVar(node);
if (*ptr == '(')
{
struct phyloTree *edge;
ptr++;
do
{
struct phyloTree *child = parseSubTree(&ptr);
if (!child)
errAbort("missing child/subTree at (%s)",ptr-1);
edge = newEdge(node,child);
edge->parent = node;
} while (*ptr++ == ',');
--ptr;
if (*ptr++ != ')')
errAbort("unbalanced parenthesis at (%s)",ptr-1);
node->ident = parseIdent(&ptr);
}
else
if ((*ptr == ':') || (isalpha(*ptr))|| (isdigit(*ptr))
|| (*ptr == '\'') || (*ptr == '.'))
node->ident = parseIdent(&ptr);
else
errAbort("illegal char '%c' in phyloString",*ptr);
if (*ptr == '[')
{
if (startsWith("[&&NHX:D=Y]",ptr))
node->isDup = TRUE;
while(*ptr != ']')
ptr++;
ptr++;
}
*ptrPtr = ptr;
return node;
}
void addEdge(int u,int v)
{
E[Ecou].to=v;
E[Ecou].next=head[u];
bridge[Ecou]=0;
chongE[Ecou]=0;
remE[Ecou]=newEdge(u,v,Ecou);
head[u]=Ecou++;
}
typename PolygonMesh<PointType>::VertexIterator PolygonMesh<PointType>::splitEdge(const typename PolygonMesh<PointType>::EdgeIterator& edgeIt,typename PolygonMesh<PointType>::Vertex* edgePoint)
{
/* Link vertex to mesh: */
edgePoint->pred=lastVertex;
edgePoint->succ=0;
if(lastVertex!=0)
lastVertex->succ=edgePoint;
else
vertices=edgePoint;
lastVertex=edgePoint;
Edge* edge1=edgeIt.edge;
Vertex* vertex1=edge1->getStart();
Edge* edge2=edge1->getOpposite();
Vertex* vertex2=edge2->getStart();
Edge* edge3=newEdge();
Edge* edge4=newEdge();
/* Split edge1 and edge2: */
edgePoint->setEdge(edge3);
edge3->set(edgePoint,edge1->getFace(),edge1,edge1->getFaceSucc(),edge2);
edge3->sharpness=edge1->sharpness;
edge4->set(edgePoint,edge2->getFace(),edge2,edge2->getFaceSucc(),edge1);
edge4->sharpness=edge2->sharpness;
edge1->setFaceSucc(edge3);
edge1->setOpposite(edge4);
edge2->setFaceSucc(edge4);
edge2->setOpposite(edge3);
edge3->getFaceSucc()->setFacePred(edge3);
edge4->getFaceSucc()->setFacePred(edge4);
#ifndef NDEBUG
vertex1->checkVertex();
vertex2->checkVertex();
edgePoint->checkVertex();
edge1->getFace()->checkFace();
edge2->getFace()->checkFace();
#endif
return VertexIterator(edgePoint);
}
void PlanRep::collapseVertices(const OrthoRep &OR, GridLayout &drawing)
{
for (node v : nodes) {
const OrthoRep::VertexInfoUML *vi = OR.cageInfo(v);
if(vi == nullptr ||
(typeOf(v) != Graph::highDegreeExpander &&
typeOf(v) != Graph::lowDegreeExpander))
continue;
node vOrig = original(v);
OGDF_ASSERT(vOrig != 0);
node vCenter = newNode();
m_vOrig[vCenter] = vOrig;
m_vCopy[vOrig] = vCenter;
m_vOrig[v] = nullptr;
node lowerLeft = vi->m_corner[odNorth]->theNode();
node lowerRight = vi->m_corner[odWest ]->theNode();
node upperLeft = vi->m_corner[odEast ]->theNode();
drawing.x(vCenter) = (drawing.x(lowerLeft)+drawing.x(lowerRight)) >> 1;
drawing.y(vCenter) = (drawing.y(lowerLeft)+drawing.y(upperLeft )) >> 1;
edge eOrig;
forall_adj_edges(eOrig,vOrig) {
if(eOrig->target() == vOrig) {
node connect = m_eCopy[eOrig].back()->target();
edge eNew = newEdge(connect,vCenter);
m_eOrig[eNew] = eOrig;
m_eIterator[eNew] = m_eCopy[eOrig].pushBack(eNew);
} else {
node connect = m_eCopy[eOrig].front()->source();
edge eNew = newEdge(vCenter,connect);
m_eOrig[eNew] = eOrig;
m_eIterator[eNew] = m_eCopy[eOrig].pushFront(eNew);
}
}
}
}
void FaceSinkGraph::doInit()
{
const ConstCombinatorialEmbedding &E = *m_pE;
NodeArray<node> sinkSwitch(E,nullptr); // corresponding node in F (if any)
NodeArray<bool> isSinkSwitch(E,true);
NodeArray<int> visited(E,-1);
int faceNo = -1;
for(face f : E.faces)
{
faceNo++;
node faceNode = newNode();
m_originalFace[faceNode] = f;
SListPure<node> nodesInF;
adjEntry adj1 = f->firstAdj(), adj = adj1;
do {
node v = adj->theNode();
// if the graph is not biconnected, then node v can visited more than once
if (visited[v] != faceNo) {
nodesInF.pushBack(v);
visited[v] = faceNo;
}
if (v == m_source)
m_containsSource[faceNode] = true;
isSinkSwitch[adj->theEdge()->source()] = false;
adj = adj->twin()->cyclicPred();
} while (adj != adj1);
SListConstIterator<node> it;
for(it = nodesInF.begin(); it.valid(); ++it)
{
node v = *it;
if(isSinkSwitch[v]) {
if (sinkSwitch[v] == nullptr) {
node vF = newNode();
m_originalNode[vF] = v;
sinkSwitch[v] = vF;
}
newEdge(faceNode,sinkSwitch[v]);
}
}
for(it = nodesInF.begin(); it.valid(); ++it)
isSinkSwitch[*it] = true;
}
}
/*
* Append edgeSet at end of the edgeSet list, returns a pointer
* to the edge just added
*/
edgeSet * appendEdgeSet(edgeSet **head, int id)
{
if((*head)==NULL)
{
(*head) = newEdge(id);
return (*head);
}
else
{
return appendEdgeSet(&(*head)->nextEdge, id);
}
}
// builds expansion graph of graph G
// for debugging purposes only
void ExpansionGraph::init(const Graph &G)
{
// remove previous component
for(node v : nodes) {
node vOrig = m_vOrig[v];
if (vOrig)
m_vCopy[vOrig] = nullptr;
}
clear();
// create new component
for(node v : G.nodes)
getCopy(v);
for(edge e : G.edges)
{
edge eCopy = newEdge(getCopy(e->source()),getCopy(e->target()));
m_eOrig[eCopy] = e;
}
// expand vertices
for(node v : nodes)
{
if (original(v) && v->indeg() >= 1 && v->outdeg() >= 1) {
node vPrime = newNode();
SListPure<edge> edges;
v->outEdges(edges);
SListConstIterator<edge> it;
for(it = edges.begin(); it.valid(); ++it)
moveSource(*it,vPrime);
newEdge(v,vPrime);
}
}
}
/*-----------------------------------------------------------------*/
static void
addSuccessor (eBBlock * thisBlock, eBBlock * succ)
{
/* check for boundary conditions */
if (!thisBlock || !succ)
return;
/* add it to the succ of thisBlock */
addSetIfnotP (&thisBlock->succList, succ);
thisBlock->succVect =
bitVectSetBit (thisBlock->succVect, succ->bbnum);
/* add this edge to the list of edges */
addSet (&graphEdges, newEdge (thisBlock, succ));
}
void addEdge(graph* g,int x,int y,int wt)
{
edge* edj = newEdge(y,wt) ;
if(g->adjlist[x]->firstedge == NULL)
{
g->adjlist[x]->firstedge = edj ;
}
else
{
edge* curedge = g->adjlist[x]->firstedge ;
while(curedge->next != NULL)
curedge = curedge->next ;
curedge->next = edj ;
}
g->adjlist[x]->sz += 1 ;
}
void VertexGraph::addEdge(int index1, int index2)
{
// Vertex* v1 = findVertex(index1);
// Vertex* v2 = findVertex(index2);
Edge newEdge(findVertex(index1), findVertex(index2));
for(int i = 0; i < vertices.size(); i++)
{
if(vertices[i].getIndex() == newEdge.getPreviousIndex())
{
//found desired owner of edge
vertices[i].addEdge(newEdge);
}
}
}
//
// insert an arc for each edge with direction m_arcDir
void CompactionConstraintGraphBase::insertBasicArcs(const PlanRep &PG)
{
const Graph &G = *m_pOR;
for(node v : G.nodes)
{
node start = m_pathNode[v];
for(adjEntry adj : v->adjEdges) {
if (m_pOR->direction(adj) == m_arcDir) {
edge e = newEdge(start, m_pathNode[adj->theEdge()->opposite(v)]);
m_edgeToBasicArc[adj] = e;
m_cost[e] = m_edgeCost[PG.typeOf(adj->theEdge())];
//try to pull nodes up in hierarchies
if ( (PG.typeOf(adj->theEdge()) == Graph::generalization) &&
(PG.typeOf(adj->theEdge()->target()) == Graph::generalizationExpander) &&
!(PG.isExpansionEdge(adj->theEdge()))
)
{
if (m_align)
{
//got to be higher than vertexarccost*doublebendfactor
m_cost[e] = 4000*m_cost[e]; //use parameter later corresponding
m_alignmentArc[e] = true;
}//if align
//to compconsgraph::doublebendfactor
else m_cost[e] = 2*m_cost[e];
}
//set generalization type
if (verticalGen(adj->theEdge())) m_verticalArc[e] = true;
//set onborder
if (PG.isDegreeExpansionEdge(adj->theEdge()))
{
edge borderE = adj->theEdge();
node v1 = borderE->source();
node v2 = borderE->target();
m_border[e] = ((v1->degree()>2) && (v2->degree()>2) ? 2 : 1);
}
}
}
}
}
void addEdge(graph* g , int i , int y)
{
edge* temp = g->adjlist[i]->firstedge ;
edge* edg = newEdge(g->v[y]) ;
if(temp == NULL)
{
g->adjlist[i]->firstedge = edg ;
}
else
{
while(temp->next != NULL)
temp = temp->next ;
temp->next = edg ;
}
g->adjlist[i]->sz +=1 ;
}
static void reParent(struct phyloTree *tree)
{
if (tree->parent)
{
struct phyloTree *edge, *saveParent = tree->parent;
reParent(saveParent); /* make the parent into the root */
phyloDeleteEdge(saveParent, tree); /* remove this tree from the
parent tree */
tree->parent = NULL; /* make this tree the root */
edge = newEdge(tree, saveParent); /* add the old parent tree as a
child of the new root */
edge->parent = tree; /* set the parent in the new child */
edge->ident->length = tree->ident->length;
}
}
