void UPRSupplier::revertUPR(UpwardPlanRep& upr, GraphAttributes& uga){
upr.delNode(getSource(upr));
upr.delNode(getSink(upr));
upr.delNode(getSink(upr));
node source = getSource(upr);
node sink = getSink(upr);
vector<edge> edgesToDelete;
edge e;
forall_edges(e, upr){
if (upr.original(e)->source() == upr.original(source) || upr.original(e)->target() == upr.original(sink))
edgesToDelete.push_back(e);
}
for (vector<edge>::iterator it = edgesToDelete.begin(); it != edgesToDelete.end(); ++it){
upr.delEdge(*it);
}
upr.delNode(source);
upr.delNode(sink);
vector<node> nodesToUnsplit;
node n;
forall_nodes(n, upr){
if (n->indeg() == 1 && n->outdeg() == 1 && upr.isDummy(n)){
nodesToUnsplit.push_back(n);
}
}
for (vector<node>::iterator it = nodesToUnsplit.begin(); it != nodesToUnsplit.end(); ++it){
edge in = (*it)->firstAdj()->theEdge();
edge out = (*it)->lastAdj()->theEdge();
if (in->source() == *it)
swap(in, out);
DPolyline& inBends = uga.bends(in);
DPolyline& outBends = uga.bends(out);
inBends.popBack();
double x = inBends.back().m_x;
int counter = 0;
for (ListIterator<DPoint> it = outBends.begin(); it != outBends.end(); ++it){
if (counter < 2){
DPoint p(x, (*it).m_y);
inBends.pushBack(p);
counter++;
} else {
inBends.pushBack(*it);
}
}
upr.unsplit(in, out);
}
}
void UPRSupplier::supply(Graph& graph, UpwardPlanRep& retVal){
node addedSource = graph.newNode();
node addedSink = graph.newNode();
if (outputDebug){
cout << "\tAdded super source (" << addedSource->index() << ") and super sink (" << addedSink->index() << ")." << endl;
cout << endl;
}
vector<edge> addedEdges;
node n;
forall_nodes(n, graph){
if (n->indeg() == 0 && n != addedSource && n != addedSink) {
edge e = graph.newEdge(addedSource, n);
addedEdges.push_back(e);
}
}
forall_nodes(n, graph){
if (n->outdeg() == 0 && n != addedSource && n != addedSink) {
edge e = graph.newEdge(n, addedSink);
addedEdges.push_back(e);
}
}
retVal.createEmpty(graph);
assert(&retVal.original() == &graph);
EdgeArray<int> cost (graph, this->normalCost);
if (outputDebug)
cout << "\tAssigning cost " << this->normalCost << " as default cost per edge" << endl;
EdgeArray<bool> forbid (graph, false);
for (vector<edge>::iterator it = addedEdges.begin(); it != addedEdges.end(); ++it){
cost[*it] = this->sourceSinkCost;
if (outputDebug)
cout << "\tAssigning cost " << cost[*it] << " to " << *it << endl;
}
if (outputDebug)
cout << endl;
SubgraphUpwardPlanarizer sup;
FUPSSourceSink* fups = new FUPSSourceSink();
fups->runs(this->runs);
sup.setSubgraph(fups);
sup.setInserter(new OutputUpwardEdgeInserter());
sup.runs(this->runs);
sup.call(retVal, &cost, &forbid);
}
void FUPSSimple::computeFUPS(UpwardPlanRep &UPR, List<edge> &delEdges)
{
const Graph &G = UPR.original();
GraphCopy FUPS(G);
node s_orig;
hasSingleSource(G, s_orig);
List<edge> nonTreeEdges_orig;
bool random = (m_nRuns != 0);
getSpanTree(FUPS, nonTreeEdges_orig, random);
CombinatorialEmbedding Gamma(FUPS);
if (random)
nonTreeEdges_orig.permute(); // random order
adjEntry extFaceHandle = nullptr;
//insert nonTreeEdges
while (!nonTreeEdges_orig.empty()) {
/*
//------------------------------------debug
GraphAttributes AG(FUPS, GraphAttributes::nodeGraphics|
GraphAttributes::edgeGraphics|
GraphAttributes::nodeColor|
GraphAttributes::edgeColor|
GraphAttributes::nodeLabel|
GraphAttributes::edgeLabel
);
// label the nodes with their index
for(node v : AG.constGraph().nodes) {
AG.label(v) = to_string(v->index());
}
AG.writeGML("c:/temp/spannTree.gml");
*/
// make identical copy FUPSCopy of FUPS
//and insert e_orig in FUPSCopy
GraphCopy FUPSCopy((const GraphCopy &) FUPS);
edge e_orig = nonTreeEdges_orig.popFrontRet();
FUPSCopy.newEdge(e_orig);
if (UpwardPlanarity::upwardPlanarEmbed_singleSource(FUPSCopy)) { //upward embedded the fups and check feasibility
CombinatorialEmbedding Beta(FUPSCopy);
//choose a arbitrary feasibel ext. face
FaceSinkGraph fsg(Beta, FUPSCopy.copy(s_orig));
SList<face> ext_faces;
fsg.possibleExternalFaces(ext_faces);
OGDF_ASSERT(!ext_faces.empty());
Beta.setExternalFace(ext_faces.front());
#if 0
//*************************** debug ********************************
cout << endl << "FUPS : " << endl;
for(face ff : Beta.faces) {
cout << "face " << ff->index() << ": ";
adjEntry adjNext = ff->firstAdj();
do {
cout << adjNext->theEdge() << "; ";
adjNext = adjNext->faceCycleSucc();
} while(adjNext != ff->firstAdj());
cout << endl;
}
if (Beta.externalFace() != 0)
cout << "ext. face of the graph is: " << Beta.externalFace()->index() << endl;
else
cout << "no ext. face set." << endl;
#endif
GraphCopy M((const GraphCopy &) FUPSCopy); // use a identical copy of FUPSCopy to construct the merge graph of FUPSCopy
adjEntry extFaceHandle_cur = getAdjEntry(Beta, FUPSCopy.copy(s_orig), Beta.externalFace());
adjEntry adj_orig = FUPSCopy.original(extFaceHandle_cur->theEdge())->adjSource();
List<edge> missingEdges = nonTreeEdges_orig, listTmp = delEdges;
missingEdges.conc(listTmp);
if (constructMergeGraph(M, adj_orig, missingEdges)) {
FUPS = FUPSCopy;
extFaceHandle = FUPS.copy(FUPSCopy.original(extFaceHandle_cur->theEdge()))->adjSource();
continue;
}
else {
//Beta is not feasible
delEdges.pushBack(e_orig);
}
}
else {
// not ok, GC is not feasible
delEdges.pushBack(e_orig);
}
}
UpwardPlanRep fups_tmp (FUPS, extFaceHandle);
UPR = fups_tmp;
}
Module::ReturnType SubgraphUpwardPlanarizer::doCall(UpwardPlanRep &UPR,
const EdgeArray<int> &cost,
const EdgeArray<bool> &forbid)
{
const Graph &G = UPR.original();
GraphCopy GC(G);
//reverse some edges in order to obtain a DAG
List<edge> feedBackArcSet;
m_acyclicMod.get().call(GC, feedBackArcSet);
for(edge e : feedBackArcSet) {
GC.reverseEdge(e);
}
OGDF_ASSERT(isSimple(G));
//mapping cost
EdgeArray<int> cost_GC(GC);
for(edge e : GC.edges) {
if (forbid[GC.original(e)])
cost_GC[e] = numeric_limits<int>::max();
else
cost_GC[e] = cost[GC.original(e)];
}
// tranform to single source graph by adding a super source s_hat and connect it with the other sources
EdgeArray<bool> sourceArcs(GC, false);
node s_hat = GC.newNode();
for(node v : GC.nodes) {
if (v->indeg() == 0 && v != s_hat) {
edge e_tmp = GC.newEdge(s_hat, v);
cost_GC[e_tmp] = 0; // crossings source arcs cause not cost
sourceArcs[e_tmp] = true;
}
}
/*
//------------------------------------------------debug
GraphAttributes AG_GC(GC, GraphAttributes::nodeGraphics|
GraphAttributes::edgeGraphics|
GraphAttributes::nodeColor|
GraphAttributes::edgeColor|
GraphAttributes::nodeLabel|
GraphAttributes::edgeLabel
);
AG_GC.setAllHeight(30.0);
AG_GC.setAllWidth(30.0);
for(node z : AG_GC.constGraph().nodes) {
AG_GC.label(z) = to_string(z->index());
}
AG_GC.writeGML("c:/temp/GC.gml");
// --------------------------------------------end debug
*/
BCTree BC(GC);
const Graph &bcTree = BC.bcTree();
GraphCopy G_dummy;
G_dummy.createEmpty(G);
NodeArray<GraphCopy> biComps(bcTree, G_dummy); // bicomps of G; init with an empty graph
UpwardPlanRep UPR_dummy;
UPR_dummy.createEmpty(G);
NodeArray<UpwardPlanRep> uprs(bcTree, UPR_dummy); // the upward planarized representation of the bicomps; init with an empty UpwarPlanRep
constructComponentGraphs(BC, biComps);
for(node v : bcTree.nodes) {
if (BC.typeOfBNode(v) == BCTree::CComp)
continue;
GraphCopy &block = biComps[v];
OGDF_ASSERT(m_subgraph.valid());
// construct a super source for this block
node s, s_block;
hasSingleSource(block, s);
s_block = block.newNode();
block.newEdge(s_block, s); //connect s
UpwardPlanRep bestUPR;
//upward planarize if not upward planar
if (!UpwardPlanarity::upwardPlanarEmbed_singleSource(block)) {
for (int i = 0; i < m_runs; i++) {// i multistarts
UpwardPlanRep UPR_tmp;
UPR_tmp.createEmpty(block);
List<edge> delEdges;
m_subgraph.get().call(UPR_tmp, delEdges);
OGDF_ASSERT( isSimple(UPR_tmp) );
UPR_tmp.augment();
//mark the source arcs of block
UPR_tmp.m_isSourceArc[UPR_tmp.copy(s_block->firstAdj()->theEdge())] = true;
for (adjEntry adj_tmp : UPR_tmp.copy(s_block->firstAdj()->theEdge()->target())->adjEntries) {
edge e_tmp = UPR_tmp.original(adj_tmp->theEdge());
if (e_tmp != nullptr && block.original(e_tmp) != nullptr && sourceArcs[block.original(e_tmp)])
UPR_tmp.m_isSourceArc[adj_tmp->theEdge()] = true;
}
//assign "crossing cost"
EdgeArray<int> cost_Block(block);
for (edge e : block.edges) {
if (block.original(e) == nullptr || GC.original(block.original(e)) == nullptr)
cost_Block[e] = 0;
else
cost_Block[e] = cost_GC[block.original(e)];
}
/*
if (false) {
//---------------------------------------------------debug
LayerBasedUPRLayout uprLayout;
UpwardPlanRep upr_bug(UPR_tmp.getEmbedding());
adjEntry adj_bug = upr_bug.getAdjEntry(upr_bug.getEmbedding(), upr_bug.getSuperSource(), upr_bug.getEmbedding().externalFace());
node s_upr_bug = upr_bug.newNode();
upr_bug.getEmbedding().splitFace(s_upr_bug, adj_bug);
upr_bug.m_isSourceArc.init(upr_bug, false);
upr_bug.m_isSourceArc[s_upr_bug->firstAdj()->theEdge()] = true;
upr_bug.s_hat = s_upr_bug;
upr_bug.augment();
GraphAttributes GA_UPR_tmp(UPR_tmp, GraphAttributes::nodeGraphics|
GraphAttributes::edgeGraphics|
GraphAttributes::nodeColor|
GraphAttributes::edgeColor|
GraphAttributes::nodeLabel|
GraphAttributes::edgeLabel
);
GA_UPR_tmp.setAllHeight(30.0);
GA_UPR_tmp.setAllWidth(30.0);
uprLayout.call(upr_bug, GA_UPR_tmp);
// label the nodes with their index
for(node z : GA_UPR_tmp.constGraph().nodes) {
GA_UPR_tmp.label(z) = to_string(z->index());
GA_UPR_tmp.y(z)=-GA_UPR_tmp.y(z);
GA_UPR_tmp.x(z)=-GA_UPR_tmp.x(z);
}
for(edge eee : GA_UPR_tmp.constGraph().edges) {
DPolyline &line = GA_UPR_tmp.bends(eee);
ListIterator<DPoint> it;
for(it = line.begin(); it.valid(); it++) {
(*it).m_y = -(*it).m_y;
(*it).m_x = -(*it).m_x;
}
}
GA_UPR_tmp.writeGML("c:/temp/UPR_tmp_fups.gml");
cout << "UPR_tmp/fups faces:";
UPR_tmp.outputFaces(UPR_tmp.getEmbedding());
//end -----------------------------------------------debug
}
*/
delEdges.permute();
m_inserter.get().call(UPR_tmp, cost_Block, delEdges);
if (i != 0) {
if (UPR_tmp.numberOfCrossings() < bestUPR.numberOfCrossings()) {
//cout << endl << "new cr_nr:" << UPR_tmp.numberOfCrossings() << " old cr_nr : " << bestUPR.numberOfCrossings() << endl;
bestUPR = UPR_tmp;
}
}
else
bestUPR = UPR_tmp;
}//for
}
else { //block is upward planar
CombinatorialEmbedding Gamma(block);
FaceSinkGraph fsg((const CombinatorialEmbedding &) Gamma, s_block);
SList<face> faceList;
fsg.possibleExternalFaces(faceList);
Gamma.setExternalFace(faceList.front());
UpwardPlanRep UPR_tmp(Gamma);
UPR_tmp.augment();
//mark the source arcs of block
UPR_tmp.m_isSourceArc[UPR_tmp.copy(s->firstAdj()->theEdge())] = true;
for (adjEntry adj_tmp : UPR_tmp.copy(s->firstAdj()->theEdge()->target())->adjEntries) {
edge e_tmp = UPR_tmp.original(adj_tmp->theEdge());
if (e_tmp != nullptr && block.original(e_tmp) != nullptr && sourceArcs[block.original(e_tmp)])
UPR_tmp.m_isSourceArc[adj_tmp->theEdge()] = true;
}
bestUPR = UPR_tmp;
/*
//debug
//---------------------------------------------------debug
GraphAttributes GA_UPR_tmp(UPR_tmp, GraphAttributes::nodeGraphics|
GraphAttributes::edgeGraphics|
GraphAttributes::nodeColor|
GraphAttributes::edgeColor|
GraphAttributes::nodeLabel|
GraphAttributes::edgeLabel
);
GA_UPR_tmp.setAllHeight(30.0);
GA_UPR_tmp.setAllWidth(30.0);
// label the nodes with their index
for(node z : GA_UPR_tmp.constGraph().nodes) {
GA_UPR_tmp.label(z) = to_string(z->index());
GA_UPR_tmp.y(z)=-GA_UPR_tmp.y(z);
GA_UPR_tmp.x(z)=-GA_UPR_tmp.x(z);
}
for(edge eee : GA_UPR_tmp.constGraph().edges) {
DPolyline &line = GA_UPR_tmp.bends(eee);
ListIterator<DPoint> it;
for(it = line.begin(); it.valid(); it++) {
(*it).m_y = -(*it).m_y;
(*it).m_x = -(*it).m_x;
}
}
GA_UPR_tmp.writeGML("c:/temp/UPR_tmp_fups.gml");
cout << "UPR_tmp/fups faces:";
UPR_tmp.outputFaces(UPR_tmp.getEmbedding());
//end -----------------------------------------------debug
*/
}
uprs[v] = bestUPR;
}
// compute the number of crossings
int nr_cr = 0;
for(node v : bcTree.nodes) {
if (BC.typeOfBNode(v) != BCTree::CComp)
nr_cr = nr_cr + uprs[v].numberOfCrossings();
}
//merge all component to a graph
node parent_BC = BC.bcproper(s_hat);
NodeArray<bool> nodesDone(bcTree, false);
dfsMerge(GC, BC, biComps, uprs, UPR, nullptr, parent_BC, nodesDone); // start with the component which contains the super source s_hat
//augment to single sink graph
UPR.augment();
//set crossings
UPR.crossings = nr_cr;
//------------------------------------------------debug
/*
LayerBasedUPRLayout uprLayout;
UpwardPlanRep upr_bug(UPR.getEmbedding());
adjEntry adj_bug = upr_bug.getAdjEntry(upr_bug.getEmbedding(), upr_bug.getSuperSource(), upr_bug.getEmbedding().externalFace());
node s_upr_bug = upr_bug.newNode();
upr_bug.getEmbedding().splitFace(s_upr_bug, adj_bug);
upr_bug.m_isSourceArc.init(upr_bug, false);
upr_bug.m_isSourceArc[s_upr_bug->firstAdj()->theEdge()] = true;
upr_bug.s_hat = s_upr_bug;
upr_bug.augment();
GraphAttributes AG(UPR, GraphAttributes::nodeGraphics|
GraphAttributes::edgeGraphics|
GraphAttributes::nodeColor|
GraphAttributes::edgeColor|
GraphAttributes::nodeLabel|
GraphAttributes::edgeLabel
);
AG.setAllHeight(30.0);
AG.setAllWidth(30.0);
uprLayout.call(upr_bug, AG);
for(node v : AG.constGraph().nodes) {
int idx;
idx = v->index();
if (UPR.original(v) != 0)
idx = UPR.original(v)->index();
AG.label(v) = to_string(idx);
if (UPR.isDummy(v))
AG.fillColor(v) = "#ff0000";
AG.y(v)=-AG.y(v);
}
// label the edges with their index
for(edge e : AG.constGraph().edges) {
AG.label(e) = to_string(e->index());
if (UPR.isSourceArc(e))
AG.strokeColor(e) = "#00ff00";
if (UPR.isSinkArc(e))
AG.strokeColor(e) = "#ff0000";
DPolyline &line = AG.bends(e);
ListIterator<DPoint> it;
for(it = line.begin(); it.valid(); it++) {
(*it).m_y = -(*it).m_y;
}
}
AG.writeGML("c:/temp/upr_res.gml");
//cout << "UPR_RES";
//UPR.outputFaces(UPR.getEmbedding());
//cout << "Mapping :" << endl;
//for(node v : UPR.nodes) {
// if (UPR.original(v) != 0) {
// cout << "node UPR " << v << " node G " << UPR.original(v) << endl;
// }
//}
// --------------------------------------------end debug
*/
OGDF_ASSERT(hasSingleSource(UPR));
OGDF_ASSERT(isSimple(UPR));
OGDF_ASSERT(isAcyclic(UPR));
OGDF_ASSERT(UpwardPlanarity::isUpwardPlanar_singleSource(UPR));
/*
for(edge eee : UPR.original().edges) {
if (UPR.isReversed(eee))
cout << endl << eee << endl;
}
*/
return Module::retFeasible;
}
void SubgraphUpwardPlanarizer::merge(
const GraphCopy &GC,
UpwardPlanRep &UPR_res,
const GraphCopy &block,
UpwardPlanRep &UPR)
{
node startUPR = UPR.getSuperSource()->firstAdj()->theEdge()->target();
node startRes;
node startG = GC.original(block.original(UPR.original(startUPR)));
bool empty = UPR_res.empty();
if (empty) {
OGDF_ASSERT(startG == 0);
// contruct a node in UPR_res assocciated with startUPR
startRes = UPR_res.newNode();
UPR_res.m_isSinkArc.init(UPR_res, false);
UPR_res.m_isSourceArc.init(UPR_res, false);
UPR_res.s_hat = startRes;
}
else {
startRes = UPR_res.copy(startG);
}
OGDF_ASSERT(startRes != 0);
// compute the adjEntry position (in UPR_res) of the cutvertex startRes
adjEntry pos = nullptr;
if (!empty) {
adjEntry adj_ext = nullptr, adj_int = nullptr;
for(adjEntry run : startRes->adjEntries) {
if (UPR_res.getEmbedding().rightFace(run) == UPR_res.getEmbedding().externalFace()) {
adj_ext = run;
break;
}
if (run->theEdge()->source() == startRes)
adj_int = run;
}
// cutvertex is a sink in UPR_res
if (adj_ext == nullptr && adj_int == nullptr) {
pos = UPR_res.sinkSwitchOf(startRes);
}
else {
if (adj_ext == nullptr)
pos = adj_int;
else
pos = adj_ext;
}
OGDF_ASSERT(pos != 0);
}
// construct for each node (except the two super sink and the super source) of UPR a associated of UPR to UPR_res
NodeArray<node> nodeUPR2UPR_res(UPR, nullptr);
nodeUPR2UPR_res[startUPR] = startRes;
for(node v : UPR.nodes) {
// allready constructed or is super sink or super source
if (v == startUPR || v == UPR.getSuperSink() || v == UPR.getSuperSink()->firstAdj()->theEdge()->source() || v == UPR.getSuperSource())
continue;
node vNew;
if (UPR.original(v) != nullptr ) {
node vG = GC.original(block.original((UPR.original(v))));
if (vG != nullptr)
vNew = UPR_res.newNode(vG);
else
vNew = UPR_res.newNode(); //vG is the super source
}
else // crossing dummy, no original node
vNew = UPR_res.newNode();
nodeUPR2UPR_res[v] = vNew;
}
//add edges of UPR to UPR_res
EdgeArray<edge> edgeUPR2UPR_res(UPR, nullptr);
for(edge e : block.edges) {
if (e->source()->indeg()==0) // the artificial edge with the super source
continue;
List<edge> chains = UPR.chain(e);
edge eG = nullptr, eGC = block.original(e);
eG = GC.original(eGC);
OGDF_ASSERT(!chains.empty());
//construct new edges in UPR_res
for(edge eChain : chains) {
node tgt = nodeUPR2UPR_res[eChain->target()];
node src = nodeUPR2UPR_res[eChain->source()];
edge eNew = UPR_res.newEdge(src, tgt);
edgeUPR2UPR_res[eChain] = eNew;
if (UPR.isSinkArc(UPR.copy(e)))
UPR_res.m_isSinkArc[eNew] = true;
if (UPR.isSourceArc(UPR.copy(e)))
UPR_res.m_isSourceArc[eNew] = true;
if (eG == nullptr) { // edge is associated with a sink arc
UPR_res.m_eOrig[eNew] = nullptr;
continue;
}
UPR_res.m_eOrig[eNew] = eG;
if (chains.size() == 1) { // e is not split
UPR_res.m_eCopy[eG].pushBack(eNew);
UPR_res.m_eIterator[eNew] = UPR_res.m_eCopy[eG].begin();
break;
}
UPR_res.m_eCopy[eG].pushBack(eNew);
UPR_res.m_eIterator[eNew] = UPR_res.m_eCopy[eG].rbegin();
}
}
///*
//* embed the new component in UPR_res with respect to the embedding of UPR
//*/
// for the cut vertex
if (!empty) {
adjEntry run = UPR.getAdjEntry(UPR.getEmbedding(), startUPR, UPR.getEmbedding().externalFace());
run = run->cyclicSucc();
adjEntry adjStart = run;
do {
if (edgeUPR2UPR_res[run->theEdge()] != nullptr) {
adjEntry adj_UPR_res = edgeUPR2UPR_res[run->theEdge()]->adjSource();
UPR_res.moveAdjAfter(adj_UPR_res, pos);
pos = adj_UPR_res;
}
run = run->cyclicSucc();
} while(run != adjStart);
}
for(node v : UPR.nodes) {
if (v == startUPR && !empty)
continue;
node v_UPR_res = nodeUPR2UPR_res[v];
List<adjEntry> adj_UPR, adj_UPR_res;
v->allAdjEntries(adj_UPR);
// convert adj_UPR of v to adj_UPR_res of v_UPR_res
for(adjEntry adj : adj_UPR) {
edge e_res = edgeUPR2UPR_res[adj->theEdge()];
if (e_res == nullptr) // associated edges in UPR_res
continue;
adjEntry adj_res = e_res->adjSource();
if (adj_res->theNode() != v_UPR_res)
adj_res = adj_res->twin();
adj_UPR_res.pushBack(adj_res);
}
UPR_res.sort(v_UPR_res, adj_UPR_res);
}
/*
//---------------------------------------------------debug
if (!UPR_res.empty()) {
GraphAttributes GA_UPR_res(UPR_res, GraphAttributes::nodeGraphics|
GraphAttributes::edgeGraphics|
GraphAttributes::nodeColor|
GraphAttributes::edgeColor|
GraphAttributes::nodeLabel|
GraphAttributes::edgeLabel
);
GA_UPR_res.setAllHeight(30.0);
GA_UPR_res.setAllWidth(30.0);
// label the nodes with their index
for(node z : GA_UPR_res.constGraph().nodes) {
GA_UPR_res.label(z) = to_string(z->index());
}
GA_UPR_res.writeGML("c:/temp/UPR_res_tmp.gml");
cout << "UPR_res_tmp faces:";
UPR_res.outputFaces(UPR_res.getEmbedding());
}
GraphAttributes GA_UPR(UPR, GraphAttributes::nodeGraphics|
GraphAttributes::edgeGraphics|
GraphAttributes::nodeColor|
GraphAttributes::edgeColor|
GraphAttributes::nodeLabel|
GraphAttributes::edgeLabel
);
GA_UPR.setAllHeight(30.0);
GA_UPR.setAllWidth(30.0);
// label the nodes with their index
for(node z : GA_UPR.constGraph().nodes) {
GA_UPR.label(z) = to_string(z->index());
}
GA_UPR.writeGML("c:/temp/UPR_tmp.gml");
cout << "UPR_tmp faces:";
UPR.outputFaces(UPR.getEmbedding());
//end -----------------------------------------------debug
*/
// update UPR_res
UPR_res.initMe();
}
void VisibilityLayout::layout(GraphAttributes &GA, const UpwardPlanRep &UPROrig)
{
UpwardPlanRep UPR = UPROrig;
//clear some data
for(edge e : GA.constGraph().edges) {
GA.bends(e).clear();
}
int minGridDist = 1;
for(node v : GA.constGraph().nodes) {
if (minGridDist < max(GA.height(v), GA.width(v)))
minGridDist = (int) max(GA.height(v), GA.width(v));
}
minGridDist = max(minGridDist*2+1, m_grid_dist);
CombinatorialEmbedding &gamma = UPR.getEmbedding();
//add edge (s,t)
adjEntry adjSrc = nullptr;
for(adjEntry adj : UPR.getSuperSource()->adjEntries) {
if (gamma.rightFace(adj) == gamma.externalFace())
adjSrc = adj;
break;
}
OGDF_ASSERT(adjSrc != nullptr);
edge e_st = UPR.newEdge(adjSrc, UPR.getSuperSink()); // on the right
gamma.computeFaces();
gamma.setExternalFace(gamma.rightFace(e_st->adjSource()));
constructVisibilityRepresentation(UPR);
// the preliminary postion
NodeArray<int> xPos(UPR);
NodeArray<int> yPos(UPR);
// node Position
for(node v : UPR.nodes) {
NodeSegment vVis = nodeToVis[v];
int x = (int) (vVis.x_l + vVis.x_r)/2 ; // median positioning
xPos[v] = x;
yPos[v] = vVis.y;
if (UPR.original(v) != nullptr) {
node vOrig = UPR.original(v);
//final position
GA.x(vOrig) = x * minGridDist;
GA.y(vOrig) = vVis.y * minGridDist;
}
}
//compute bendpoints
for(edge e : GA.constGraph().edges) {
const List<edge> &chain = UPR.chain(e);
for(edge eUPR : chain) {
EdgeSegment eVis = edgeToVis[eUPR];
if (chain.size() == 1) {
if ((yPos[eUPR->target()] - yPos[eUPR->source()]) > 1) {
DPoint p1(eVis.x*minGridDist, (yPos[eUPR->source()]+1)*minGridDist);
DPoint p2(eVis.x*minGridDist, (yPos[eUPR->target()]-1)*minGridDist);
GA.bends(e).pushBack(p1);
if (yPos[eUPR->source()]+1 != yPos[eUPR->target()]-1)
GA.bends(e).pushBack(p2);
}
}
else {
//short edge
if ((yPos[eUPR->target()] - yPos[eUPR->source()]) == 1) {
if (UPR.original(eUPR->target()) == nullptr) {
node tgtUPR = eUPR->target();
DPoint p(xPos[tgtUPR]*minGridDist, yPos[tgtUPR]*minGridDist);
GA.bends(e).pushBack(p);
}
}
//long edge
else {
DPoint p1(eVis.x*minGridDist, (yPos[eUPR->source()]+1)*minGridDist);
DPoint p2(eVis.x*minGridDist, (yPos[eUPR->target()]-1)*minGridDist);
GA.bends(e).pushBack(p1);
if (yPos[eUPR->source()]+1 != yPos[eUPR->target()]-1)
GA.bends(e).pushBack(p2);
if (UPR.original(eUPR->target()) == nullptr) {
node tgtUPR = eUPR->target();
DPoint p(xPos[tgtUPR]*minGridDist, yPos[tgtUPR]*minGridDist);
GA.bends(e).pushBack(p);
}
}
}
}
DPolyline &poly = GA.bends(e);
DPoint pSrc(GA.x(e->source()), GA.y(e->source()));
DPoint pTgt(GA.x(e->target()), GA.y(e->target()));
poly.normalize(pSrc, pTgt);
}
}
