/// <summary>
/// Creates a sample node for this demo.
/// </summary>
private static void CreateNode(IGraph graph, double x, double y, double w, double h, Color fillColor, Color textColor, string labelText)
{
var whiteTextLabelStyle = new DefaultLabelStyle {
TextBrush = new SolidBrush(textColor)
};
INode node = graph.CreateNode(new RectD(x, y, w, h), new ShinyPlateNodeStyle {
Brush = new SolidBrush(fillColor)
}, fillColor);
graph.SetStyle(graph.AddLabel(node, labelText), whiteTextLabelStyle);
}
/// <summary>
/// Creates a sample node for this demo.
/// </summary>
private static INode CreateNode(IGraph graph, double x, double y, double w, double h, Color color, string labelText)
{
var whiteTextLabelStyle = new DefaultLabelStyle {
TextBrush = Brushes.White
};
INode node = graph.CreateNode(new RectD(x, y, w, h), new ShinyPlateNodeStyle {
Brush = new SolidBrush(color)
}, color);
graph.SetStyle(graph.AddLabel(node, labelText), whiteTextLabelStyle);
return(node);
}
/// <summary>
/// Creates a large random graph to give the layout algorithms something to chew.
/// </summary>
private static void BuildGraph(IGraph graph)
{
graph.Clear();
// Create 400 nodes
INode[] nodes = new INode[400];
for (int i = 0; i < nodes.Length; i++)
{
nodes[i] = graph.CreateNode();
}
// Connect the nodes randomly
Random random = new Random(0);
for (int i = 0; i < nodes.Length; i++)
{
int edgeCount;
if (random.Next(10) == 0)
{
edgeCount = 4 + random.Next(5);
}
else
{
edgeCount = random.Next(3);
}
for (int j = 0; j < edgeCount; j++)
{
graph.CreateEdge(nodes[i], nodes[random.Next(nodes.Length)]);
}
}
// remove all components except the largest one
var adapter = new YGraphAdapter(graph);
NodeList[] components = GraphConnectivity.ConnectedComponents(adapter.YGraph);
Array.Sort(components, (o1, o2) => o2.Count - o1.Count);
for (int i = components.Length - 1; i > 0; i--)
{
foreach (var node in components[i])
{
graph.Remove(adapter.GetOriginalNode(node));
}
}
// add labels
int count = 0;
foreach (var node in graph.Nodes)
{
graph.AddLabel(node, count++.ToString());
}
RandomizeGraph(graph);
}
/// <summary>
/// Copy one node label.
/// </summary>
/// <param name="pageView">The view (i.e. target) graph.</param>
/// <param name="nodeLabelLayout">The layout of the label.</param>
/// <param name="modelLabel">The model (i.e. original) label.</param>
/// <param name="layoutNode">The node in the layout graph. </param>
/// <param name="viewNode">The node in the view graph.</param>
/// <returns>The copied label.</returns>
private ILabel CopyNodeLabel(IGraph pageView, INodeLabelLayout nodeLabelLayout, ILabel modelLabel, Node layoutNode, INode viewNode)
{
INodeInfo nodeInfo = result.GetNodeInfo(layoutNode);
ILabelDefaults labelDefaults;
// determine the style for the label
switch (nodeInfo.Type)
{
case NodeType.Group:
labelDefaults = GroupNodeDefaults.Labels;
break;
case NodeType.Connector:
labelDefaults = ConnectorNodeDefaults.Labels;
break;
case NodeType.Proxy:
labelDefaults = ProxyNodeDefaults.Labels;
break;
case NodeType.ProxyReference:
labelDefaults = ProxyReferenceNodeDefaults.Labels;
break;
default:
labelDefaults = NormalNodeDefaults.Labels;
break;
}
ILabelModelParameter parameter = labelDefaults.LayoutParameter != NullLabelModelParameter
? labelDefaults.GetLayoutParameterInstance(viewNode)
: (ILabelModelParameter)nodeLabelLayout.ModelParameter;
ILabelStyle style = labelDefaults.Style != NullLabelStyle
? labelDefaults.GetStyleInstance(viewNode)
: (ILabelStyle)(modelLabel != null ? modelLabel.Style.Clone() : pageView.NodeDefaults.Labels.Style);
string text = modelLabel != null ? modelLabel.Text : null;
object tag = modelLabel != null ? modelLabel.Tag : null;
// create a new label in the view graph using the style,
// the text and tag from the original label and the layout from the layout graph
ILabel viewLabel = pageView.AddLabel(viewNode, text, parameter, style);
viewLabel.Tag = tag;
return(viewLabel);
}
/// <summary>
/// Copy one edge label.
/// </summary>
/// <param name="pageView">The view (i.e. target) graph.</param>
/// <param name="edgeLabelLayout">The layout of the label.</param>
/// <param name="modelLabel">The original label.</param>
/// <param name="viewEdge">The copied edge (from the view graph).</param>
/// <param name="labelDefaults"></param>
/// <returns>The copied label.</returns>
private ILabel CopyEdgeLabel(IGraph pageView, IEdgeLabelLayout edgeLabelLayout, ILabel modelLabel, IEdge viewEdge, ILabelDefaults labelDefaults)
{
// get the style from edgeLabelStyle property. If none is set get it from the original (model) label.
ILabelStyle style = (ILabelStyle)(labelDefaults.Style != NullLabelStyle ?
labelDefaults.GetStyleInstance(viewEdge) :
modelLabel.Style.Clone());
ILabelModelParameter parameter = labelDefaults.LayoutParameter != NullLabelModelParameter
? labelDefaults.GetLayoutParameterInstance(viewEdge)
: (ILabelModelParameter)edgeLabelLayout.ModelParameter;
// create a new label in the view graph using the style,
// the text from the original label and the layout from the layout graph
ILabel viewLabel = pageView.AddLabel(viewEdge, modelLabel.Text, parameter, style);
viewLabel.Tag = modelLabel.Tag;
return(viewLabel);
}
public IEdge CreateEdge(IGraph graph, [CanBeNull] INode source, [CanBeNull] INode target,
[CanBeNull] object labelData, [CanBeNull] TEdge edgeObject)
{
if (source == null || target == null)
{
// early exit if source or target node doesn't exist
return(null);
}
var edge = graph.CreateEdge(source, target, graph.EdgeDefaults.GetStyleInstance(), edgeObject);
if (labelData != null)
{
graph.AddLabel(edge, labelData.ToString(), null, null, null, labelData);
}
this.OnEdgeCreated(edge, edgeObject);
return(edge);
}
/// <summary>
/// Create a proxy reference node, i.e., a node referencing a proxy node.
/// </summary>
/// <remarks>
/// This implementation copies the labels of the represented node and applies the <c>ProxyReferenceNodeStyle</c>.
/// </remarks>
/// <param name="pageLayoutGraph">The layout graph representing the current page</param>
/// <param name="layoutNode">The node of the layout graph that should be copied</param>
/// <param name="pageView">The <see cref="IGraph"/> that is built to show the multi-page layout in a graph canvas</param>
/// <returns>The created node</returns>
/// <seealso cref="CreateNodeCore"/>
protected INode CreateProxyReferenceNode(LayoutGraph pageLayoutGraph, Node layoutNode, IGraph pageView)
{
INode representedNode = GetRepresentedNode(layoutNode);
INode viewNode = CreateNodeCore(pageLayoutGraph, pageView, layoutNode, representedNode, true, ProxyReferenceNodeDefaults);
INodeInfo nodeInfo = result.GetNodeInfo(layoutNode);
Node referencingNode = nodeInfo.ReferencingNode;
int targetPage = result.GetNodeInfo(referencingNode).PageNo;
ILabelStyle style = ProxyNodeDefaults.Labels.Style != NullLabelStyle
? ProxyNodeDefaults.Labels.GetStyleInstance(viewNode)
: pageView.NodeDefaults.Labels.GetStyleInstance(viewNode);
ILabelModelParameter parameter = ProxyNodeDefaults.Labels.LayoutParameter != NullLabelModelParameter
? ProxyNodeDefaults.Labels.GetLayoutParameterInstance(viewNode)
: pageView.NodeDefaults.Labels.GetLayoutParameterInstance(viewNode);
pageView.AddLabel(viewNode, "p" + targetPage, parameter, style);
return(viewNode);
}
/// <summary>
/// Creates a group node for the sample graph with a specific styling.
/// </summary>
private static INode CreateGroupNode(IGraph graph, double x, double y, Color fillColor, string labelText)
{
var groupNode = graph.CreateGroupNode();
graph.SetStyle(groupNode, new PanelNodeStyle {
Color = fillColor, LabelInsetsColor = fillColor, Insets = new InsetsD(5, 20, 5, 5)
});
graph.SetNodeLayout(groupNode, new RectD(x, y, 130, 100));
// The label style and placement
var labelStyle = new DefaultLabelStyle();
labelStyle.TextBrush = Brushes.White;
var labelModel = new InteriorStretchLabelModel();
labelModel.Insets = new InsetsD(5, 2, 5, 4);
var modelParameter = labelModel.CreateParameter(InteriorStretchLabelModel.Position.North);
graph.AddLabel(groupNode, labelText, modelParameter, labelStyle);
groupNode.Tag = fillColor;
return(groupNode);
}
/// <summary>
/// Callback used by <see cref="CreateEdgeInputMode"/> to create an edge.
/// </summary>
/// <remarks>
/// This implementation adds a label to the newly created edge and sets up the correct business object.
/// Note that only edges from Customers to Products are allowed.
/// </remarks>
private IEdge CreateEdge(IInputModeContext context, IGraph graph, IPortCandidate sourcePortCandidate, IPortCandidate targetPortCandidate, IEdge templateEdge)
{
var sourcePort = sourcePortCandidate.Port ?? sourcePortCandidate.CreatePort(context);
var targetPort = targetPortCandidate.Port ?? targetPortCandidate.CreatePort(context);
var customer = sourcePort.Owner.Tag as Customer;
var product = targetPort.Owner.Tag as Product;
if (customer != null && product != null)
{
var edge = graph.CreateEdge(sourcePort, targetPort, edgeStyle);
var relation = new Relation()
{
Customer = customer, Product = product
};
var label = graph.AddLabel(edge, relation.ToString());
label.Tag = relation;
return(edge);
}
else
{
return(null);
}
}
/// <summary>
/// Creates the sample graph.
/// </summary>
private void InitializeGraph(IGraph graph)
{
INode[] nodes = new INode[16];
int count = 0;
for (int i = 1; i < 5; i++)
{
nodes[count++] = graph.CreateNode(new PointD(50 + 40 * i, 260));
nodes[count++] = graph.CreateNode(new PointD(50 + 40 * i, 40));
nodes[count++] = graph.CreateNode(new PointD(40, 50 + 40 * i));
nodes[count++] = graph.CreateNode(new PointD(260, 50 + 40 * i));
}
for (int i = 0; i < nodes.Length; i++)
{
graph.AddLabel(nodes[i], "" + i);
}
graph.CreateEdge(nodes[0], nodes[1]);
graph.CreateEdge(nodes[5], nodes[4]);
graph.CreateEdge(nodes[2], nodes[3]);
graph.CreateEdge(nodes[7], nodes[6]);
graph.CreateEdge(nodes[2 + 8], nodes[3 + 8]);
graph.CreateEdge(nodes[7 + 8], nodes[6 + 8]);
graph.CreateEdge(nodes[0 + 8], nodes[1 + 8]);
graph.CreateEdge(nodes[5 + 8], nodes[4 + 8]);
// enable undo...
graph.SetUndoEngineEnabled(true);
GraphControl.FitGraphBounds();
}
/// <summary>
/// Creates a node of the specified type.
/// </summary>
/// <remarks>
/// The method will specify the ports that the node should have based on its type.
/// </remarks>
private void CreateNode(IGraph graph, PointD location, LogicGateType type, string label = null, SizeD?size = null)
{
RectD newBounds = RectD.FromCenter(location, graph.NodeDefaults.Size);
INode node;
if (type >= LogicGateType.Timer)
{
node = graph.CreateNode(RectD.FromCenter(location, (SizeD)size), new ShapeNodeStyle {
Pen = new Pen(Brushes.Black, 2)
});
}
else
{
node = graph.CreateNode(newBounds, new LogicGateNodeStyle {
GateType = type
});
}
if (label != null)
{
graph.AddLabel(node, label, InteriorLabelModel.Center);
}
var portDescriptors = PortDescriptor.CreatePortDescriptors(type);
// use relative port locations
var model = new FreeNodePortLocationModel();
// add ports for all descriptors using the descriptor as the tag of the port
foreach (var descriptor in portDescriptors)
{
// use the descriptor's location as offset
var portLocationModelParameter = model.CreateParameter(PointD.Origin, new PointD(descriptor.X, descriptor.Y));
graph.AddPort(node, portLocationModelParameter, tag: descriptor);
}
}
private void CreateSampleGraph(IGraph graph)
{
graph.AddLabel(graph.CreateNode(new PointD(100, 100)), "1");
graph.AddLabel(graph.CreateNode(new PointD(200, 100)), "2");
graph.AddLabel(graph.CreateNode(new PointD(300, 100)), "3");
}
/// <summary>
/// Runs the algorithm.
/// </summary>
public override void RunAlgorithm(IGraph graph)
{
ResetGraph(graph);
double maximumNodeCentrality;
double minimumNodeCentrality;
ResultItemMapping <INode, double> normalizedNodeCentrality;
switch (algorithmType)
{
case CentralityMode.Weight: {
var result = new WeightCentrality {
Weights = { Delegate = GetEdgeWeight }, ConsiderOutgoingEdges = true, ConsiderIncomingEdges = true
}.Run(graph);
maximumNodeCentrality = result.MaximumNodeCentrality;
minimumNodeCentrality = result.MinimumNodeCentrality;
normalizedNodeCentrality = result.NormalizedNodeCentrality;
break;
}
case CentralityMode.Graph: {
var result = new GraphCentrality {
Weights = { Delegate = GetEdgeWeight }, Directed = Directed
}.Run(graph);
maximumNodeCentrality = result.MaximumNodeCentrality;
minimumNodeCentrality = result.MinimumNodeCentrality;
normalizedNodeCentrality = result.NormalizedNodeCentrality;
break;
}
case CentralityMode.NodeEdgeBetweenness: {
var result = new BetweennessCentrality {
Directed = Directed, Weights = { Delegate = GetEdgeWeight }
}.Run(graph);
maximumNodeCentrality = result.MaximumNodeCentrality;
minimumNodeCentrality = result.MinimumNodeCentrality;
normalizedNodeCentrality = result.NormalizedNodeCentrality;
result.NormalizedEdgeCentrality.ForEach((edge, centralityId) => {
edge.Tag = Math.Round(centralityId * 100.0) / 100;
graph.AddLabel(edge, edge.Tag.ToString(), tag: "Centrality");
});
break;
}
case CentralityMode.Closeness: {
var result = new ClosenessCentrality {
Directed = Directed, Weights = { Delegate = GetEdgeWeight }
}.Run(graph);
maximumNodeCentrality = result.MaximumNodeCentrality;
minimumNodeCentrality = result.MinimumNodeCentrality;
normalizedNodeCentrality = result.NormalizedNodeCentrality;
break;
}
case CentralityMode.Degree:
default: {
var result = new DegreeCentrality {
ConsiderOutgoingEdges = true, ConsiderIncomingEdges = true
}.Run(graph);
maximumNodeCentrality = result.MaximumNodeCentrality;
minimumNodeCentrality = result.MinimumNodeCentrality;
normalizedNodeCentrality = result.NormalizedNodeCentrality;
break;
}
}
var min = minimumNodeCentrality / maximumNodeCentrality;
var diff = 1 - min;
var mostCentralValue = 100;
var leastCentralValue = 30;
var colorNumber = 50;
normalizedNodeCentrality.ForEach((node, centralityId) => {
var textLabelStyle = new DefaultLabelStyle {
TextBrush = Brushes.White
};
node.Tag = Math.Round(centralityId * 100.0) / 100;
if (double.IsNaN((double)node.Tag) || double.IsNaN(diff))
{
node.Tag = "Inf";
}
graph.AddLabel(node, node.Tag.ToString(), style: textLabelStyle, tag: "Centrality");
if (diff == 0 || double.IsNaN(diff))
{
graph.SetStyle(node, GetMarkedNodeStyle(0, colorNumber));
graph.SetNodeLayout(node, new RectD(node.Layout.X, node.Layout.Y, leastCentralValue, leastCentralValue));
}
else
{
// adjust gradient color
var colorScale = (colorNumber - 1) / diff;
var index = Math.Max(0, Math.Min(colorNumber, (int)Math.Floor((centralityId - min) * colorScale)));
graph.SetStyle(node, GetMarkedNodeStyle(index, colorNumber));
// adjust size
var sizeScale = (mostCentralValue - leastCentralValue) / diff;
var size = leastCentralValue + (centralityId - min) * sizeScale;
graph.SetNodeLayout(node, new RectD(node.Layout.X, node.Layout.Y, size, size));
}
});
}
public static ILabel AddLabel(this IGraph graph, ILabelOwner owner, ILabelModelParameter parameter, string text, object tag = null)
{
return(graph.AddLabel(owner, text, parameter, null, null, tag));
}
public static ILabel AddLabel(this IGraph graph, ILabelOwner owner, ILabelModelParameter parameter, ILabelStyle style, string text, SizeD preferredSize, object tag = null)
{
return(graph.AddLabel(owner, text, parameter, style, preferredSize, tag));
}
