// assumes, that the Graphs of MultilevelGraph and GA are the same, not copies!
void MultilevelGraph::exportAttributesSimple(GraphAttributes &GA) const
{
OGDF_ASSERT(&(GA.constGraph()) == m_G);
prepareGraphAttributes(GA);
for(node v : m_G->nodes) {
GA.x(v) = m_GA->x(v);
GA.y(v) = m_GA->y(v);
//TODO: Check what this w,h computation does
double w = GA.width(v);
double h = GA.height(v);
if(w > 0 || h > 0) {
double factor = m_radius[v] / sqrt(w*w + h*h) * 2.0f;
w *= factor;
h *= factor;
} else {
w = h = m_radius[v] * sqrt(2.0f);
}
GA.width(v) = w;
GA.height(v) = h;
GA.weight(v) = m_reverseNodeMergeWeight[v->index()];
}
for(edge e : m_G->edges) {
GA.doubleWeight(e) = m_weight[e];
}
}
void MultilevelGraph::importAttributesSimple(const GraphAttributes &GA)
{
OGDF_ASSERT(&(GA.constGraph()) == m_G);
m_avgRadius = 0.0;
for(node v : m_G->nodes) {
double w = GA.width(v);
double h = GA.height(v);
if(w > 0 || h > 0) {
m_radius[v] = sqrt(w*w + h*h) / 2.0f;
} else {
m_radius[v] = 1.0f;
}
m_avgRadius += m_radius[v];
m_GA->x(v) = GA.x(v);
m_GA->y(v) = GA.y(v);
m_GA->width(v) = GA.width(v);
m_GA->height(v) = GA.height(v);
}
m_avgRadius /= m_G->numberOfNodes();
for(edge e : m_G->edges) {
m_weight[e] = GA.doubleWeight(e);
}
}
void PivotMDS::doPathLayout(GraphAttributes& GA, const node& v)
{
double xPos = 0;
node prev = v;
node cur = v;
// since the given node is the beginning of the path just
// use bfs and increment the x coordinate by the average
// edge costs.
do {
GA.x(cur) = xPos;
GA.y(cur) = 0;
for(adjEntry adj : cur->adjEntries) {
node w = adj->twinNode();
if (!(w == prev) || w == cur) {
prev = cur;
cur = w;
if(m_hasEdgeCostsAttribute) {
xPos+=GA.doubleWeight(adj->theEdge());
} else {
xPos += m_edgeCosts;
}
break;
}
prev = cur;
}
} while (prev != cur);
}
static inline bool readVizAttribute(
GraphAttributes &GA,
edge e,
const pugi::xml_node tag)
{
const long attrs = GA.attributes();
if(string(tag.name()) == "viz:color") {
if(attrs & GraphAttributes::edgeStyle) {
return readColor(GA.strokeColor(e), tag);
}
} else if(string(tag.name()) == "viz:thickness") {
auto thickAttr = tag.attribute("value");
if(!thickAttr) {
GraphIO::logger.lout() << "Missing \"value\" on thickness tag." << std::endl;
return false;
}
if(attrs & GraphAttributes::edgeDoubleWeight) {
GA.doubleWeight(e) = thickAttr.as_double();
} else if(attrs & GraphAttributes::edgeIntWeight) {
GA.intWeight(e) = thickAttr.as_int();
}
} else if(string(tag.name()) == "viz:shape") {
// Values: solid, dotted, dashed, double. Not supported in OGDF.
} else {
GraphIO::logger.lout() << "Incorrect tag \"" << tag.name() << "\"." << std::endl;
return false;
}
return true;
}
static inline void writeAttributes(
std::ostream &out, int depth,
const GraphAttributes &GA, edge e)
{
const long attrs = GA.attributes();
if(attrs & GraphAttributes::edgeStyle) {
const Color &color = GA.strokeColor(e);
const int red = color.red();
const int green = color.green();
const int blue = color.blue();
const int alpha = color.alpha();
GraphIO::indent(out, depth) << "<viz:color "
<< "red=\"" << red << "\" "
<< "green=\"" << green << "\" "
<< "blue=\"" << blue << "\" "
<< "alpha=\"" << alpha << "\" "
<< "/>\n";
}
if(attrs & GraphAttributes::edgeDoubleWeight) {
const double weight = GA.doubleWeight(e);
GraphIO::indent(out, depth) << "<viz:thickness "
<< "value=\"" << weight << "\" "
<< "/>\n";
} else if(attrs & GraphAttributes::edgeIntWeight) {
const int weight = GA.intWeight(e);
GraphIO::indent(out, depth) << "<viz:thickness "
<< "value=\"" << weight << "\" "
<< "/>\n";
}
/*
* Edge type and arrow are not supported by VIZ module. Therefore, they
* need to be written using <attvalues> tag (for estetic reasons, we write
* them only if either of them is present). For convenience reasons, we use
* the same names and values as in GraphML format.
*/
if(!(attrs & (GraphAttributes::edgeType | GraphAttributes::edgeArrow))) {
return;
}
GraphIO::indent(out, depth) << "<attvalues>\n";
if(attrs & GraphAttributes::edgeType) {
writeAttValue(
out, depth + 1,
graphml::a_edgeType, graphml::toString(GA.type(e)));
}
if(attrs & GraphAttributes::edgeArrow) {
writeAttValue(
out, depth + 1,
graphml::a_edgeArrow, graphml::toString(GA.arrowType(e)));
}
GraphIO::indent(out, depth) << "</attvalues>\n";
}
void PivotMDS::getPivotDistanceMatrix(
const GraphAttributes& GA,
Array<Array<double> >& pivDistMatrix)
{
const Graph& G = GA.constGraph();
const int n = G.numberOfNodes();
// lower the number of pivots if necessary
int numberOfPivots = min(n, m_numberOfPivots);
// number of pivots times n matrix used to store the graph distances
pivDistMatrix.init(numberOfPivots);
for (int i = 0; i < numberOfPivots; i++) {
pivDistMatrix[i].init(n);
}
// edges costs array
EdgeArray<double> edgeCosts;
bool hasEdgeCosts = false;
// already checked whether this attribute exists or not (see call method)
if (m_hasEdgeCostsAttribute) {
edgeCosts.init(G);
for(edge e : G.edges)
{
edgeCosts[e] = GA.doubleWeight(e);
}
hasEdgeCosts = true;
}
// used for min-max strategy
NodeArray<double> minDistances(G, std::numeric_limits<double>::infinity());
NodeArray<double> shortestPathSingleSource(G);
// the current pivot node
node pivNode = G.firstNode();
for (int i = 0; i < numberOfPivots; i++) {
// get the shortest path from the currently processed pivot node to
// all other nodes in the graph
shortestPathSingleSource.fill(std::numeric_limits<double>::infinity());
if (hasEdgeCosts) {
dijkstra_SPSS(pivNode, G, shortestPathSingleSource, edgeCosts);
} else {
bfs_SPSS(pivNode, G, shortestPathSingleSource, m_edgeCosts);
}
copySPSS(pivDistMatrix[i], shortestPathSingleSource);
// update the pivot and the minDistances array ... to ensure the
// correctness set minDistance of the pivot node to zero
minDistances[pivNode] = 0;
for(node v : G.nodes)
{
minDistances[v] = min(minDistances[v], shortestPathSingleSource[v]);
if (minDistances[v] > minDistances[pivNode]) {
pivNode = v;
}
}
}
}
void ComponentSplitterLayout::call(GraphAttributes &GA)
{
// Only do preparations and call if layout is valid
if (m_secondaryLayout.valid())
{
//first we split the graph into its components
const Graph& G = GA.constGraph();
NodeArray<int> componentNumber(G);
m_numberOfComponents = connectedComponents(G, componentNumber);
if (m_numberOfComponents == 0) {
return;
}
//std::vector< std::vector<node> > componentArray;
//componentArray.resize(numComponents);
//Array<GraphAttributes *> components(numComponents);
//
// intialize the array of lists of nodes contained in a CC
nodesInCC.init(m_numberOfComponents);
node v;
forall_nodes(v,G)
nodesInCC[componentNumber[v]].pushBack(v);
// Create copies of the connected components and corresponding
// GraphAttributes
GraphCopy GC;
GC.createEmpty(G);
EdgeArray<edge> auxCopy(G);
for (int i = 0; i < m_numberOfComponents; i++)
{
GC.initByNodes(nodesInCC[i],auxCopy);
GraphAttributes cGA(GC, GA.attributes());
//copy information into copy GA
forall_nodes(v, GC)
{
cGA.width(v) = GA.width(GC.original(v));
cGA.height(v) = GA.height(GC.original(v));
cGA.x(v) = GA.x(GC.original(v));
cGA.y(v) = GA.y(GC.original(v));
}
// copy information on edges
if (GA.attributes() & GraphAttributes::edgeDoubleWeight) {
edge e;
forall_edges(e, GC) {
cGA.doubleWeight(e) = GA.doubleWeight(GC.original(e));
}
}
static inline void writeAttributes(
std::ostream &out,
const GraphAttributes &GA, const edge &e)
{
const long flags = GA.attributes();
out << "[";
bool comma = false; // Whether to put comma before attribute.
if(flags & GraphAttributes::edgeLabel) {
writeAttribute(out, comma, "label", GA.label(e));
}
if(flags & GraphAttributes::edgeDoubleWeight) {
writeAttribute(out, comma, "weight", GA.doubleWeight(e));
} else if(flags & GraphAttributes::edgeIntWeight) {
writeAttribute(out, comma, "weight", GA.intWeight(e));
}
if(flags & GraphAttributes::edgeGraphics) {
// This should be legal cubic B-Spline in the future.
std::stringstream sstream;
for(const DPoint &p : GA.bends(e)) {
sstream << p.m_x << "," << p.m_y << " ";
}
writeAttribute(out, comma, "pos", sstream.str());
}
if(flags & GraphAttributes::edgeArrow) {
writeAttribute(out, comma, "dir", dot::toString(GA.arrowType(e)));
}
if(flags & GraphAttributes::edgeStyle) {
writeAttribute(out, comma, "color", GA.strokeColor(e));
}
if(flags & GraphAttributes::edgeType) {
writeAttribute(out, comma, "arrowhead", GA.arrowType(e));
// Additionaly, according to IBM UML doc dependency is a dashed edge.
if(GA.type(e) == Graph::dependency) {
writeAttribute(out, comma, "style", "dashed");
}
}
// NOTE: Edge subgraphs are not supported.
out << "]";
}
bool GraphMLParser::readData(
GraphAttributes &GA,
const edge &e,
const pugi::xml_node edgeData)
{
pugi::xml_attribute keyId = edgeData.attribute("key");
if (!keyId) {
GraphIO::logger.lout() << "Edge data does not have a key." << endl;
return false;
}
const long attrs = GA.attributes();
pugi::xml_text text = edgeData.text();
switch(graphml::toAttribute(m_attrName[keyId.value()])) {
case graphml::a_edgeLabel:
if(attrs & GraphAttributes::edgeLabel) {
GA.label(e) = text.get();
}
break;
case graphml::a_edgeWeight:
if(attrs & GraphAttributes::edgeIntWeight) {
GA.intWeight(e) = text.as_int();
} else if(attrs & GraphAttributes::edgeDoubleWeight) {
GA.doubleWeight(e) = text.as_double();
}
break;
case graphml::a_edgeType:
if(attrs & GraphAttributes::edgeType) {
GA.type(e) = graphml::toEdgeType(text.get());
}
break;
case graphml::a_edgeArrow:
if(attrs & GraphAttributes::edgeArrow) {
GA.arrowType(e) = graphml::toArrow(text.get());
}
break;
case graphml::a_edgeStroke:
if(attrs & GraphAttributes::edgeStyle) {
GA.strokeColor(e) = text.get();
}
break;
default:
GraphIO::logger.lout(Logger::LL_MINOR) << "Unknown edge attribute with \""
<< keyId.value()
<< "\"." << endl;
}
return true;
}
void MultilevelGraph::importAttributes(const GraphAttributes &GA)
{
OGDF_ASSERT(GA.constGraph().numberOfNodes() == m_G->numberOfNodes());
OGDF_ASSERT(GA.constGraph().numberOfEdges() == m_G->numberOfEdges());
m_avgRadius = 0.0;
std::vector<node> tempNodeAssociations;
const Graph &cG = GA.constGraph();
tempNodeAssociations.resize(cG.maxNodeIndex()+1, nullptr);
for(node v : cG.nodes) {
tempNodeAssociations[v->index()] = v;
}
for(node v : m_G->nodes) {
double w = GA.width(tempNodeAssociations[m_nodeAssociations[v]]);
double h = GA.height(tempNodeAssociations[m_nodeAssociations[v]]);
if(w > 0 || h > 0) {
m_radius[v] = sqrt(w*w + h*h) / 2.0f;
} else {
m_radius[v] = 1.0f;
}
m_avgRadius += m_radius[v];
m_GA->x(v) = GA.x(tempNodeAssociations[m_nodeAssociations[v]]);
m_GA->y(v) = GA.y(tempNodeAssociations[m_nodeAssociations[v]]);
m_GA->width(v) = GA.width(tempNodeAssociations[m_nodeAssociations[v]]);
m_GA->height(v) = GA.height(tempNodeAssociations[m_nodeAssociations[v]]);
}
m_avgRadius /= m_G->numberOfNodes();
std::vector<edge> tempEdgeAssociations;
tempEdgeAssociations.resize(cG.maxEdgeIndex()+1, nullptr);
for(edge e : cG.edges) {
tempEdgeAssociations[e->index()] = e;
}
for(edge e : m_G->edges) {
m_weight[e] = GA.doubleWeight(tempEdgeAssociations[m_edgeAssociations[e]]);
}
}
void MultilevelGraph::exportAttributes(GraphAttributes &GA) const
{
OGDF_ASSERT(GA.constGraph().numberOfNodes() == m_G->numberOfNodes());
OGDF_ASSERT(GA.constGraph().numberOfEdges() == m_G->numberOfEdges());
prepareGraphAttributes(GA);
std::vector<node> tempNodeAssociations;
const Graph &cG = GA.constGraph();
tempNodeAssociations.resize(cG.maxNodeIndex()+1, nullptr);
for(node v : cG.nodes) {
tempNodeAssociations[v->index()] = v;
}
for(node v : m_G->nodes) {
GA.x(tempNodeAssociations[m_nodeAssociations[v]]) = m_GA->x(v);
GA.y(tempNodeAssociations[m_nodeAssociations[v]]) = m_GA->y(v);
double w = GA.width(tempNodeAssociations[m_nodeAssociations[v]]);
double h = GA.height(tempNodeAssociations[m_nodeAssociations[v]]);
if(w > 0 || h > 0) {
double factor = m_radius[v] / sqrt(w*w + h*h) * 2.0f;
w *= factor;
h *= factor;
} else {
w = h = m_radius[v] * sqrt(2.0f);
}
GA.width(tempNodeAssociations[m_nodeAssociations[v]]) = w;
GA.height(tempNodeAssociations[m_nodeAssociations[v]]) = h;
GA.weight(tempNodeAssociations[m_nodeAssociations[v]]) = m_reverseNodeMergeWeight[v->index()];
}
std::vector<edge> tempEdgeAssociations;
tempEdgeAssociations.resize(cG.maxEdgeIndex()+1, nullptr);
for(edge e :cG.edges) {
tempEdgeAssociations[e->index()] = e;
}
for(edge e : m_G->edges) {
GA.doubleWeight(tempEdgeAssociations[m_edgeAssociations[e]]) = m_weight[e];
}
}
bool GmlParser::read(Graph &G, GraphAttributes &AG)
{
OGDF_ASSERT(&G == &(AG.constGraph()))
G.clear();
int minId = m_mapToNode.low();
int maxId = m_mapToNode.high();
int notDefined = minId-1; //indicates not defined id key
HashArray<string,Shape> strToShape(shRect);
strToShape["rectangle"] = shRect;
strToShape["rect"] = shRect;
strToShape["roundedRect"] = shRoundedRect;
strToShape["oval"] = shEllipse;
strToShape["ellipse"] = shEllipse;
strToShape["triangle"] = shTriangle;
strToShape["pentagon"] = shPentagon;
strToShape["hexagon"] = shHexagon;
strToShape["octagon"] = shOctagon;
strToShape["rhomb"] = shRhomb;
strToShape["trapeze"] = shTrapeze;
strToShape["parallelogram"] = shParallelogram;
strToShape["invTriangle"] = shInvTriangle;
strToShape["invTrapeze"] = shInvTrapeze;
strToShape["invParallelogram"] = shInvParallelogram;
strToShape["image"] = shImage;
DPolyline bends;
GmlObject *son = m_graphObject->m_pFirstSon;
for(; son; son = son->m_pBrother) {
switch(id(son)) {
case nodePredefKey: {
if (son->m_valueType != gmlListBegin) break;
// set attributes to default values
int vId = notDefined;
double x = 0, y = 0, w = 0, h = 0;
string label;
string templ;
string fill; // the fill color attribute
string line; // the line color attribute
string shape; //the shape type
float lineWidth = 1.0f; //node line width
int pattern = 1; //node brush pattern
int stipple = 1; //line style pattern
int weight = 0; // node weight
// read all relevant attributes
GmlObject *nodeSon = son->m_pFirstSon;
for(; nodeSon; nodeSon = nodeSon->m_pBrother) {
switch(id(nodeSon)) {
case idPredefKey:
if(nodeSon->m_valueType != gmlIntValue) break;
vId = nodeSon->m_intValue;
break;
case graphicsPredefKey: {
if (nodeSon->m_valueType != gmlListBegin) break;
GmlObject *graphicsObject = nodeSon->m_pFirstSon;
for(; graphicsObject;
graphicsObject = graphicsObject->m_pBrother)
{
switch(id(graphicsObject)) {
case xPredefKey:
if(graphicsObject->m_valueType != gmlDoubleValue) break;
x = graphicsObject->m_doubleValue;
break;
case yPredefKey:
if(graphicsObject->m_valueType != gmlDoubleValue) break;
y = graphicsObject->m_doubleValue;
break;
case wPredefKey:
if(graphicsObject->m_valueType != gmlDoubleValue) break;
w = graphicsObject->m_doubleValue;
break;
case hPredefKey:
if(graphicsObject->m_valueType != gmlDoubleValue) break;
h = graphicsObject->m_doubleValue;
break;
case fillPredefKey:
if(graphicsObject->m_valueType != gmlStringValue) break;
fill = graphicsObject->m_stringValue;
break;
case linePredefKey:
if(graphicsObject->m_valueType != gmlStringValue) break;
line = graphicsObject->m_stringValue;
break;
case lineWidthPredefKey:
if(graphicsObject->m_valueType != gmlDoubleValue) break;
lineWidth = (float)graphicsObject->m_doubleValue;
break;
case typePredefKey:
if(graphicsObject->m_valueType != gmlStringValue) break;
shape = graphicsObject->m_stringValue;
break;
case patternPredefKey: //fill style
if(graphicsObject->m_valueType != gmlIntValue) break;
pattern = graphicsObject->m_intValue;
case stipplePredefKey: //line style
if(graphicsObject->m_valueType != gmlIntValue) break;
stipple = graphicsObject->m_intValue;
}
}
break; }
case templatePredefKey:
if (nodeSon->m_valueType != gmlStringValue) break;
templ = nodeSon->m_stringValue;
break;
case labelPredefKey:
if (nodeSon->m_valueType != gmlStringValue) break;
label = nodeSon->m_stringValue;
break;
case edgeWeightPredefKey: //sic!
if (nodeSon->m_valueType != gmlIntValue) break;
weight = nodeSon->m_intValue;
break;
}
}
// check if everything required is defined correctly
if (vId == notDefined) {
setError("node id not defined");
return false;
}
// create new node if necessary and assign attributes
if (m_mapToNode[vId] == nullptr) m_mapToNode[vId] = G.newNode();
node v = m_mapToNode[vId];
if (AG.attributes() & GraphAttributes::nodeGraphics)
{
AG.x(v) = x;
AG.y(v) = y;
AG.width (v) = w;
AG.height(v) = h;
AG.shape(v) = strToShape[shape];
}
if (AG.attributes() & GraphAttributes::nodeLabel)
AG.label(m_mapToNode[vId]) = label;
if (AG.attributes() & GraphAttributes::nodeTemplate)
AG.templateNode(m_mapToNode[vId]) = templ;
if (AG.attributes() & GraphAttributes::nodeId)
AG.idNode(m_mapToNode[vId]) = vId;
if (AG.attributes() & GraphAttributes::nodeWeight)
AG.weight(m_mapToNode[vId]) = weight;
if (AG.attributes() & GraphAttributes::nodeStyle)
{
AG.fillColor(m_mapToNode[vId]) = fill;
AG.strokeColor(m_mapToNode[vId]) = line;
AG.setFillPattern(m_mapToNode[vId], intToFillPattern(pattern));
AG.setStrokeType(m_mapToNode[vId], intToStrokeType(stipple));
AG.strokeWidth(m_mapToNode[vId]) = lineWidth;
}
}//node
//Todo: line style set stipple value
break;
case edgePredefKey: {
string arrow; // the arrow type attribute
string fill; //the color fill attribute
int stipple = 1; //the line style
float lineWidth = 1.0f;
double edgeWeight = 1.0;
int subGraph = 0; //edgeSubGraphs attribute
string label; // label attribute
if (son->m_valueType != gmlListBegin) break;
// set attributes to default values
int sourceId = notDefined, targetId = notDefined;
Graph::EdgeType umlType = Graph::association;
// read all relevant attributes
GmlObject *edgeSon = son->m_pFirstSon;
for(; edgeSon; edgeSon = edgeSon->m_pBrother) {
switch(id(edgeSon)) {
case sourcePredefKey:
if (edgeSon->m_valueType != gmlIntValue) break;
sourceId = edgeSon->m_intValue;
break;
case targetPredefKey:
if (edgeSon->m_valueType != gmlIntValue) break;
targetId = edgeSon->m_intValue;
break;
case subGraphPredefKey:
if (edgeSon->m_valueType != gmlIntValue) break;
subGraph = edgeSon->m_intValue;
break;
case labelPredefKey:
if (edgeSon->m_valueType != gmlStringValue) break;
label = edgeSon->m_stringValue;
break;
case graphicsPredefKey: {
if (edgeSon->m_valueType != gmlListBegin) break;
GmlObject *graphicsObject = edgeSon->m_pFirstSon;
for(; graphicsObject;
graphicsObject = graphicsObject->m_pBrother)
{
if(id(graphicsObject) == LinePredefKey &&
graphicsObject->m_valueType == gmlListBegin)
{
readLineAttribute(graphicsObject->m_pFirstSon,bends);
}
if(id(graphicsObject) == arrowPredefKey &&
graphicsObject->m_valueType == gmlStringValue)
arrow = graphicsObject->m_stringValue;
if(id(graphicsObject) == fillPredefKey &&
graphicsObject->m_valueType == gmlStringValue)
fill = graphicsObject->m_stringValue;
if (id(graphicsObject) == stipplePredefKey && //line style
graphicsObject->m_valueType == gmlIntValue)
stipple = graphicsObject->m_intValue;
if (id(graphicsObject) == lineWidthPredefKey && //line width
graphicsObject->m_valueType == gmlDoubleValue)
lineWidth = (float)graphicsObject->m_doubleValue;
if (id(graphicsObject) == edgeWeightPredefKey &&
graphicsObject->m_valueType == gmlDoubleValue)
edgeWeight = graphicsObject->m_doubleValue;
}//for graphics
}
case generalizationPredefKey:
if (edgeSon->m_valueType != gmlIntValue) break;
umlType = (edgeSon->m_intValue == 0) ?
Graph::association : Graph::generalization;
break;
}
}
// check if everything required is defined correctly
if (sourceId == notDefined || targetId == notDefined) {
setError("source or target id not defined");
return false;
} else if (sourceId < minId || maxId < sourceId ||
targetId < minId || maxId < targetId) {
setError("source or target id out of range");
return false;
}
// create adjacent nodes if necessary and new edge
if (m_mapToNode[sourceId] == nullptr) m_mapToNode[sourceId] = G.newNode();
if (m_mapToNode[targetId] == nullptr) m_mapToNode[targetId] = G.newNode();
edge e = G.newEdge(m_mapToNode[sourceId],m_mapToNode[targetId]);
if (AG.attributes() & GraphAttributes::edgeGraphics)
AG.bends(e).conc(bends);
if (AG.attributes() & GraphAttributes::edgeType)
AG.type(e) = umlType;
if(AG.attributes() & GraphAttributes::edgeSubGraphs)
AG.subGraphBits(e) = subGraph;
if (AG.attributes() & GraphAttributes::edgeLabel)
AG.label(e) = label;
if (AG.attributes() & GraphAttributes::edgeArrow) {
if (arrow == "none")
AG.arrowType(e) = eaNone;
else if (arrow == "last")
AG.arrowType(e) = eaLast;
else if (arrow == "first")
AG.arrowType(e) = eaFirst;
else if (arrow == "both")
AG.arrowType(e) = eaBoth;
else
AG.arrowType(e) = eaUndefined;
}
if (AG.attributes() & GraphAttributes::edgeStyle)
{
AG.strokeColor(e) = fill;
AG.setStrokeType(e, intToStrokeType(stipple));
AG.strokeWidth(e) = lineWidth;
}
if (AG.attributes() & GraphAttributes::edgeDoubleWeight)
AG.doubleWeight(e) = edgeWeight;
break; }
case directedPredefKey: {
if(son->m_valueType != gmlIntValue) break;
AG.setDirected(son->m_intValue > 0);
break; }
}
}
return true;
}//read
void ComponentSplitterLayout::call(GraphAttributes &GA)
{
// Only do preparations and call if layout is valid
if (m_secondaryLayout.valid())
{
//first we split the graph into its components
const Graph& G = GA.constGraph();
NodeArray<int> componentNumber(G);
int numberOfComponents = connectedComponents(G, componentNumber);
if (numberOfComponents == 0) {
return;
}
// intialize the array of lists of nodes contained in a CC
Array<List<node> > nodesInCC(numberOfComponents);
for(node v : G.nodes)
nodesInCC[componentNumber[v]].pushBack(v);
// Create copies of the connected components and corresponding
// GraphAttributes
GraphCopy GC;
GC.createEmpty(G);
EdgeArray<edge> auxCopy(G);
for (int i = 0; i < numberOfComponents; i++)
{
GC.initByNodes(nodesInCC[i],auxCopy);
GraphAttributes cGA(GC, GA.attributes());
//copy information into copy GA
for(node v : GC.nodes)
{
cGA.width(v) = GA.width(GC.original(v));
cGA.height(v) = GA.height(GC.original(v));
cGA.x(v) = GA.x(GC.original(v));
cGA.y(v) = GA.y(GC.original(v));
}
// copy information on edges
if (GA.attributes() & GraphAttributes::edgeDoubleWeight) {
for (edge e : GC.edges) {
cGA.doubleWeight(e) = GA.doubleWeight(GC.original(e));
}
}
m_secondaryLayout.get().call(cGA);
//copy layout information back into GA
for(node v : GC.nodes)
{
node w = GC.original(v);
if (w != nullptr)
{
GA.x(w) = cGA.x(v);
GA.y(w) = cGA.y(v);
if (GA.attributes() & GraphAttributes::threeD) {
GA.z(w) = cGA.z(v);
}
}
}
}
// rotate component drawings and call the packer
reassembleDrawings(GA, nodesInCC);
}//if valid
}
bool GmlParser::read(Graph &G, GraphAttributes &AG)
{
OGDF_ASSERT(&G == &(AG.constGraph()))
G.clear();
int minId = m_mapToNode.low();
int maxId = m_mapToNode.high();
int notDefined = minId-1; //indicates not defined id key
DPolyline bends;
GmlObject *son = m_graphObject->m_pFirstSon;
for(; son; son = son->m_pBrother) {
switch(id(son)) {
case nodePredefKey: {
if (son->m_valueType != gmlListBegin) break;
// set attributes to default values
int vId = notDefined;
double x = 0, y = 0, w = 0, h = 0;
String label;
String templ;
String fill; // the fill color attribute
String line; // the line color attribute
String shape; //the shape type
double lineWidth = 1.0; //node line width
int pattern = 1; //node brush pattern
int stipple = 1; //line style pattern
// read all relevant attributes
GmlObject *nodeSon = son->m_pFirstSon;
for(; nodeSon; nodeSon = nodeSon->m_pBrother) {
switch(id(nodeSon)) {
case idPredefKey:
if(nodeSon->m_valueType != gmlIntValue) break;
vId = nodeSon->m_intValue;
break;
case graphicsPredefKey: {
if (nodeSon->m_valueType != gmlListBegin) break;
GmlObject *graphicsObject = nodeSon->m_pFirstSon;
for(; graphicsObject;
graphicsObject = graphicsObject->m_pBrother)
{
switch(id(graphicsObject)) {
case xPredefKey:
if(graphicsObject->m_valueType != gmlDoubleValue) break;
x = graphicsObject->m_doubleValue;
break;
case yPredefKey:
if(graphicsObject->m_valueType != gmlDoubleValue) break;
y = graphicsObject->m_doubleValue;
break;
case wPredefKey:
if(graphicsObject->m_valueType != gmlDoubleValue) break;
w = graphicsObject->m_doubleValue;
break;
case hPredefKey:
if(graphicsObject->m_valueType != gmlDoubleValue) break;
h = graphicsObject->m_doubleValue;
break;
case fillPredefKey:
if(graphicsObject->m_valueType != gmlStringValue) break;
fill = graphicsObject->m_stringValue;
break;
case linePredefKey:
if(graphicsObject->m_valueType != gmlStringValue) break;
line = graphicsObject->m_stringValue;
break;
case lineWidthPredefKey:
if(graphicsObject->m_valueType != gmlDoubleValue) break;
lineWidth = graphicsObject->m_doubleValue;
break;
case typePredefKey:
if(graphicsObject->m_valueType != gmlStringValue) break;
shape = graphicsObject->m_stringValue;
break;
case patternPredefKey: //fill style
if(graphicsObject->m_valueType != gmlIntValue) break;
pattern = graphicsObject->m_intValue;
case stipplePredefKey: //line style
if(graphicsObject->m_valueType != gmlIntValue) break;
stipple = graphicsObject->m_intValue;
}
}
break; }
case templatePredefKey:
if (nodeSon->m_valueType != gmlStringValue) break;
templ = nodeSon->m_stringValue;
break;
case labelPredefKey:
if (nodeSon->m_valueType != gmlStringValue) break;
label = nodeSon->m_stringValue;
break;
}
}
// check if everything required is defined correctly
if (vId == notDefined) {
setError("node id not defined");
return false;
}
// create new node if necessary and assign attributes
if (m_mapToNode[vId] == 0) m_mapToNode[vId] = G.newNode();
if (AG.attributes() & GraphAttributes::nodeGraphics)
{
AG.x(m_mapToNode[vId]) = x;
AG.y(m_mapToNode[vId]) = y;
AG.width (m_mapToNode[vId]) = w;
AG.height(m_mapToNode[vId]) = h;
if (shape == "oval")
AG.shapeNode(m_mapToNode[vId]) = GraphAttributes::oval;
else AG.shapeNode(m_mapToNode[vId]) = GraphAttributes::rectangle;
}
if ( (AG.attributes() & GraphAttributes::nodeColor) &&
(AG.attributes() & GraphAttributes::nodeGraphics) )
{
AG.colorNode(m_mapToNode[vId]) = fill;
AG.nodeLine(m_mapToNode[vId]) = line;
}
if (AG.attributes() & GraphAttributes::nodeLabel)
AG.labelNode(m_mapToNode[vId]) = label;
if (AG.attributes() & GraphAttributes::nodeTemplate)
AG.templateNode(m_mapToNode[vId]) = templ;
if (AG.attributes() & GraphAttributes::nodeId)
AG.idNode(m_mapToNode[vId]) = vId;
if (AG.attributes() & GraphAttributes::nodeStyle)
{
AG.nodePattern(m_mapToNode[vId]) =
GraphAttributes::intToPattern(pattern);
AG.styleNode(m_mapToNode[vId]) =
GraphAttributes::intToStyle(stipple);
AG.lineWidthNode(m_mapToNode[vId]) =
lineWidth;
}
}//node
//Todo: line style set stipple value
break;
case edgePredefKey: {
String arrow; // the arrow type attribute
String fill; //the color fill attribute
int stipple = 1; //the line style
double lineWidth = 1.0;
double edgeWeight = 1.0;
int subGraph = 0; //edgeSubGraph attribute
String label; // label attribute
if (son->m_valueType != gmlListBegin) break;
// set attributes to default values
int sourceId = notDefined, targetId = notDefined;
Graph::EdgeType umlType = Graph::association;
// read all relevant attributes
GmlObject *edgeSon = son->m_pFirstSon;
for(; edgeSon; edgeSon = edgeSon->m_pBrother) {
switch(id(edgeSon)) {
case sourcePredefKey:
if (edgeSon->m_valueType != gmlIntValue) break;
sourceId = edgeSon->m_intValue;
break;
case targetPredefKey:
if (edgeSon->m_valueType != gmlIntValue) break;
targetId = edgeSon->m_intValue;
break;
case subGraphPredefKey:
if (edgeSon->m_valueType != gmlIntValue) break;
subGraph = edgeSon->m_intValue;
break;
case labelPredefKey:
if (edgeSon->m_valueType != gmlStringValue) break;
label = edgeSon->m_stringValue;
break;
case graphicsPredefKey: {
if (edgeSon->m_valueType != gmlListBegin) break;
GmlObject *graphicsObject = edgeSon->m_pFirstSon;
for(; graphicsObject;
graphicsObject = graphicsObject->m_pBrother)
{
if(id(graphicsObject) == LinePredefKey &&
graphicsObject->m_valueType == gmlListBegin)
{
readLineAttribute(graphicsObject->m_pFirstSon,bends);
}
if(id(graphicsObject) == arrowPredefKey &&
graphicsObject->m_valueType == gmlStringValue)
arrow = graphicsObject->m_stringValue;
if(id(graphicsObject) == fillPredefKey &&
graphicsObject->m_valueType == gmlStringValue)
fill = graphicsObject->m_stringValue;
if (id(graphicsObject) == stipplePredefKey && //line style
graphicsObject->m_valueType == gmlIntValue)
stipple = graphicsObject->m_intValue;
if (id(graphicsObject) == lineWidthPredefKey && //line width
graphicsObject->m_valueType == gmlDoubleValue)
lineWidth = graphicsObject->m_doubleValue;
if (id(graphicsObject) == edgeWeightPredefKey &&
graphicsObject->m_valueType == gmlDoubleValue)
edgeWeight = graphicsObject->m_doubleValue;
}//for graphics
}
case generalizationPredefKey:
if (edgeSon->m_valueType != gmlIntValue) break;
umlType = (edgeSon->m_intValue == 0) ?
Graph::association : Graph::generalization;
break;
}
}
// check if everything required is defined correctly
if (sourceId == notDefined || targetId == notDefined) {
setError("source or target id not defined");
return false;
} else if (sourceId < minId || maxId < sourceId ||
targetId < minId || maxId < targetId) {
setError("source or target id out of range");
return false;
}
// create adjacent nodes if necessary and new edge
if (m_mapToNode[sourceId] == 0) m_mapToNode[sourceId] = G.newNode();
if (m_mapToNode[targetId] == 0) m_mapToNode[targetId] = G.newNode();
edge e = G.newEdge(m_mapToNode[sourceId],m_mapToNode[targetId]);
if (AG.attributes() & GraphAttributes::edgeGraphics)
AG.bends(e).conc(bends);
if (AG.attributes() & GraphAttributes::edgeType)
AG.type(e) = umlType;
if(AG.attributes() & GraphAttributes::edgeSubGraph)
AG.subGraphBits(e) = subGraph;
if (AG.attributes() & GraphAttributes::edgeLabel)
AG.labelEdge(e) = label;
if (AG.attributes() & GraphAttributes::edgeArrow)
if (arrow == "none")
AG.arrowEdge(e) = GraphAttributes::none;
else if (arrow == "last")
AG.arrowEdge(e) = GraphAttributes::last;
else if (arrow == "first")
AG.arrowEdge(e) = GraphAttributes::first;
else if (arrow == "both")
AG.arrowEdge(e) = GraphAttributes::both;
else
AG.arrowEdge(e) = GraphAttributes::undefined;
if (AG.attributes() & GraphAttributes::edgeColor)
AG.colorEdge(e) = fill;
if (AG.attributes() & GraphAttributes::edgeStyle)
{
AG.styleEdge(e) = AG.intToStyle(stipple);
AG.edgeWidth(e) = lineWidth;
}
if (AG.attributes() & GraphAttributes::edgeDoubleWeight)
AG.doubleWeight(e) = edgeWeight;
break; }
case directedPredefKey: {
if(son->m_valueType != gmlIntValue) break;
AG.directed(son->m_intValue > 0);
break; }
}
}
return true;
}//read
