static bool AllowedToRoute(List <Edge> inParentEdges, List <Edge> outParentEdges,
EdgeRoutingSettings edgeRoutingSettings)
{
return(ShapeCreatorForRoutingToParents.NumberOfActiveNodesIsUnderThreshold(inParentEdges, outParentEdges,
edgeRoutingSettings.
SimpleSelfLoopsForParentEdgesThreshold));
}
static void EdgeSeparationTrackBarValueChanged(object sender, EventArgs e)
{
var edgeSeparationTruckBar = (TrackBar)sender;
GViewer gviewer = GetGviewer(edgeSeparationTruckBar);
Graph drawingGraph = gviewer.Graph;
if (drawingGraph == null)
{
return;
}
EdgeRoutingSettings edgeRoutingSettings = drawingGraph.LayoutAlgorithmSettings.EdgeRoutingSettings;
edgeRoutingSettings.EdgeRoutingMode = EdgeRoutingMode.SplineBundling;
if (edgeRoutingSettings.BundlingSettings == null)
{
edgeRoutingSettings.BundlingSettings = new BundlingSettings();
}
edgeRoutingSettings.BundlingSettings.EdgeSeparation = GetEdgeSeparation(edgeSeparationTruckBar);
var br = new SplineRouter(drawingGraph.GeometryGraph, 1, 1, Math.PI / 6, edgeRoutingSettings.BundlingSettings);
br.Run();
IViewer iv = gviewer;
foreach (IViewerObject edge in iv.Entities)
{
if (edge is IViewerEdge)
{
iv.Invalidate(edge);
}
}
}
static void RouteSimplHooksAndFillTheLists(Cluster rootCluster, List<Edge> inParentEdges,
List<Edge> outParentEdges, EdgeRoutingSettings edgeRoutingSettings) {
var padding = edgeRoutingSettings.Padding + edgeRoutingSettings.PolylinePadding;
foreach (var cluster in rootCluster.AllClustersWidthFirstExcludingSelfAvoidingChildrenOfCollapsed().Where(c => !c.IsCollapsed)) {
RouteClusterParentInEdges(inParentEdges, edgeRoutingSettings, cluster, padding);
RouteClusterParentOutEdges(outParentEdges, edgeRoutingSettings, cluster, padding);
}
}
internal static void RouteParentEdges(GeometryGraph graph, EdgeRoutingSettings edgeRoutingSettings) {
var inParentEdges = new List<Edge>();
var outParentEdges = new List<Edge>();
RouteSimplHooksAndFillTheLists(graph.RootCluster, inParentEdges, outParentEdges, edgeRoutingSettings);
if (inParentEdges.Count > 0 || outParentEdges.Count > 0)
LabelParentEdgesAndMaybeRerouteThemNicely(graph, inParentEdges, outParentEdges, edgeRoutingSettings);
}
private void OverrideGaphRoutingSettingsToolStripMenuItemClick(object sender, EventArgs e)
{
if (overrideGraphRoutingSettingsToolStripMenuItem.Checked)
{
if (EdgeRoutingSettings == null)
{
EdgeRoutingSettings = new EdgeRoutingSettings();
}
}
}
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 LabelParentEdgesAndMaybeRerouteThemNicely(GeometryGraph graph, List<Edge> inParentEdges,
List<Edge> outParentEdges, EdgeRoutingSettings edgeRoutingSettings) {
if (AllowedToRoute(inParentEdges, outParentEdges, edgeRoutingSettings)) {
var shapeGroupRouter = new SplineRouter(graph, edgeRoutingSettings.Padding,
edgeRoutingSettings.PolylinePadding,
edgeRoutingSettings.RoutingToParentConeAngle, inParentEdges, outParentEdges);
shapeGroupRouter.Run();
}
var labeledEdges = outParentEdges.Concat(inParentEdges).Where(e => e.Labels.Any());
if (labeledEdges.Any()) {
var elb = new EdgeLabelPlacement(graph.Nodes, labeledEdges);
//consider adding more nodes here: some sibling clusters maybe
elb.Run();
}
}
private void drawGraphWithInstantiations(List <Instantiation> newNodeInsts, bool forceDialog = false)
{
var usedQuants = newNodeInsts.Select(inst => inst.Quant).Distinct().ToList();
var removedQuants = colorMap.Keys.Where(quant => !usedQuants.Contains(quant)).ToList();
foreach (var removedQuant in removedQuants)
{
colorMap.Remove(removedQuant);
}
var edgeRoutingSettings = new EdgeRoutingSettings
{
EdgeRoutingMode = EdgeRoutingMode.Spline,
BendPenalty = 50
};
var layoutSettings = new SugiyamaLayoutSettings
{
AspectRatio = 0.5f,
LayerSeparation = 20,
EdgeRoutingSettings = edgeRoutingSettings
};
//create a graph object
graph = new Graph($"Instantiations dependencies [{maxRenderDepth.Value} levels]")
{
LayoutAlgorithmSettings = layoutSettings
};
if (checkNumNodesWithDialog(ref newNodeInsts, forceDialog))
{
return;
}
// Sorting helps ensure that the most common quantifiers end up with different colors
var prioritySortedNewNodeInsts = newNodeInsts.GroupBy(inst => inst.Quant)
.OrderByDescending(group => group.Count())
.SelectMany(group => group);
foreach (var node in prioritySortedNewNodeInsts.Select(connectToVisibleNodes))
{
formatNode(node);
}
//bind the graph to the viewer
_viewer.Graph = graph;
}
void RouteGraphEdgesAsSplines()
{
var geomGraph = gViewer.Graph.GeometryGraph;
var layoutSettings = gViewer.Graph.LayoutAlgorithmSettings;
EdgeRoutingSettings routingSettings = layoutSettings.EdgeRoutingSettings;
if (routingSettings.EdgeRoutingMode == EdgeRoutingMode.StraightLine)
{
RouteStraightLines();
}
else
if (routingSettings.EdgeRoutingMode == EdgeRoutingMode.Spline)
{
var coneAngle = routingSettings.ConeAngle;
var padding = layoutSettings.NodeSeparation * gViewer.TightOffsetForRouting * 2;
this.currentCancelToken = new CancelToken();
var router = new SplineRouter(geomGraph, padding, 0.65 * padding, coneAngle, null);
router.Run(this.currentCancelToken);
}
else if (routingSettings.EdgeRoutingMode == EdgeRoutingMode.SplineBundling)
{
var coneAngle = routingSettings.ConeAngle;
var padding = layoutSettings.NodeSeparation / 3;
var loosePadding = SplineRouter.ComputeLooseSplinePadding(layoutSettings.NodeSeparation, padding);
if (layoutSettings.EdgeRoutingSettings.BundlingSettings == null)
{
layoutSettings.EdgeRoutingSettings.BundlingSettings = new BundlingSettings();
}
var br = new SplineRouter(geomGraph, padding, loosePadding, coneAngle, layoutSettings.EdgeRoutingSettings.BundlingSettings);
br.Run();
}
else
{
MessageBox.Show(String.Format("Mode {0} is not supported with this settings",
routingSettings.EdgeRoutingMode));
return;
}
new EdgeLabelPlacement(geomGraph).Run();
InvalidateEdges();
}
void RoutingSettingsToolStripMenuItemClick(object sender, EventArgs e)
{
if (EdgeRoutingSettings == null)
{
EdgeRoutingSettings = new EdgeRoutingSettings();
}
if (overrideGraphRoutingSettingsToolStripMenuItem.Checked)
{
EdgeRoutingSettings.EdgeRoutingMode = EdgeRoutingMode;
}
Form f = CreateFormForEdgeRoutingSettings();
var dr = f.ShowDialog();
if (dr == DialogResult.OK)
{
overrideGraphRoutingSettingsToolStripMenuItem.Checked = true;
EdgeRoutingMode = EdgeRoutingSettings.EdgeRoutingMode;
RouteEdges();
}
}
/// <summary>
///
/// </summary>
void WriteLayoutSettings()
{
if (Settings != null)
{
LayoutAlgorithmSettings settings = Settings;
EdgeRoutingSettings routingSettings = settings.EdgeRoutingSettings;
WriteStartElement(GeometryToken.LayoutAlgorithmSettings);
WriteAttribute(GeometryToken.EdgeRoutingMode, (int)routingSettings.EdgeRoutingMode);
var sugiyama = settings as SugiyamaLayoutSettings;
if (sugiyama != null)
{
WriteSugiyamaSettings(sugiyama);
}
else
{
var mds = settings as MdsLayoutSettings;
if (mds != null)
{
WriteAttribute(GeometryToken.LayoutAlgorithmType, GeometryToken.MdsLayoutSettings);
#if REPORTING
WriteAttribute(GeometryToken.Reporting, mds.Reporting);
#endif
WriteAttribute(GeometryToken.Exponent, mds.Exponent);
WriteAttribute(GeometryToken.IterationsWithMajorization, mds.IterationsWithMajorization);
WriteAttribute(GeometryToken.PivotNumber, mds.PivotNumber);
WriteAttribute(GeometryToken.RotationAngle, mds.RotationAngle);
WriteAttribute(GeometryToken.ScaleX, mds.ScaleX);
WriteAttribute(GeometryToken.ScaleY, mds.ScaleY);
}
}
XmlWriter.WriteEndElement();
}
}
static void LabelParentEdgesAndMaybeRerouteThemNicely(GeometryGraph graph, List <Edge> inParentEdges,
List <Edge> outParentEdges, EdgeRoutingSettings edgeRoutingSettings)
{
if (AllowedToRoute(inParentEdges, outParentEdges, edgeRoutingSettings))
{
var shapeGroupRouter = new SplineRouter(graph, edgeRoutingSettings.Padding,
edgeRoutingSettings.PolylinePadding,
edgeRoutingSettings.RoutingToParentConeAngle, inParentEdges, outParentEdges);
shapeGroupRouter.Run();
}
var labeledEdges = outParentEdges.Concat(inParentEdges).Where(e => e.Labels.Any());
if (labeledEdges.Any())
{
var elb = new EdgeLabelPlacement(graph.Nodes, labeledEdges);
//consider adding more nodes here: some sibling clusters maybe
elb.Run();
}
/*//*************debug code start
* var parentEdges = inParentEdges.Concat(outParentEdges);
* var ll = new List<DebugCurve>();
* var marked = new Microsoft.Msagl.Core.DataStructures.Set<Node>();
* foreach (var e in parentEdges) {
* marked.Insert(e.Source);
* marked.Insert(e.Target);
* ll.Add(new DebugCurve(100, 1, "blue", e.Curve));
* }
* foreach (var c in graph.RootCluster.AllClustersDepthFirst()) {
* var color = marked.Contains(c) ? "red" : "green";
* ll.Add(new DebugCurve(100, 1, color, c.BoundaryCurve));
* }
* foreach (var c in graph.Nodes) {
* var color = marked.Contains(c) ? "red" : "green";
* ll.Add(new DebugCurve(100, 1, color, c.BoundaryCurve));
* }
*
* LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(ll);
*/
//*************debug code end
}
public static void RouteBundledEdges(GeometryGraph geometryGraph, bool measureTime, EdgeRoutingSettings edgeRoutingSettings)
{
Stopwatch sw = null;
if (measureTime)
{
sw = new Stopwatch();
sw.Start();
}
BundleRouter br = new BundleRouter(geometryGraph, edgeRoutingSettings.ConeAngle,
edgeRoutingSettings.Padding, edgeRoutingSettings.PolylinePadding, edgeRoutingSettings.BundlingSettings);
br.Run();
if (sw != null)
{
sw.Stop();
Console.WriteLine("bundling takes " + sw.Elapsed);
}
}
