public frmGraphView()
{
//---------------------------------------------------------------------------------------
//Remove Debug Asserts from Graph Tool - may have adverse side effects elsewhere though!!
Debug.Listeners.Clear();
//---------------------------------------------------------------------------------------
mdsLayoutSettings = new MdsLayoutSettings();
sugiyamaSettings = new SugiyamaLayoutSettings();
InitializeComponent();
SuspendLayout();
viewer.Dock = DockStyle.Fill;
//Mouse Double Click Handler
viewer.MouseDoubleClick += Viewer_MouseDoubleClick;
//Mouse over / Object select Handler
viewer.ObjectUnderMouseCursorChanged += Viewer_ObjectUnderMouseCursorChanged;
//Key Press handler
viewer.KeyPress += Viewer_KeyPress;
viewer.KeyDown += Viewer_KeyDown;
viewer.KeyUp += Viewer_KeyUp;
//Add viewer
Controls.Add(viewer);
//Make it dock under the top panel
viewer.BringToFront();
viewer.OutsideAreaBrush = new SolidBrush(Color.White);
ResumeLayout();
}
MdsLayoutSettings GetMdsLayoutSettings()
{
var settings = new MdsLayoutSettings();
settings.ScaleX *= 3;
settings.ScaleY *= 3;
settings.EdgeRoutingSettings.KeepOriginalSpline = true;
settings.EdgeRoutingSettings.EdgeRoutingMode = EdgeRoutingMode.Spline;
settings.IterationsWithMajorization = _argsParser.OptionIsUsed(NoIterationsWithMajorization) ? 0 : 30;
if (_argsParser.OptionIsUsed(AllowOverlapsInMds))
{
settings.RemoveOverlaps = false;
}
if (_argsParser.OptionIsUsed(SequentialRunOption))
{
settings.RunInParallel = false;
}
if (_argsParser.OptionIsUsed(StraightLineEdgesOption))
{
settings.EdgeRoutingSettings.EdgeRoutingMode = EdgeRoutingMode.StraightLine;
}
if (_argsParser.OptionIsUsed(NoEdgeRoutingOption))
{
settings.EdgeRoutingSettings.EdgeRoutingMode = EdgeRoutingMode.None;
}
//settings.AdjustScale = true;
return(settings);
}
public void Clusterabc()
{
#if TEST_MSAGL
DisplayGeometryGraph.SetShowFunctions();
#endif
var geometryGraph = new GeometryGraph();
geometryGraph.RootCluster = new Cluster();
var a = new Node();
a.BoundaryCurve = CurveFactory.CreateCircle(20, new Point());
var b = new Node();
b.BoundaryCurve = CurveFactory.CreateCircle(20, new Point());
var c = new Node();
c.BoundaryCurve = CurveFactory.CreateCircle(20, new Point());
geometryGraph.RootCluster.AddNode(a);
geometryGraph.RootCluster.AddNode(b);
geometryGraph.RootCluster.AddNode(c);
b.AddInEdge(new Edge(a, b));
c.AddInEdge(new Edge(a, c));
var mdsLayoutSettings = new MdsLayoutSettings {
RemoveOverlaps = true, NodeSeparation = 10
};
var mdsLayout = new MdsGraphLayout(mdsLayoutSettings, geometryGraph);
mdsLayout.Run();
var splineRouter = new SplineRouter(geometryGraph, geometryGraph.Edges, 2,
3,
Math.PI / 6, null);
splineRouter.Run();
#if TEST_MSAGL
DisplayGeometryGraph.ShowGraph(geometryGraph);
#endif
}
private static MdsLayoutSettings GetMdsSettings()
{
MdsLayoutSettings mSettings = new MdsLayoutSettings();
mSettings.IterationsWithMajorization = 0;
mSettings.RemoveOverlaps = false;
return(mSettings);
}
void MDSLayout(MdsLayoutSettings settings, GeometryGraph component) {
LayoutAlgorithmHelpers.ComputeDesiredEdgeLengths(settings.EdgeConstraints, component);
var layout = new MdsGraphLayout(settings, component);
layout.Run(this.CancelToken);
InitialLayoutHelpers.RouteEdges(component, settings, this.CancelToken);
InitialLayoutHelpers.PlaceLabels(component, this.CancelToken);
InitialLayoutHelpers.FixBoundingBox(component, settings);
}
MdsLayoutSettings GetMdsLayoutSettings()
{
var settings = new MdsLayoutSettings {
EdgeRoutingSettings = { KeepOriginalSpline = true, EdgeRoutingMode = EdgeRoutingMode.None }
};
settings.ScaleX *= 3;
settings.ScaleY *= 3;
return(settings);
}
/// <summary>
/// Default constructor
/// </summary>
public GViewer()
{
mdsLayoutSettings = new MdsLayoutSettings()
{
RunInParallel = this.AsyncLayout
};
sugiyamaSettings = new SugiyamaLayoutSettings();
// This call is required by the Windows.Forms Form Designer.
InitializeComponent();
BackwardEnabled = false;
ForwardEnabled = false;
toolbar.MouseMove += ToolBarMouseMoved;
Assembly a = Assembly.GetExecutingAssembly();
foreach (string r in a.GetManifestResourceNames())
{
if (r.Contains("hmove.cur"))
{
panGrabCursor = new Cursor(a.GetManifestResourceStream(r));
}
else if (r.Contains("oph.cur"))
{
panOpenCursor = new Cursor(a.GetManifestResourceStream(r));
}
}
originalCursor = Cursor;
panButton.Checked = false;
windowZoomButton.Checked = false;
layoutSettingsButton.ToolTipText = "Configures the layout algorithm settings";
undoButton.ToolTipText = "Undo layout editing";
redoButton.ToolTipText = "Redo layout editing";
forwardButton.ToolTipText = "Forward";
panButton.ToolTipText = panButton.Checked ? panButtonToolTipText : PanButtonDisabledToolTipText;
windowZoomButton.ToolTipText = windowZoomButton.Checked
? WindowZoomButtonToolTipText
: windowZoomButtonDisabledToolTipText;
InitDrawingLayoutEditor();
toolbar.Invalidate();
SuspendLayout();
InitPanel();
Controls.Add(toolbar);
ResumeLayout();
}
public void TreeGraphMdsLayout()
{
GeometryGraph treeGraph = GraphGenerator.GenerateTree(20);
treeGraph.RootCluster = new Cluster(treeGraph.Nodes);
var settings = new MdsLayoutSettings {
ScaleX = 1, ScaleY = 1, RemoveOverlaps = true, PackingAspectRatio = 1.4
};
settings.EdgeRoutingSettings = new EdgeRoutingSettings {
EdgeRoutingMode = EdgeRoutingMode.Spline, ConeAngle = Math.PI / 6, Padding = settings.NodeSeparation / 2.1
};
foreach (var v in treeGraph.Nodes)
{
v.BoundingBox = new Rectangle(0, 0, new Point(30, 30));
}
var layout = new InitialLayoutByCluster(treeGraph, settings);
double progress = 0.0;
EventHandler <ProgressChangedEventArgs> handler = (s, e) => progress = e.RatioComplete;
try
{
layout.ProgressChanged += handler;
layout.Run();
}
finally
{
layout.ProgressChanged -= handler;
}
EnableDebugViewer();
ShowGraphInDebugViewer(treeGraph);
const double EdgeLengthDelta = 0.5;
foreach (var e in treeGraph.Edges)
{
Assert.IsNotNull(e.Curve, "Edge curves not populated");
if (e.Source != e.Target)
{
double actualLength = (e.Source.Center - e.Target.Center).Length;
double actualDesiredRatio = e.Length / actualLength;
Assert.AreEqual(1, actualDesiredRatio, EdgeLengthDelta, "Edge length is not correct");
}
}
double aspectRatio = treeGraph.BoundingBox.Width / treeGraph.BoundingBox.Height;
Assert.AreEqual(settings.PackingAspectRatio, aspectRatio, 1.4, "Aspect ratio too far from desired");
Assert.AreEqual(1.0, progress, "Progress was never reported as 100%. Last update was at " + progress + "%");
}
static LayoutAlgorithmSettings PickLayoutAlgorithmSettings(int edges, int nodes)
{
LayoutAlgorithmSettings settings;
const int sugiaymaTreshold = 200;
const double bundlingTreshold = 3.0;
bool bundling = nodes != 0 && ((double)edges / nodes >= bundlingTreshold || edges > 100);
if (nodes < sugiaymaTreshold && edges < sugiaymaTreshold)
{
settings = new SugiyamaLayoutSettings();
if (bundling)
{
settings.EdgeRoutingSettings.EdgeRoutingMode = EdgeRoutingMode.SplineBundling;
}
}
else
{
MdsLayoutSettings mdsSettings;
settings = mdsSettings = new MdsLayoutSettings {
EdgeRoutingSettings =
{
EdgeRoutingMode
=
bundling
? EdgeRoutingMode.SplineBundling
: EdgeRoutingMode.Spline
}
};
if (bundling)
{
settings.EdgeRoutingSettings.BundlingSettings = new BundlingSettings();
}
double scale = FigureOutScaleForMdsLayout(nodes);
mdsSettings.ScaleX = scale;
mdsSettings.ScaleY = scale;
}
return(settings);
}
static void Main(string[] args)
{
#if TEST_MSAGL
DisplayGeometryGraph.SetShowFunctions();
#endif
ArgsParser.ArgsParser argsParser = SetArgsParser(args);
if (argsParser.OptionIsUsed("-help"))
{
Console.WriteLine(argsParser.UsageString());
Environment.Exit(0);
}
if (argsParser.OptionIsUsed(PolygonDistanceTestOption))
{
TestPolygonDistance();
}
else if (argsParser.OptionIsUsed(TestCdtThreaderOption))
{
TestCdtThreader();
}
else if (argsParser.OptionIsUsed(RandomBundlingTest))
{
RandomBundlingTests.RsmContent();
}
bundling = argsParser.OptionIsUsed(BundlingOption);
var gviewer = new GViewer();
gviewer.MouseMove += Draw.GviewerMouseMove;
if (argsParser.OptionIsUsed(FdOption))
{
TestFD();
gviewer.CurrentLayoutMethod = LayoutMethod.IcrementalLayout;
}
Form form = CreateForm(null, gviewer);
if (argsParser.OptionIsUsed(AsyncLayoutOption))
{
gviewer.AsyncLayout = true;
}
string listOfFilesFile = argsParser.GetStringOptionValue(ListOfFilesOption);
if (listOfFilesFile != null)
{
ProcessListOfFiles(listOfFilesFile, argsParser);
return;
}
string fileName = argsParser.GetStringOptionValue(FileOption);
string ext = Path.GetExtension(fileName);
if (ext != null)
{
ext = ext.ToLower();
if (ext == ".dot")
{
ProcessDotFile(gviewer, argsParser, fileName);
}
else
{
if (ext == ".geom")
{
GeometryGraph geometryGraph = GeometryGraphReader.CreateFromFile(fileName);
geometryGraph.Margins = 10;
FixHookPorts(geometryGraph);
// if (argsParser.OptionIsUsed(BundlingOption)) {
for (int i = 0; i < 1; i++)
{
#if TEST_MSAGL
/*DisplayGeometryGraph.ShowGraph(geometryGraph);
* var l = new List<DebugCurve>(); l.AddRange(geometryGraph.Nodes.Select(n=>new DebugCurve(100,1,"black",n.BoundaryCurve)));
* l.AddRange(geometryGraph.Edges.Select(e=>new DebugCurve(100,1,"black", new LineSegment(e.Source.Center,e.Target.Center))));
* foreach (var cl in geometryGraph.RootCluster.AllClustersDepthFirst()) {
* l.Add(new DebugCurve(100,2,"blue",cl.BoundaryCurve));
* foreach (var node in cl.Nodes)
* l.Add(new DebugCurve(100, 2, "brown", node.BoundaryCurve));
*
* foreach (var e in cl.Edges)
* l.Add(new DebugCurve(100, 2, "pink", new LineSegment(e.Source.Center, e.Target.Center)));
*
* }
*
* DisplayGeometryGraph.ShowDebugCurves(l.ToArray());*/
#endif
BundlingSettings bs = GetBundlingSettings(argsParser);
double loosePadding;
double tightPadding = GetPaddings(argsParser, out loosePadding);
if (argsParser.OptionIsUsed(MdsOption))
{
var mdsLayoutSettings = new MdsLayoutSettings {
RemoveOverlaps = true, NodeSeparation = loosePadding * 3
};
var mdsLayout = new MdsGraphLayout(mdsLayoutSettings, geometryGraph);
mdsLayout.Run();
}
else
{
if (argsParser.OptionIsUsed(FdOption))
{
var settings = new FastIncrementalLayoutSettings {
AvoidOverlaps = true
};
(new InitialLayout(geometryGraph, settings)).Run();
}
}
var splineRouter = new SplineRouter(geometryGraph, geometryGraph.Edges, tightPadding,
loosePadding,
Math.PI / 6, bs);
splineRouter.Run();
}
#if TEST_MSAGL
DisplayGeometryGraph.ShowGraph(geometryGraph);
#endif
return;
}
else
{
if (ext == ".msagl")
{
Graph graph = Graph.Read(fileName);
// DisplayGeometryGraph.ShowGraph(graph.GeometryGraph);
if (graph != null)
{
if (argsParser.OptionIsUsed(BundlingOption))
{
BundlingSettings bs = GetBundlingSettings(argsParser);
double loosePadding;
double tightPadding = GetPaddings(argsParser, out loosePadding);
var br = new SplineRouter(graph.GeometryGraph, tightPadding, loosePadding, Math.PI / 6,
bs);
br.Run();
// DisplayGeometryGraph.ShowGraph(graph.GeometryGraph);
}
}
gviewer.NeedToCalculateLayout = false;
gviewer.Graph = graph;
gviewer.NeedToCalculateLayout = true;
}
}
}
}
else if (argsParser.OptionIsUsed(TestCdtOption))
{
Triangulation(argsParser.OptionIsUsed(ReverseXOption));
Environment.Exit(0);
}
else if (argsParser.OptionIsUsed(TestCdtOption0))
{
TestTriangulationOnSmallGraph(argsParser);
Environment.Exit(0);
}
else if (argsParser.OptionIsUsed(TestCdtOption2))
{
TestTriangulationOnPolys();
Environment.Exit(0);
}
else if (argsParser.OptionIsUsed(TestCdtOption1))
{
ThreadThroughCdt();
Environment.Exit(0);
}
else if (argsParser.OptionIsUsed(ConstraintsTestOption))
{
TestGraphWithConstraints();
}
if (!argsParser.OptionIsUsed(QuietOption))
{
Application.Run(form);
}
}
protected override void OnValueChanged(ModelRoot element, LayoutAlgorithm oldValue, LayoutAlgorithm newValue)
{
base.OnValueChanged(element, oldValue, newValue);
if (!element.Store.InUndoRedoOrRollback)
{
// if this is the first time we've been here, cache what's alread there
if (oldValue != LayoutAlgorithm.Default && !settingsCache.ContainsKey(oldValue) && element.LayoutAlgorithmSettings != null)
{
settingsCache[oldValue] = element.LayoutAlgorithmSettings;
}
// use the prior settings for this layout type if available
if (newValue != LayoutAlgorithm.Default && settingsCache.ContainsKey(newValue))
{
element.LayoutAlgorithmSettings = settingsCache[newValue];
}
else
{
// if not, set some defaults that make sense in our context
switch (newValue)
{
case LayoutAlgorithm.Default:
element.LayoutAlgorithmSettings = null;
return;
case LayoutAlgorithm.FastIncremental:
FastIncrementalLayoutSettings fastIncrementalLayoutSettings = new FastIncrementalLayoutSettings();
element.LayoutAlgorithmSettings = fastIncrementalLayoutSettings;
break;
case LayoutAlgorithm.MDS:
MdsLayoutSettings mdsLayoutSettings = new MdsLayoutSettings();
mdsLayoutSettings.ScaleX = 1;
mdsLayoutSettings.ScaleY = 1;
mdsLayoutSettings.AdjustScale = true;
mdsLayoutSettings.RemoveOverlaps = true;
element.LayoutAlgorithmSettings = mdsLayoutSettings;
break;
case LayoutAlgorithm.Ranking:
RankingLayoutSettings rankingLayoutSettings = new RankingLayoutSettings();
rankingLayoutSettings.ScaleX = 1;
rankingLayoutSettings.ScaleY = 1;
element.LayoutAlgorithmSettings = rankingLayoutSettings;
break;
case LayoutAlgorithm.Sugiyama:
SugiyamaLayoutSettings sugiyamaLayoutSettings = new SugiyamaLayoutSettings
{
LayerSeparation = 1,
MinNodeHeight = 1,
MinNodeWidth = 1
};
element.LayoutAlgorithmSettings = sugiyamaLayoutSettings;
break;
}
element.LayoutAlgorithmSettings.ClusterMargin = 1;
element.LayoutAlgorithmSettings.NodeSeparation = 1;
element.LayoutAlgorithmSettings.EdgeRoutingSettings.Padding = .3;
element.LayoutAlgorithmSettings.EdgeRoutingSettings.PolylinePadding = 1.5;
element.LayoutAlgorithmSettings.EdgeRoutingSettings.EdgeRoutingMode = EdgeRoutingMode.StraightLine;
settingsCache[newValue] = element.LayoutAlgorithmSettings;
}
}
}
public static void MDS()
{
WriteMessage("Starting test...");
WriteMessage("Create GeometryGraph");
GeometryGraph graph = AbcdeGraph();
//graph.Save("c:\\tmp\\saved.msagl");
var settings = new MdsLayoutSettings();
settings.RunInParallel = false;
settings.EdgeRoutingSettings.EdgeRoutingMode = EdgeRoutingMode.Rectilinear;
LayoutHelpers.CalculateLayout(graph, settings, null);
WriteMessage("Layout progressed");
WriteMessage("");
WriteMessage("Segments A->B");
//OutputCurve(ab.Curve);
WriteMessage("");
WriteMessage("Segments B->C");
//OutputCurve(bc.Curve);
WriteMessage("");
WriteMessage("Segments C->A");
//OutputCurve(ca.Curve);
foreach (var node in graph.Nodes)
{
WriteMessage(string.Format("{0}: {1} {2}", node.UserData, node.Center.X, node.Center.Y));
}
var canvas = HtmlContext.document.getElementById("drawing").As <HtmlCanvasElement>();
var ctx = canvas.getContext("2d").As <CanvasRenderingContext2D>();
var canvasHeight = canvas.height;
var bounds = calcBounds(graph.Nodes);
var xScale = canvas.width / bounds.Width;
var yScale = canvas.height / bounds.Height;
var xShift = -bounds.Left * xScale;
var yShift = -(canvas.height - bounds.Top) * yScale;
WriteMessage(string.Format("Scaling : {0} {1}", xScale, yScale));
WriteMessage(string.Format("Shifting : {0} {1}", xShift, yShift));
foreach (var msaglEdge in graph.Edges)
{
DrawEdge(ctx, msaglEdge, xShift, yShift, xScale, yScale, canvasHeight);
}
foreach (var msaglNode in graph.Nodes)
{
DrawNode(ctx, msaglNode, xShift, yShift, xScale, yScale, canvasHeight);
}
* /
}
