public static GeometryGraph CopyGraph(GeometryGraph graph)
{
if (graph == null)
{
return(null);
}
var copy = new GeometryGraph();
Dictionary <Node, Node> nodeCopy = new Dictionary <Node, Node>(graph.Nodes.Count);
foreach (Node node in graph.Nodes)
{
var c = new Node();
copy.Nodes.Add(c);
nodeCopy[node] = c;
c.BoundaryCurve = node.BoundaryCurve.Clone();
}
foreach (Edge edge in graph.Edges)
{
var source = edge.Source;
var target = edge.Target;
var copySource = nodeCopy[source];
var copyTarget = nodeCopy[target];
Edge edgeCopy = new Edge(copySource, copyTarget);
copy.Edges.Add(edgeCopy);
StraightLineEdges.RouteEdge(edgeCopy, 0);
}
return(copy);
}
private void RouteGraphEdges(Graph graph)
{
foreach (Edge edge in graph.GeometryGraph.Edges)
{
StraightLineEdges.RouteEdge(edge, 0);
}
}
private void ShapeStyle_cmb_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (_iset_ShapeStyle)
{
_iset_ShapeStyle = false;
return;
}
var objs = _graphViewer.LayoutEditor.dragGroup;
if ((objs.First() as VNode) == null)
{
return;
}
foreach (var obj in objs)
{
VNode vnode = obj as VNode;
var sh = (Shape)shapeStyle_cmb.SelectedValue;
if (vnode.Node.Attr.Shape == sh)
{
continue;
}
var node = vnode.Node;
node.Attr.Shape = sh;
var sz = Common.MeasureLabel(node.Label);
var pos = node.GeometryNode.Center;
node.GeometryNode.BoundaryCurve = NodeBoundaryCurves.GetNodeBoundaryCurve(vnode.Node, sz.Width, sz.Height);
node.GeometryNode.Center = pos;
foreach (var dEdge in node.Edges)
{
StraightLineEdges.CreateSimpleEdgeCurveWithUnderlyingPolyline(dEdge.GeometryEdge);
(_graphViewer.GetIViewerObject(dEdge) as VEdge).Invalidate();
}
vnode.Invalidate();
}
}
/// <summary>
/// </summary>
/// <param name="geometryGraph"></param>
/// <param name="layoutSettings"></param>
/// <param name="edgesToRoute"></param>
public static void RouteAndLabelEdges(GeometryGraph geometryGraph, LayoutAlgorithmSettings layoutSettings, IEnumerable <Edge> edgesToRoute, int straighLineRoutingThreshold, CancelToken cancelToken)
{
//todo: what about parent edges!!!!
var filteredEdgesToRoute =
edgesToRoute.Where(e => !e.UnderCollapsedCluster()).ToArray();
var ers = layoutSettings.EdgeRoutingSettings;
var mode = (straighLineRoutingThreshold == 0 || geometryGraph.Nodes.Count < straighLineRoutingThreshold) ? ers.EdgeRoutingMode : EdgeRoutingMode.StraightLine;
if (mode == EdgeRoutingMode.Rectilinear ||
mode == EdgeRoutingMode.RectilinearToCenter)
{
RectilinearInteractiveEditor.CreatePortsAndRouteEdges(
layoutSettings.NodeSeparation / 3,
layoutSettings.NodeSeparation / 3,
geometryGraph.Nodes,
edgesToRoute,
mode,
true,
ers.UseObstacleRectangles,
ers.BendPenalty, cancelToken);
}
else if (mode == EdgeRoutingMode.Spline || mode == EdgeRoutingMode.SugiyamaSplines)
{
new SplineRouter(geometryGraph, filteredEdgesToRoute, ers.Padding, ers.PolylinePadding, ers.ConeAngle, null)
{
ContinueOnOverlaps = true,
KeepOriginalSpline = ers.KeepOriginalSpline
}.Run(cancelToken);
}
else if (mode == EdgeRoutingMode.SplineBundling)
{
var edgeBundlingSettings = ers.BundlingSettings ?? new BundlingSettings();
var bundleRouter = new SplineRouter(geometryGraph, filteredEdgesToRoute, ers.Padding, ers.PolylinePadding, ers.ConeAngle,
edgeBundlingSettings)
{
KeepOriginalSpline = ers.KeepOriginalSpline
};
bundleRouter.Run(cancelToken);
if (bundleRouter.OverlapsDetected)
{
new SplineRouter(geometryGraph, filteredEdgesToRoute, ers.Padding, ers.PolylinePadding, ers.ConeAngle, null)
{
ContinueOnOverlaps = true,
KeepOriginalSpline = ers.KeepOriginalSpline
}.Run(cancelToken);
}
}
else if (mode == EdgeRoutingMode.StraightLine)
{
var router = new StraightLineEdges(filteredEdgesToRoute, ers.Padding);
router.Run();
}
var elb = new EdgeLabelPlacement(geometryGraph.Nodes, filteredEdgesToRoute);
elb.Run();
geometryGraph.UpdateBoundingBox();
}
void RouteStraightLines()
{
var geomGraph = gViewer.Graph.GeometryGraph;
foreach (var e in geomGraph.Edges)
{
StraightLineEdges.CreateSimpleEdgeCurveWithUnderlyingPolyline(e);
}
}
Graph Run()
{
xmlReader.MoveToContent();
while (IsStartElement())
{
switch (Name)
{
case "edges":
ReadEdges();
break;
case "nodes":
ReadNodes();
break;
case "gexf":
Read();
break;
case "graph":
Read();
break;
default:
xmlReader.Skip();
break;
}
}
if (!GeometryPresent(graph.Nodes))
{
return(graph);
}
graph.CreateGeometryGraph();
foreach (var n in graph.Nodes)
{
var geomNode = n.GeometryNode;
GexfNodeAttr nodeData;
if (idsToGexfNodeAttr.TryGetValue(n.Id, out nodeData))
{
n.Label.FontSize *= nodeData.Size;
geomNode.BoundaryCurve = CurveFactory.CreateCircle(nodeData.Size, nodeData.Position);
}
}
foreach (var e in graph.Edges)
{
if (e.GeometryEdge.Source.BoundaryCurve != null && e.GeometryEdge.Target.BoundaryCurve != null)
{
StraightLineEdges.RouteEdge(e.GeometryEdge, e.Source == e.Target?graph.LayoutAlgorithmSettings.NodeSeparation / 4: 0);
}
}
return(graph);
}
static void RouteClusterParentInEdges(List<Edge> inParentEdges, EdgeRoutingSettings edgeRoutingSettings, Cluster cluster,
double padding) {
foreach (var e in cluster.InEdges.Where(e => IsDescendant(e.Source, cluster))) {
double ePadding = Math.Max(padding, 1.5 * ArrowlengthAtTarget(e));
var hookPort = e.TargetPort as HookUpAnywhereFromInsidePort;
if (hookPort == null)
e.TargetPort = hookPort = new HookUpAnywhereFromInsidePort(() => cluster.BoundaryCurve);
hookPort.HookSize = ePadding;
e.Curve = StraightLineEdges.CreateLoop(e.Source.BoundingBox, cluster.BoundingBox, ePadding, false);
Arrowheads.TrimSplineAndCalculateArrowheads(e, e.Curve, false,
edgeRoutingSettings.KeepOriginalSpline);
inParentEdges.Add(e);
}
}
static void RouteEdges(GeometryGraph graph, FastIncrementalLayoutSettings settings)
{
if (graph.Edges.Count < 1000)
{
var router = new SplineRouter(graph, settings.EdgeRoutingSettings.Padding,
settings.EdgeRoutingSettings.PolylinePadding,
settings.EdgeRoutingSettings.ConeAngle,
settings.EdgeRoutingSettings.BundlingSettings);
router.Run();
}
else
{
var sr = new StraightLineEdges(graph.Edges, 1);
sr.Run();
}
}
internal static void RouteEdges(GeometryGraph component, LayoutAlgorithmSettings settings, CancelToken cancelToken)
{
EdgeRoutingMode mode = settings.EdgeRoutingSettings.EdgeRoutingMode;
// Use straight line routing on very large graphs otherwise it is too slow
if (component.Nodes.Count >= 2000)
{
mode = EdgeRoutingMode.StraightLine;
}
switch (mode)
{
case EdgeRoutingMode.Spline:
var splineRouter = new SplineRouter(
component,
settings.EdgeRoutingSettings.Padding,
settings.NodeSeparation, settings.EdgeRoutingSettings.ConeAngle, null);
splineRouter.Run(cancelToken);
break;
case EdgeRoutingMode.SplineBundling:
splineRouter = new SplineRouter(
component,
settings.EdgeRoutingSettings.Padding,
settings.NodeSeparation / 20, settings.EdgeRoutingSettings.ConeAngle,
new BundlingSettings());
splineRouter.Run(cancelToken);
break;
case EdgeRoutingMode.Rectilinear:
double edgePadding = settings.EdgeRoutingSettings.Padding;
double cornerRadius = settings.EdgeRoutingSettings.CornerRadius;
var rectilinearEdgeRouter = new RectilinearEdgeRouter(component, edgePadding, cornerRadius,
true);
rectilinearEdgeRouter.Run(cancelToken);
break;
case EdgeRoutingMode.StraightLine:
var router = new StraightLineEdges(component.Edges,
settings.EdgeRoutingSettings.Padding);
router.Run(cancelToken);
break;
}
}
private void RefreshAndCleanGraph(Graph graph)
{
// List<Microsoft.Msagl.Drawing.Edge> selfEdges=new List<Microsoft.Msagl.Drawing.Edge>();
// foreach (Microsoft.Msagl.Drawing.Node node in graph.Nodes) {
// selfEdges.AddRange(node.SelfEdges);
// }
//
// selfEdges.ForEach((edge) => graph.RemoveEdge(edge));
// if (graph.Edges.Count() > 3000) {
// //delete all edges
// graph.GeometryGraph.Edges.Clear();
//// var edgeList=graph.GeometryGraph.Edges.Reverse().ToList();
//// edgeList.ForEach((edge)=>graph.GeometryGraph.Edges.Remove(edge));
// }
// else {
// }
foreach (Microsoft.Msagl.Drawing.Node node in graph.Nodes)
{
var c = node.Attr.Color;
node.Attr.FillColor = new Color(170, c.R, c.G, c.B);
}
foreach (Microsoft.Msagl.Drawing.Edge edge in graph.Edges)
{
edge.Attr.Color = new Color(220, 115, 115, 115);
}
foreach (Edge edge in graph.GeometryGraph.Edges)
{
StraightLineEdges.RouteEdge(edge, 0);
}
}
static void DragEdgeAsStraightLine(Point delta, GeomEdge edge)
{
StraightLineEdges.CreateSimpleEdgeCurveWithUnderlyingPolyline(edge);
}
/// <summary>
/// Executes the algorithm.
/// </summary>
protected override void RunInternal() {
SetNodePositionsAndMovedBoundaries();
StraightLineEdges.SetStraightLineEdgesWithUnderlyingPolylines(graph);
SetGraphBoundingBox();
}
