C++ GraphAttributes::strokeWidth方法代码示例

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 void compute_bounding_box(const GraphAttributes &A, double &xmin, double &ymin, double &xmax, double &ymax)
{
	const Graph &G = A.constGraph();
	if(G.numberOfNodes() == 0) {
		xmin = xmax = ymin = ymax = 0;
		return;
	}

	node v = G.firstNode();
	xmin = xmax = A.x(v),
	ymin = ymax = A.y(v);

	forall_nodes(v, G) {
		double lw = (A.attributes() & GraphAttributes::nodeStyle) ? 0.5*A.strokeWidth(v) : 0.5;

		xmax = max(xmax, A.x(v) + A.width (v)/2 + lw);
		ymax = max(ymax, A.y(v) + A.height(v)/2 + lw);
		xmin = min(xmin, A.x(v) - A.width (v)/2 - lw);
		ymin = min(ymin, A.y(v) - A.height(v)/2 - lw);
	}

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))
			{
//.........这里部分代码省略.........

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

//.........这里部分代码省略.........

//.........这里部分代码省略.........
			}

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