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();
}