face CombinatorialEmbedding::joinFacesPure(edge e)
{
OGDF_ASSERT(e->graphOf() == m_pGraph);
// get the two faces adjacent to e
face f1 = m_rightFace[e->adjSource()];
face f2 = m_rightFace[e->adjTarget()];
OGDF_ASSERT(f1 != f2);
// we will reuse the largest face and delete the other one
if (f2->m_size > f1->m_size)
swap(f1,f2);
// the size of the joined face is the sum of the sizes of the two faces
// f1 and f2 minus the two adjacency entries of e
f1->m_size += f2->m_size - 2;
// If the stored (first) adjacency entry of f1 belongs to e, we must set
// it to the next entry in the face, because we will remove it by deleting
// edge e
if (f1->entries.m_adjFirst->theEdge() == e)
f1->entries.m_adjFirst = f1->entries.m_adjFirst->faceCycleSucc();
// each adjacency entry in f2 belongs now to f1
adjEntry adj1 = f2->firstAdj(), adj = adj1;
do {
m_rightFace[adj] = f1;
} while((adj = adj->faceCycleSucc()) != adj1);
faces.del(f2);
return f1;
}
edge VarEdgeInserterDynCore::ExpandedGraph::insertEdge(node vG, node wG, edge eG)
{
node &rVG = m_GtoExp[vG];
node &rWG = m_GtoExp[wG];
if (rVG == nullptr) {
rVG = m_exp.newNode();
m_nodesG.pushBack(vG);
}
if (rWG == nullptr) {
rWG = m_exp.newNode();
m_nodesG.pushBack(wG);
}
edge e1 = m_exp.newEdge(rVG, rWG);
if (eG != nullptr) {
m_expToG[e1->adjSource()] = eG->adjSource();
m_expToG[e1->adjTarget()] = eG->adjTarget();
}
else {
m_expToG[e1->adjSource()] = nullptr;
m_expToG[e1->adjTarget()] = nullptr;
}
return e1;
}
//==============================================================================================
void triangle::getedges(edge &e1,edge &e2,edge &e3)
{
e1.setedgeparams(x1,y1,x2,y2,pointids[0],pointids[1]);
e2.setedgeparams(x2,y2,x3,y3,pointids[1],pointids[2]);
e3.setedgeparams(x3,y3,x1,y1,pointids[2],pointids[0]);
}
edge ExpandedGraph2::insertEdge(node vG, node wG, edge eG)
{
node &rVG = m_GtoExp[vG];
node &rWG = m_GtoExp[wG];
if (rVG == 0) {
rVG = m_exp.newNode();
m_nodesG.pushBack(vG);
}
if (rWG == 0) {
rWG = m_exp.newNode();
m_nodesG.pushBack(wG);
}
edge e1 = m_exp.newEdge(rVG,rWG);
if(eG != 0) {
m_expToG[e1->adjSource()] = eG->adjSource();
m_expToG[e1->adjTarget()] = eG->adjTarget();
} else {
m_expToG[e1->adjSource()] = 0;
m_expToG[e1->adjTarget()] = 0;
}
return e1;
}
// Add additional edges between nodes and clusters to reflect adjacency hierarchy also
// with respect to clusters
forall_edges(e, G) {
node u = e->source();
node v = e->target();
// e was reversed?
if(m_copyEdge[e].front()->source() != m_copy[e->source()])
swap(u,v);
if(CG.clusterOf(u) != CG.clusterOf(v)) {
cluster c = lca(u, v);
cluster cTo, cFrom;
if(m_secondPathTo == v) {
cTo = m_secondPath;
cFrom = m_mark[c];
} else {
cFrom = m_secondPath;
cTo = m_mark[c];
}
// Transfer adjacency relationship to a relationship between clusters
// "clusters shall be above each other"
edge eH = 0;
if(cFrom != c && cTo != c)
eH = addEdge(m_bottomNode[cFrom], m_topNode[cTo]);
// if this is not possible, try to relax it to a relationship between node and cluster
if(eH == 0) {
addEdge(m_copy[u], m_topNode[cTo]);
addEdge(m_bottomNode[cFrom], m_copy[v]);
}
}
}
node CombinatorialEmbedding::contract(edge e)
{
// Since we remove face e, we also remove adjSrc and adjTgt.
// We make sure that node of them is stored as first adjacency
// entry of a face.
adjEntry adjSrc = e->adjSource();
adjEntry adjTgt = e->adjTarget();
face fSrc = m_rightFace[adjSrc];
face fTgt = m_rightFace[adjTgt];
if (fSrc->entries.m_adjFirst == adjSrc) {
adjEntry adj = adjSrc->faceCycleSucc();
fSrc->entries.m_adjFirst = (adj != adjTgt) ? adj : adj->faceCycleSucc();
}
if (fTgt->entries.m_adjFirst == adjTgt) {
adjEntry adj = adjTgt->faceCycleSucc();
fTgt->entries.m_adjFirst = (adj != adjSrc) ? adj : adj->faceCycleSucc();
}
node v = m_pGraph->contract(e);
--fSrc->m_size;
--fTgt->m_size;
OGDF_ASSERT_IF(dlConsistencyChecks, consistencyCheck());
return v;
}
forall_edges (e, G)
{
if (e.source() != e.target())
{
edge ec = g.new_edge (partner[e.source()], partner[e.target()]);
w[ec] = edge_weight[e];
}
}
// connects the a.dst to b.org through a new edge
edge connect(edge a, edge b) {
Edge_Record er = make_edge();
er.get_qr().v = a.dst();
er.sym().get_qr().v = b.org();
splice(er, a.lnext());
splice(er.sym(), b);
return er;
}
void TopologicSSSP::relaxEdge(int sourceComponent, int targetComponent, edge e) {
if( m_componentDistanceArray[sourceComponent] + e->getWeight() <
m_componentDistanceArray[targetComponent]) {
m_componentDistanceArray[targetComponent] = m_componentDistanceArray[sourceComponent] + e->getWeight();
m_componentPredsArray[targetComponent] = e->getSource();
m_componentBestArray[targetComponent] = e->getTarget();
}
}
void print_edge(edge e, string delim)
{
int a = e->source()->index(), b = e->target()->index(), t;
if (a > b)
SWAP(a, b, t);
printf("%s%d %d", delim.c_str(), a, b);
}
string print_edge_string(edge e)
{
int a = e->source()->index(), b = e->target()->index(), t;
if (a > b)
SWAP(a, b, t);
sprintf(buf, "%d %d", a, b);
string res = buf;
return res;
}
// tests if two edges cross
bool Planarity::intersect(const edge e1, const edge e2) const
{
node v1s = e1->source();
node v1t = e1->target();
node v2s = e2->source();
node v2t = e2->target();
bool cross = false;
if(v1s != v2s && v1s != v2t && v1t != v2s && v1t != v2t)
cross = lowLevelIntersect(currentPos(v1s),currentPos(v1t),
currentPos(v2s),currentPos(v2t));
return cross;
}
//update face information after inserting a merger ith edge e in a copy graph
void CombinatorialEmbedding::updateMerger(edge e, face fRight, face fLeft)
{
//two cases: a single face/two faces
fRight->m_size++;
fLeft->m_size++;
m_rightFace[e->adjSource()] = fRight;
m_rightFace[e->adjTarget()] = fLeft;
//check for first adjacency entry
if (fRight != fLeft)
{
fRight->entries.m_adjFirst = e->adjSource();
fLeft->entries.m_adjFirst = e->adjTarget();
}//if
}//updateMerger
bool MultilevelGraph::deleteEdge(NodeMerge * NM, edge theEdge)
{
int index = theEdge->index();
NM->m_deletedEdges.push_back(index);
NM->m_doubleWeight[index] = m_weight[theEdge];
NM->m_source[index] = theEdge->source()->index();
NM->m_target[index] = theEdge->target()->index();
m_G->delEdge(theEdge);
m_reverseEdgeIndex[index] = nullptr;
return true;
}
void VarEdgeInserterDynUMLCore::BCandSPQRtreesUML::insertEdgePath(
edge eOrig, const SList<adjEntry>& crossedEdges)
{
SList<edge> ti;
SList<node> tj;
for (adjEntry adj : crossedEdges) {
ti.pushBack(adj->theEdge());
tj.pushBack(adj->theEdge()->target());
}
m_pr.insertEdgePath(eOrig, crossedEdges);
Graph::EdgeType typeOfEOrig = m_pr.typeOrig(eOrig);
int costOfEOrig = m_costOrig ? eOrig ? (*m_costOrig)[eOrig] : 0 : 1;
node v = m_pr.copy(eOrig->source());
SListConstIterator<edge> it = ti.begin();
SListConstIterator<node> jt = tj.begin();
SListConstIterator<adjEntry> kt;
for (kt = crossedEdges.begin(); it.valid(); ++it, ++jt, ++kt) {
edge e = *it;
node u = e->target();
adjEntry a;
for (a = u->firstAdj(); a->theEdge()->target() != *jt; a = a->succ())
;
edge f = a->theEdge();
m_dynamicSPQRForest.updateInsertedNode(e, f);
e = m_dynamicSPQRForest.rep(e);
f = m_dynamicSPQRForest.rep(f);
m_typeOf[f] = m_typeOf[e];
m_cost[f] = m_cost[e];
for (a = u->firstAdj(); a->theEdge()->source() != v; a = a->succ());
f = a->theEdge();
m_dynamicSPQRForest.updateInsertedEdge(f);
f = m_dynamicSPQRForest.rep(f);
m_typeOf[f] = typeOfEOrig;
m_cost[f] = costOfEOrig;
v = u;
}
node u = m_pr.copy(eOrig->target());
adjEntry a;
for (a = v->firstAdj(); a->theEdge()->target() != u; a = a->succ())
;
edge f = a->theEdge();
m_dynamicSPQRForest.updateInsertedEdge(f);
f = m_dynamicSPQRForest.rep(f);
m_typeOf[f] = typeOfEOrig;
m_cost[f] = costOfEOrig;
}
edge PlanRep::split(edge e)
{
bool cageBound = (m_expandedNode[e->source()] && m_expandedNode[e->target()])
&& (m_expandedNode[e->source()] == m_expandedNode[e->target()]);
node expNode = (cageBound ? m_expandedNode[e->source()] : nullptr);
edge eNew = GraphCopy::split(e);
m_eType[eNew] = m_eType[e];
m_edgeTypes[eNew] = m_edgeTypes[e];
m_expansionEdge[eNew] = m_expansionEdge[e];
m_expandedNode[eNew->source()] = expNode;
return eNew;
}
int main(int argc, char *argv[])
{
argList::noParallel();
argList::validArgs.append("surfaceFile");
argList::validArgs.append("output surfaceFile");
argList::validArgs.append("maximum length");
argList args(argc, argv);
const fileName surfFileName = args[1];
const fileName outFileName = args[2];
const scalar maxLength = args.argRead<scalar>(3);
Info<< "Reading surface from " << surfFileName << " ..." << endl << endl;
const triSurface& surf1(surfFileName);
triSurface surf2;
triSurface surf = surf1;
int loopCounter = 1;
while(true)
{
const pointField points(surf.points());
const labelList meshPoints(surf.meshPoints());
const edgeList& edges = surf.edges();
labelListList edgeFaces = surf.sortedEdgeFaces();
List<bool> refineFaces(surf.size(), false);
forAll(edges, i)
{
const edge e = surf.edges()[i];
const point& pStart = points[meshPoints[e.start()]];
const point& pEnd = points[meshPoints[e.end()]];
const vector eVec(pEnd - pStart);
const scalar eMag = mag(eVec);
if(eMag > maxLength)
{
labelList edgeFacesI = edgeFaces[i];
forAll(edgeFacesI, i)
{
label faceI = edgeFacesI[i];
refineFaces[faceI] = true;
}
}
}
static inline bool writeEdge(
std::ostream &out, const int &depth,
const GraphAttributes *GA, const edge &e)
{
GraphIO::indent(out, depth) << e->source()
<< (GA && !GA->directed() ? " -- " : " -> ")
<< e->target();
if(GA) {
out << " ";
writeAttributes(out, *GA, e);
}
out << "\n";
return true;
}
edge CombinatorialEmbedding::split(edge e)
{
face f1 = m_rightFace[e->adjSource()];
face f2 = m_rightFace[e->adjTarget()];
edge e2 = m_pGraph->split(e);
m_rightFace[e->adjSource()] = m_rightFace[e2->adjSource()] = f1;
f1->m_size++;
m_rightFace[e->adjTarget()] = m_rightFace[e2->adjTarget()] = f2;
f2->m_size++;
OGDF_ASSERT_IF(dlConsistencyChecks, consistencyCheck());
return e2;
}
void MultilevelGraph::copyEdgeTo(edge e, MultilevelGraph &MLG, std::map<node, node> &tempNodeAssociations, bool associate, int index)
{
node source = e->source();
node target = e->target();
edge e_new;
if (index == -1) {
e_new = MLG.m_G->newEdge(tempNodeAssociations[source], tempNodeAssociations[target]);
} else {
e_new = MLG.m_G->newEdge(tempNodeAssociations[source], tempNodeAssociations[target], index);
}
if(associate) {
MLG.m_edgeAssociations[e_new] = e->index();
}
MLG.m_weight[e_new] = m_weight[e];
}
/// \{
/// Removes an edge from the matrix.
///
/// Complexity: O(1)
///
/// \param[in] e Edge to remove
/// \param[in] type Type of edge to add
/// \return true on success, false otherwise
///
/// \note This function performs boundary check.
bool remove(edge e, edge::type type = edge::type::uni)
{
if ((e.from >= n) || (e.to >= n))
return false;
at(e) = no_value;
if (type == edge::type::bi)
at(e.reverse()) = no_value;
return true;
}
/// \{
/// Adds an edge to the matrix.
///
/// Complexity: O(1)
///
/// \param[in] e The edge to add
/// \param[in] type Type of edge to add
/// \param[in] value Value for the specified edge
/// \return true on success, false otherwise
///
/// \note This function performs boundary check.
bool add(edge e, edge::type type = edge::type::uni, value_type value = edge_value)
{
if ((e.from >= n) || (e.to >= n))
return false;
at(e) = value;
if (type == edge::type::bi)
at(e.reverse()) = value;
return true;
}
forall_edges(e, primalGraph)
{
adjEntry aE = e->adjSource();
node vDualSource = m_dualNode[CE.rightFace(aE)];
node vDualTarget = m_dualNode[CE.leftFace(aE)];
edge eDual = dualGraph.newEdge(vDualSource, vDualTarget);
m_primalEdge[eDual] = e;
m_dualEdge[e] = eDual;
}
edge next() {
// check hasNext()
assert(curEdge.isValid());
// we are already pointing to the next
edge tmp=curEdge;
// anticipating the next iteration
prepareNext();
return tmp;
}
bool MultilevelGraph::changeEdge(NodeMerge * NM, edge theEdge, double newWeight, node newSource, node newTarget)
{
int index = theEdge->index();
std::vector<int>::iterator pos = find(NM->m_changedEdges.begin(), NM->m_changedEdges.end(), index);
if (pos == NM->m_changedEdges.end()) {
NM->m_changedEdges.push_back(index);
NM->m_doubleWeight[index] = m_weight[theEdge];
NM->m_source[index] = theEdge->source()->index();
NM->m_target[index] = theEdge->target()->index();
}
m_G->delEdge(theEdge);
edge newEdge = m_G->newEdge(newSource, newTarget, index);
m_reverseEdgeIndex[index] = newEdge;
m_weight[newEdge] = newWeight;
return true;
}
double SvgPrinter::getArrowSize(edge e, node v) {
double result = 0;
if(m_attr.has(GraphAttributes::edgeArrow) || m_attr.directed()) {
const double minSize = (m_attr.has(GraphAttributes::edgeStyle) ? m_attr.strokeWidth(e) : 1) * 3;
node w = e->opposite(v);
result = std::max(minSize, (m_attr.width(v) + m_attr.height(v) + m_attr.width(w) + m_attr.height(w)) / 16.0);
}
return result;
}
//inserts copy for original edge eOrig after adAfter
edge PlanRep::newCopy(node v, adjEntry adAfter, edge eOrig)
{
OGDF_ASSERT(eOrig->graphOf() == &(original()))
OGDF_ASSERT(m_eCopy[eOrig].size() == 0)
edge e;
if (adAfter != nullptr)
e = Graph::newEdge(v, adAfter);
else
{
node w = copy(eOrig->opposite(original(v)));
OGDF_ASSERT(w)
e = Graph::newEdge(v, w);
}//else
m_eOrig[e] = eOrig;
m_eIterator[e] = m_eCopy[eOrig].pushBack(e);
//set type of copy
if (m_pGraphAttributes != nullptr)
setCopyType(e, eOrig);
return e;
}
void delete_all_edges(edge hull_edge) {
edge e, e1, e2;
std::vector<Quadedge*> *to_delete = new std::vector<Quadedge*>;
// mark all hull edges as visited
e = hull_edge.sym();
while (not e.get_qr().flag) {
e.get_qr().flag = true; // visited
to_delete->push_back(e.q);
e = e.lnext();
}
// perform dfs and mark all visited faces
std::stack<edge> fringe = std::stack<edge>();
fringe.push(hull_edge);
// invariants:
// if e is popped, e's sym() was already visited
// if e is not visited, neither have any of the other edges of the face
while (not fringe.empty()) {
e = fringe.top();
fringe.pop();
if (not e.get_qr().flag) {
// visit the triangle left of e, mark e and all adjoining edges
// add the sym() of each visited edge except e
e1 = e.lnext();
e2 = e1.lnext();
// assert e == e2.lnext()
e.get_qr().flag = true;
if (not e.sym().get_qr().flag) {
to_delete->push_back(e.q);
}
e1.get_qr().flag = true;
if (not e1.sym().get_qr().flag) {
to_delete->push_back(e1.q);
fringe.push(e1.sym());
}
e2.get_qr().flag = true;
if (not e2.sym().get_qr().flag) {
to_delete->push_back(e2.q);
fringe.push(e2.sym());
}
}
}
std::vector<Quadedge*>::iterator it;
for (it = to_delete->begin(); it != to_delete->end(); ++it) {
delete *it;
}
delete to_delete;
}
void FeasibleUpwardPlanarSubgraph::dfs_visit(
const Graph &G,
edge e,
NodeArray<bool> &visited,
EdgeArray<bool> &treeEdges,
bool random)
{
treeEdges[e] = true;
List<edge> elist;
G.outEdges(e->target(), elist);
if (!elist.empty()) {
if (random)
elist.permute();
ListIterator<edge> it;
for (it = elist.begin(); it.valid(); ++it) {
edge ee = *it;
if (!visited[ee->target()])
dfs_visit(G, ee, visited, treeEdges, random);
}
}
visited[e->target()] = true;
}
static inline void writeEdge(
std::ostream &out, int depth,
const GraphAttributes *GA, edge e)
{
if(GA) {
GraphIO::indent(out, depth) << "<edge id=\"" << e->index() << "\"";
if(GA->attributes() & GraphAttributes::edgeLabel) {
out << " label=\"" << GA->label(e) << "\"";
}
out << ">\n";
writeAttributes(out, depth + 1, *GA, e);
GraphIO::indent(out, depth) << "</edge>\n";
} else {
GraphIO::indent(out, depth) << "<edge "
<< "id=\"" << e->index() << "\" "
<< "source=\"" << e->source() << "\" "
<< "target=\"" << e->target() << "\" "
<< "/>\n";
}
}
