Foam::edgeList Foam::cell::edges(const faceUList& f) const
{
// return the lisf of cell edges
const labelList& curFaces = *this;
// create a list of edges
label maxNoEdges = 0;
forAll(curFaces, faceI)
{
maxNoEdges += f[curFaces[faceI]].nEdges();
}
edgeList allEdges(maxNoEdges);
label nEdges = 0;
forAll(curFaces, faceI)
{
const edgeList curFaceEdges = f[curFaces[faceI]].edges();
forAll(curFaceEdges, faceEdgeI)
{
const edge& curEdge = curFaceEdges[faceEdgeI];
bool edgeFound = false;
for (label addedEdgeI = 0; addedEdgeI < nEdges; addedEdgeI++)
{
if (allEdges[addedEdgeI] == curEdge)
{
edgeFound = true;
break;
}
}
if (!edgeFound)
{
// Add the new edge onto the list
allEdges[nEdges] = curEdge;
nEdges++;
}
}
}
allEdges.setSize(nEdges);
return allEdges;
}
// remove "arcs" from visibArcs which we already have in the constraint graph
// (as basic arcs)
void CompactionConstraintGraphBase::removeRedundantVisibArcs(
SListPure<Tuple2<node,node> > &visibArcs)
{
// bucket sort list of all edges
SListPure<edge> all;
allEdges(all);
parallelFreeSort(*this,all);
// bucket sort visibArcs
BucketFirstIndex bucketSrc;
visibArcs.bucketSort(0,maxNodeIndex(),bucketSrc);
BucketSecondIndex bucketTgt;
visibArcs.bucketSort(0,maxNodeIndex(),bucketTgt);
// now, in both lists, arcs are sorted by increasing target index,
// and arcs with the same target index by increasing source index.
SListConstIterator<edge> itAll = all.begin();
SListIterator<Tuple2<node,node> > it, itNext, itPrev;
// for each arc in visibArcs, we check if it is also contained in list all
for(it = visibArcs.begin(); it.valid(); it = itNext)
{
// required since we delete from the list we traverse
itNext = it.succ();
int i = (*it).x1()->index();
int j = (*it).x2()->index();
// skip all arcs with smaller target index
while(itAll.valid() && (*itAll)->target()->index() < j)
++itAll;
// no more arcs => no more duplicates, so return
if (!itAll.valid()) break;
// if target index is j, we also skip all arcs with target index i
// and source index smaller than i
while(itAll.valid() && (*itAll)->target()->index() == j && (*itAll)->source()->index() < i)
++itAll;
// no more arcs => no more duplicates, so return
if (!itAll.valid()) break;
// if (i,j) is already present, we delete it from visibArcs
if ((*itAll)->source()->index() == i &&
(*itAll)->target()->index() == j)
{
//visibArcs.del(it);
if (itPrev.valid())
visibArcs.delSucc(itPrev);
else
visibArcs.popFront();
} else
itPrev = it;
}//for visibArcs
//****************************CHECK for
//special treatment for cage visibility
//two cases: input node cage: just compare arbitrary node
// merger cage: check first if there are mergers
itPrev = nullptr;
for(it = visibArcs.begin(); it.valid(); it = itNext)
{
itNext = it.succ();
OGDF_ASSERT(!m_path[(*it).x1()].empty());
OGDF_ASSERT(!m_path[(*it).x1()].empty());
node boundRepresentant1 = m_path[(*it).x1()].front();
node boundRepresentant2 = m_path[(*it).x2()].front();
node en1 = m_pPR->expandedNode(boundRepresentant1);
node en2 = m_pPR->expandedNode(boundRepresentant2);
//do not allow visibility constraints in fixed cages
//due to non-planarity with middle position constraints
if ( ( en1 && en2 ) && ( en1 == en2) )
{
if (itPrev.valid()) visibArcs.delSucc(itPrev);
else visibArcs.popFront();
}
else
{
//check if its a genmergerspanning vis arc, merge cases later
node firstn = nullptr, secondn = nullptr;
for (node n : m_path[(*it).x1()])
{
node en = m_pPR->expandedNode(n);
if (!en) continue;
if (!(m_pPR->typeOf(n) == Graph::generalizationExpander)) continue;
else { firstn = en; break; }
}//for
for (node n : m_path[(*it).x2()])
{
node en = m_pPR->expandedNode(n);
if (!en) continue;
if (!(m_pPR->typeOf(n) == Graph::generalizationExpander)) continue;
else { secondn = en; break; }
}//for
if ((firstn && secondn) && (firstn == secondn))
{
if (itPrev.valid()) visibArcs.delSucc(itPrev);
else visibArcs.popFront();
}
else itPrev = it;
}
}//for visibArcs
}
