// create testGraph to test criteria imlementations
void CreateGraphTwo(Graph& graph, GraphAttributes& GA) {
// add nodes
node Adresses = graph.newNode();
node Schools = graph.newNode();
node Subjects = graph.newNode();
node Parent_Adresses = graph.newNode();
node Student_Adresses = graph.newNode();
node Parents = graph.newNode();
node Student_Parents = graph.newNode();
node Teachers = graph.newNode();
node Classes = graph.newNode();
node Family_Members = graph.newNode();
node Students = graph.newNode();
node Student_Classes = graph.newNode();
node Families = graph.newNode();
node Homework = graph.newNode();
node Reports = graph.newNode();
GA.label(Adresses) = "Adresses";
GA.label(Schools) = "Schools";
GA.label(Subjects) = "Subjects";
GA.label(Parent_Adresses) = "Parent_Adresses";
GA.label(Student_Adresses) = "Student_Adresses";
GA.label(Parents) = "Parents";
GA.label(Student_Parents) = "Student_Parents";
GA.label(Teachers) = "Teachers";
GA.label(Classes) = "Classes";
GA.label(Family_Members) = "Family_Members";
GA.label(Students) = "Students";
GA.label(Student_Classes) = "Student_Classes";
GA.label(Families) = "Families";
GA.label(Homework) = "Homework";
GA.label(Reports) = "Reports";
// add edgraphes
edge SchoolsToAdresses = graph.newEdge(Schools, Adresses);
edge Parent_AdressesToAdresses = graph.newEdge(Parent_Adresses, Adresses);
edge Parent_AdressesToParents = graph.newEdge(Parent_Adresses, Parents);
edge Student_AdressesToAdresses = graph.newEdge(Student_Adresses, Adresses);
edge Student_AdressesToStudents = graph.newEdge(Student_Adresses, Students);
edge Student_ParentsToParents = graph.newEdge(Student_Parents, Parents);
edge Student_ParentsToStudents = graph.newEdge(Student_Parents, Students);
edge TeachersToSchools = graph.newEdge(Teachers, Schools);
edge ClassesToSubjects = graph.newEdge(Classes, Subjects);
edge ClassesToTeachers = graph.newEdge(Classes, Teachers);
edge Family_MembersToParents = graph.newEdge(Family_Members, Parents);
edge Family_MembersToFamilies = graph.newEdge(Family_Members, Families);
edge Family_MembersToStudents = graph.newEdge(Family_Members, Students);
edge Student_ClassesToStudents = graph.newEdge(Student_Classes, Students);
edge Student_ClassesToClasses = graph.newEdge(Student_Classes, Classes);
edge FamiliesToParents = graph.newEdge(Families, Parents);
edge HomeworkToStudents = graph.newEdge(Homework, Students);
edge ReportsToStudents = graph.newEdge(Reports, Students);
for (edge e : graph.edges) {// set default edge color and type
GA.arrowType(e) = ogdf::EdgeArrow::Last;
GA.strokeType(e) = ogdf::StrokeType::Solid;
GA.strokeColor(e) = Color("#bababa");
}
}
static inline void writeAttributes(
std::ostream &out,
const GraphAttributes &GA, const node &v)
{
const long flags = GA.attributes();
out << "[";
bool separator = false; // Wheter to put separator before attribute.
if(flags & GraphAttributes::nodeId) {
writeAttribute(out, separator, "id", GA.idNode(v));
}
if(flags & GraphAttributes::nodeLabel) {
writeAttribute(out, separator, "label", GA.label(v));
}
if(flags & GraphAttributes::nodeTemplate) {
writeAttribute(out, separator, "comment", GA.templateNode(v));
}
if(flags & GraphAttributes::nodeGraphics) {
writeAttribute(out, separator, "width", GA.width(v));
writeAttribute(out, separator, "height", GA.height(v));
writeAttribute(out, separator, "shape", dot::toString(GA.shape(v)));
out << ", pos=\"" << GA.x(v) << "," << GA.y(v);
if(flags & GraphAttributes::threeD) {
out << "," << GA.z(v);
}
out << "\"";
}
if(flags & GraphAttributes::nodeStyle) {
writeAttribute(out, separator, "color", GA.strokeColor(v));
writeAttribute(out, separator, "fillcolor", GA.fillColor(v));
writeAttribute(out, separator, "stroketype", toString(GA.strokeType(v)));
writeAttribute(out, separator, "strokewidth", GA.strokeWidth(v));
writeAttribute(out, separator, "fillpattern", toString(GA.fillPattern(v)));
}
if(flags & GraphAttributes::nodeType) {
writeAttribute(out, separator, "type", int(GA.type(v)));
}
if(flags & GraphAttributes::nodeWeight) {
writeAttribute(out, separator, "weight", GA.weight(v));
}
out << "]";
}
static inline void readAttValue(
GraphAttributes &GA,
node v,
const std::string &name,
const std::string &value)
{
const long attrs = GA.attributes();
// For not "viz" attributes, we use GraphML ones.
switch(graphml::toAttribute(name)) {
case graphml::Attribute::NodeType:
if(attrs & GraphAttributes::nodeType) {
GA.type(v) = graphml::toNodeType(value);
}
break;
case graphml::Attribute::Template:
if(attrs & GraphAttributes::nodeTemplate) {
GA.templateNode(v) = value;
}
break;
case graphml::Attribute::NodeWeight:
if(attrs & GraphAttributes::nodeWeight) {
std::istringstream ss(value);
ss >> GA.weight(v);
}
break;
case graphml::Attribute::NodeStrokeType:
if(attrs & GraphAttributes::nodeStyle) {
GA.strokeType(v) = fromString<StrokeType>(value);
}
break;
case graphml::Attribute::NodeFillPattern:
if(attrs & GraphAttributes::nodeStyle) {
GA.fillPattern(v) = fromString<FillPattern>(value);
}
break;
case graphml::Attribute::NodeStrokeWidth:
if(attrs & GraphAttributes::nodeWeight) {
std::istringstream ss(value);
ss >> GA.strokeWidth(v);
}
static void write_ogml_layout_nodes_edges(const GraphAttributes &A, ostream &os)
{
const Graph &G = A.constGraph();
if (A.has(GraphAttributes::nodeGraphics | GraphAttributes::nodeStyle))
{
for(node v : G.nodes) {
GraphIO::indent(os,4) << "<nodeStyle idRef=\"n" << v->index() << "\">\n";
if(A.has(GraphAttributes::nodeGraphics)) {
GraphIO::indent(os,5) << "<location x=\"" << A.x(v)-0.5*A.width(v) << "\" y=\""<< A.y(v)-0.5*A.height(v) << "\" />\n";
GraphIO::indent(os,5) << "<shape type=\"";
switch (A.shape(v)) {
case shRect:
os << "rect";
break;
case shRoundedRect:
os << "roundedRect";
break;
case shEllipse:
os << "ellipse";
break;
case shTriangle:
os << "triangle";
break;
case shPentagon:
os << "pentagon";
break;
case shHexagon:
os << "hexagon";
break;
case shOctagon:
os << "octagon";
break;
case shRhomb:
os << "rhomb";
break;
case shTrapeze:
os << "trapeze";
break;
case shParallelogram:
os << "parallelogram";
break;
case shInvTriangle:
os << "invTriangle";
break;
case shInvTrapeze:
os << "invTrapeze";
break;
case shInvParallelogram:
os << "invParallelogram";
break;
case shImage:
os << "image";
break;
}
os << "\" width=\"" << A.width(v) << "\" height=\"" << A.height(v) << "\" />\n";
}
if(A.has(GraphAttributes::nodeStyle)) {
// fill-tag
GraphIO::indent(os,5) << "<fill";
// color-attribute of fill-tag
os << " color=\"" << A.fillColor(v) << "\"";
// pattern- and patternColor-attribute of fill-tag (closing)
os << " pattern=\"" << fillPatternToOGML(A.fillPattern(v)) << "\" patternColor=\"" << A.fillBgColor(v) << "\" />\n";
// line-tag
GraphIO::indent(os,5) << "<line type=\"" << edgeStyleToOGML(A.strokeType(v)) << "\" width=\"" << A.strokeWidth(v) << "\""
<< " color=\"" << A.strokeColor(v) << "\"";
// closing fill-tag
os << " />\n";
}
GraphIO::indent(os,4) << "</nodeStyle>\n";
}
}
if (A.has(GraphAttributes::edgeGraphics | GraphAttributes::edgeStyle))
{
int pointId = 0;
for(edge e : G.edges) {
GraphIO::indent(os,4) << "<edgeStyle idRef=\"e" << e->index() << "\">\n";
if(A.has(GraphAttributes::edgeStyle)) {
GraphIO::indent(os,5) << "<line ";
if (A.has(GraphAttributes::edgeStyle)) {
os << "type=\"" << edgeStyleToOGML(A.strokeType(e)) << "\" width=\"" << A.strokeWidth(e) << "\" ";
os << "color=\"" << A.strokeColor(e) << "\" />\n";
} else {
os << " />\n";
}
}
// TODO review the handling of edge arrows
if(A.has(GraphAttributes::edgeArrow))
{
switch(A.arrowType(e)) {
case eaNone:
GraphIO::indent(os,5) << "<sourceStyle type=\"none\" color=\"#000000\" size=\"1\" />\n";
GraphIO::indent(os,5) << "<targetStyle type=\"none\" color=\"#000000\" size=\"1\" />\n";
break;
case eaLast:
GraphIO::indent(os,5) << "<sourceStyle type=\"none\" color=\"#000000\" size=\"1\" />\n";
GraphIO::indent(os,5) << "<targetStyle type=\"arrow\" color=\"#000000\" size=\"1\" />\n";
break;
case eaFirst:
GraphIO::indent(os,5) << "<sourceStyle type=\"arrow\" color=\"#000000\" size=\"1\" />\n";
GraphIO::indent(os,5) << "<targetStyle type=\"none\" color=\"#000000\" size=\"1\" />\n";
break;
case eaBoth:
GraphIO::indent(os,5) << "<sourceStyle type=\"arrow\" color=\"#000000\" size=\"1\" />\n";
GraphIO::indent(os,5) << "<targetStyle type=\"arrow\" color=\"#000000\" size=\"1\" />\n";
break;
case eaUndefined:
// do nothing
break;
default:
// do nothing
break;
}
}
// handling of points
// TODO: Revise for new OGML specification
const DPolyline &dpl = A.bends(e);
if (!dpl.empty()) {
// handle source
node v = e->source();
if(dpl.front().m_x < A.x(v) - A.width(v)/2 ||
dpl.front().m_x > A.x(v) + A.width(v)/2 ||
dpl.front().m_y < A.y(v) - A.height(v)/2 ||
dpl.front().m_y > A.y(v) + A.height(v)/2) {
GraphIO::indent(os,5) << "<point id=\"p" << pointId++ << "\" x=\"" << A.x(e->source()) << "\" y=\"" << A.y(e->source()) << "\" />\n";
}
// handle points
for(const DPoint &dp : dpl) {
GraphIO::indent(os,5) << "<point id=\"p" << pointId++ << "\" x=\"" << dp.m_x << "\" y=\"" << dp.m_y << "\" />\n";
}
// handle target
v = e->target();
if(dpl.back().m_x < A.x(v) - A.width(v)/2 ||
dpl.back().m_x > A.x(v) + A.width(v)/2 ||
dpl.back().m_y < A.y(v) - A.height(v)/2 ||
dpl.back().m_y > A.y(v) + A.height(v)/2) {
GraphIO::indent(os,5) << "<point id=\"p" << pointId++ << "\" x=\"" << A.x(e->target()) << "\" y=\"" << A.y(e->target()) << "\" />\n";
}
}
GraphIO::indent(os,4) << "</edgeStyle>\n";
}
}
}
void createGraphFromJson(Graph& G, GraphAttributes& GA, string file) {
// Read JSON file
ifstream i(file);
json js;
i >> js;
// map to be able to find nodes with name
map<string, node> nodes;
map<string, node>::iterator map_it;
//map<edge, string> relTypes;
//map<edge, string>::iterator map_it2;
// create all nodes
for (size_t i = 0; i < js.size(); i++) {
string name = js[i]["name"];
node n = G.newNode();
GA.label(n) = name;
GA.fillColor(n) = Color::Name::Aquamarine;
nodes.insert(pair<string, node>(name, n));
}
// create all edges
for (size_t i = 0; i < js.size(); i++) {
// walk through node members
for (size_t j = 0; j < js[i]["members"].size(); j++) {
string type = js[i]["members"][j]["relation"];
// check if edge/relation is found
if (type != "NONE") {
// find source node
string source = js[i]["name"];
map_it = nodes.find(source);
// if source node is found, continue
if (map_it != nodes.end()) {
// get source node from map
node s = map_it->second;
// find target node
string target = js[i]["members"][j]["type"]["name"];
map_it = nodes.find(target);
// if target node is found, continue
if (map_it != nodes.end()) {
// get target node from map
node t = map_it->second;
/*
edge ed = G.searchEdge(t, s);
if (ed != 0) {
map_it2 = relTypes.find(ed);
cout << "edge: " << GA.label(s) << " -- " << GA.label(t) << " type: " << type << endl;
cout << "edge: " << GA.label(t) << " -- " << GA.label(s) << " type: " << map_it2->second << endl << endl;
}
*/
// check for double edges and self-loops
if (G.searchEdge(t, s) == 0 && GA.label(s) != GA.label(t)) {
// make new edge
edge e = G.newEdge(s, t);
//relTypes.insert(pair<edge, string>(e, type));
GA.strokeWidth(e) = 0.5;
if (type == "UNI_TO_ONE") {
GA.strokeType(e) = ogdf::StrokeType::Solid;
GA.arrowType(e) = ogdf::EdgeArrow::None;
GA.fillColor(s) = Color::Name::White;
GA.fillColor(t) = Color::Name::White;
} else if (type == "BI_MANY_TO_ONE") {
GA.strokeType(e) = ogdf::StrokeType::Dash;
GA.arrowType(e) = ogdf::EdgeArrow::First;
} else if (type == "BI_ONE_TO_MANY") {
GA.strokeType(e) = ogdf::StrokeType::Dash;
GA.arrowType(e) = ogdf::EdgeArrow::Last;
} else if (type == "BI_MANY_TO_MANY") {
GA.strokeType(e) = ogdf::StrokeType::Dash;
GA.arrowType(e) = ogdf::EdgeArrow::Both;
} else if (type == "BI_ONE_TO_ONE") {
GA.strokeType(e) = ogdf::StrokeType::Dash;
GA.arrowType(e) = ogdf::EdgeArrow::None;
GA.fillColor(s) = Color::Name::White;
GA.fillColor(t) = Color::Name::White;
}
}
}
}
}
}
}
// check degree and delete non-connected nodes
for (map_it = nodes.begin(); map_it != nodes.end(); map_it++) {
node n = map_it->second;
if (n->degree() == 0) {
G.delNode(n);
}
}
/*
// List all nodes
for (node n : G.nodes) {
cout << "FINAL NODES: " << GA.label(n) << endl;
}
// List all edges
cout << endl << endl;
for (edge e : G.edges) {
cout << "FINAL EDGES: " << GA.label(e->source()) << " -- " << GA.label(e->target()) << endl;
}
*/
}
