face SimpleEmbedder::findBestExternalFace( const PlanRep& PG, const CombinatorialEmbedding& E) { FaceArray<int> weight(E); for(face f : E.faces) weight[f] = f->size(); for(node v : PG.nodes) { if(PG.typeOf(v) != Graph::generalizationMerger) continue; adjEntry adjFound = nullptr; for(adjEntry adj : v->adjEdges) { if (adj->theEdge()->source() == v) { adjFound = adj; break; } } OGDF_ASSERT(adjFound->theEdge()->source() == v); node w = adjFound->theEdge()->target(); bool isBase = true; for(adjEntry adj : w->adjEdges) { edge e = adj->theEdge(); if(e->target() != w && PG.typeOf(e) == Graph::generalization) { isBase = false; break; } } if(isBase == false) continue; face f1 = E.leftFace(adjFound); face f2 = E.rightFace(adjFound); weight[f1] += v->indeg(); if(f2 != f1) weight[f2] += v->indeg(); } face fBest = E.firstFace(); for(face f : E.faces) if(weight[f] > weight[fBest]) fBest = f; return fBest; }
// faster version of computePolylineClear // clears the list of bend points of all edges in the edge path // in the copy corresponding to eOrig! void Layout::computePolylineClear(PlanRep &PG, edge eOrig, DPolyline &dpl) { dpl.clear(); const List<edge> &edgePath = PG.chain(eOrig); // The corresponding edge path in the copy must contain at least 1 edge! OGDF_ASSERT(edgePath.size() >= 1); // iterate over all edges in the corresponding edge path in the copy bool firstTime = true; for (edge e : edgePath) { node v = e->source(); // append point of source node of e ... if (!firstTime) dpl.pushBack(DPoint(m_x[v], m_y[v])); else firstTime = false; // ... and polyline of e dpl.conc(m_bends[e]); } node w = edgePath.back()->target(); if (PG.typeOf(w) == Graph::NodeType::generalizationExpander) dpl.pushBack(DPoint(m_x[w], m_y[w])); }
// // 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); } } } } }
face SimpleEmbedder::findBestExternalFace(const PlanRep& PG, const CombinatorialEmbedding& E) { FaceArray<int> weight(E); face f; forall_faces(f,E) weight[f] = f->size(); node v; forall_nodes(v,PG) { if(PG.typeOf(v) != Graph::generalizationMerger) continue; adjEntry adj; forall_adj(adj,v) { if(adj->theEdge()->source() == v) break; } OGDF_ASSERT(adj->theEdge()->source() == v); node w = adj->theEdge()->target(); bool isBase = true; adjEntry adj2; forall_adj(adj2, w) { edge e = adj2->theEdge(); if(e->target() != w && PG.typeOf(e) == Graph::generalization) { isBase = false; break; } } if(isBase == false) continue; face f1 = E.leftFace(adj); face f2 = E.rightFace(adj); weight[f1] += v->indeg(); if(f2 != f1) weight[f2] += v->indeg(); }