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

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