// Recursive call for testing c-planarity of the clustered graph
// that is induced by cluster act
bool CconnectClusterPlanar::planarityTest(ClusterGraph &C,
cluster &act,
Graph &G)
{
// Test children first
ListConstIterator<cluster> it;
for (it = act->cBegin(); it.valid();)
{
ListConstIterator<cluster> succ = it.succ();
cluster next = (*it);
if (!planarityTest(C,next,G))
return false;
it = succ;
}
// Get induced subgraph of cluster act and test it for planarity
List<node> subGraphNodes;
ListIterator<node> its;
for (its = act->nBegin(); its.valid(); its++)
subGraphNodes.pushBack(*its);
Graph subGraph;
NodeArray<node> table;
inducedSubGraph(G,subGraphNodes.begin(),subGraph,table);
// Introduce super sink and add edges corresponding
// to outgoing edges of the cluster
node superSink = subGraph.newNode();
EdgeArray<node> outgoingTable(subGraph,0);
for (its = act->nBegin(); its.valid(); its++)
{
node w = (*its);
adjEntry adj = w->firstAdj();
forall_adj(adj,w)
{
edge e = adj->theEdge();
edge cor = 0;
if (table[e->source()] == 0) // edge is connected to a node outside the cluster
{
cor = subGraph.newEdge(table[e->target()],superSink);
outgoingTable[cor] = e->source();
}
else if (table[e->target()] == 0) // dito
{
cor = subGraph.newEdge(table[e->source()],superSink);
outgoingTable[cor] = e->target();
}
// else edge connects two nodes of the cluster
}
}
// recursively write clusters and nodes
static void write_ogml_graph(const ClusterGraphAttributes &A, cluster c, int level, ostream &os)
{
if(level > 0) {
GraphIO::indent(os,2+level) << "<node id=\"c" << c->index() << "\">\n";
if (A.has(GraphAttributes::nodeLabel)) {
GraphIO::indent(os,4) << "<label id=\"lc" << c->index() << "\">\n";
GraphIO::indent(os,5) << "<content>" << formatLabel(A.label(c)) << "</content>\n";
GraphIO::indent(os,4) << "</label>\n";
}
}
ListConstIterator<node> itn;
for (itn = c->nBegin(); itn.valid(); ++itn) {
node v = *itn;
GraphIO::indent(os,3+level) << "<node id=\"n" << v->index() << "\">\n";
if (A.has(GraphAttributes::nodeLabel)) {
GraphIO::indent(os,4) << "<label id=\"ln" << v->index() << "\">\n";
GraphIO::indent(os,5) << "<content>" << formatLabel(A.label(v)) << "</content>\n";
GraphIO::indent(os,4) << "</label>\n";
}
GraphIO::indent(os,3+level) << "</node>\n";
}
for (cluster child : c->children) {
write_ogml_graph(child, level+1, os);
}
if(level > 0) {
GraphIO::indent(os,2+level) << "</node>\n";
}
}
static void writeCluster(
std::ostream &out, int depth,
const ClusterArray < std::vector<edge> > &edgeMap,
const ClusterGraph &C, const ClusterGraphAttributes *CA, const cluster &c,
int &clusterId)
{
if(C.rootCluster() == c) {
writeHeader(out, depth++, CA);
} else {
GraphIO::indent(out, depth++) << "subgraph cluster" << clusterId
<< " {\n";
}
clusterId++;
bool whitespace; // True if a whitespace should printed (readability).
whitespace = false;
if(CA) {
writeAttributes(out, depth, *CA, c);
whitespace = true;
}
if(whitespace) {
out << "\n";
}
// Recursively export all subclusters.
whitespace = false;
for(ListConstIterator<cluster> cit = c->cBegin(); cit.valid(); ++cit) {
writeCluster(out, depth, edgeMap, C, CA, *cit, clusterId);
whitespace = true;
}
if(whitespace) {
out << "\n";
}
// Then, print all nodes whithout an adjacent edge.
whitespace = false;
for(ListConstIterator<node> nit = c->nBegin(); nit.valid(); ++nit) {
whitespace |= writeNode(out, depth, CA, *nit);
}
if(whitespace) {
out << "\n";
}
// Finally, we print all edges for this cluster (ugly version for now).
const std::vector<edge> &edges = edgeMap[c];
whitespace = false;
for(size_t i = 0; i < edges.size(); i++) {
whitespace |= writeEdge(out, depth, CA, edges[i]);
}
GraphIO::indent(out, --depth) << "}\n";
}
//in ClusterGraph??
//is not yet recursive!!!
node collapseCluster(ClusterGraph& CG, cluster c, Graph& G)
{
OGDF_ASSERT(c->cCount() == 0)
ListIterator<node> its;
SListPure<node> collaps;
//we should check here if not empty
node robinson = (*(c->nBegin()));
for (its = c->nBegin(); its.valid(); its++)
collaps.pushBack(*its);
CG.collaps(collaps, G);
if (c != CG.rootCluster())
CG.delCluster(c);
return robinson;
}
void ClusterGraphCopy::createClusterTree(cluster cOrig)
{
cluster c = m_copy[cOrig];
ListConstIterator<cluster> itC;
for(itC = cOrig->cBegin(); itC.valid(); ++itC) {
cluster child = newCluster(c);
m_copy [*itC] = child;
m_original[child] = *itC;
createClusterTree(*itC);
}
ListConstIterator<node> itV;
for(itV = cOrig->nBegin(); itV.valid(); ++itV) {
reassignNode(m_pH->copy(*itV), c);
}
}
static void writeCluster(
std::ostream &out, int depth,
const ClusterGraph &C, const ClusterGraphAttributes *CA, cluster c)
{
if(C.rootCluster() != c) {
GraphIO::indent(out, depth) << "<node "
<< "id=\"cluster" << c->index() << "\""
<< ">\n";
} else {
const std::string dir =
(CA && !CA->directed()) ? "undirected" : "directed";
GraphIO::indent(out, depth) << "<graph "
<< "mode=\"static\""
<< "defaultedgetype=\"" << dir << "\""
<< ">\n";
if(CA) {
defineAttributes(out, depth + 1, *CA);
}
}
GraphIO::indent(out, depth + 1) << "<nodes>\n";
for(ListConstIterator<cluster> cit = c->cBegin(); cit.valid(); ++cit) {
writeCluster(out, depth + 2, C, CA, *cit);
}
for(ListConstIterator<node> nit = c->nBegin(); nit.valid(); ++nit) {
writeNode(out, depth + 2, CA, *nit);
}
GraphIO::indent(out, depth + 1) << "</nodes>\n";
if(C.rootCluster() != c) {
GraphIO::indent(out, depth) << "</node>\n";
} else {
writeEdges(out, C.constGraph(), CA);
GraphIO::indent(out, depth) << "</graph>\n";
}
}