public static void PivotMDS(GeometryGraph graph)
{
if (graph == null)
{
return;
}
var mdsLayoutSettings = GetMdsSettings();
var mdsLayout = new MdsGraphLayout(mdsLayoutSettings, graph);
mdsLayout.Run(new CancelToken());
}
/// <summary>
/// Apply the appropriate layout to the specified cluster and its children (bottom up)
/// </summary>
/// <param name="cluster">the root of the cluster hierarchy to lay out</param>
/// <returns>list of edges external to the cluster</returns>
void LayoutCluster(Cluster cluster)
{
if (cluster.IsCollapsed)
{
return;
}
LayoutAlgorithmSettings settings = clusterSettings(cluster);
cluster.UnsetInitialLayoutState();
if (runInParallel && cluster.Clusters.Count() > 1)
{
Parallel.ForEach(cluster.Clusters, parallelOptions, LayoutCluster);
}
else
{
foreach (var cl in cluster.Clusters)
{
LayoutCluster(cl);
}
}
List <GeometryGraph> components = (List <GeometryGraph>)GetComponents(cluster);
//currentComponentFraction = (1.0 / clusterCount) / components.Count;
// if (runInParallel)
// Parallel.ForEach(components, parallelOptions, comp => LayoutComponent(settings, comp));
// else // debug!!!!!!
components.ForEach(c => LayoutComponent(settings, c));
var bounds = MdsGraphLayout.PackGraphs(components, settings);
foreach (var g in components)
{
FixOriginalGraph(g, true);
}
cluster.UpdateBoundary(bounds);
cluster.SetInitialLayoutState(settings.ClusterMargin);
cluster.RaiseLayoutDoneEvent();
// var l = new List<DebugCurve>();
// foreach (var node in cluster.Nodes) {
// l.Add(new DebugCurve(node.BoundaryCurve));
// }
// foreach (var cl in cluster.AllClustersDepthFirstExcludingSelf()) {
// l.Add(new DebugCurve(cl.BoundaryCurve));
// l.AddRange(cl.Nodes.Select(n=>new DebugCurve(n.BoundaryCurve)));
// }
// LayoutAlgorithmSettings.ShowDebugCurves(l.ToArray());
}
public static void PivotMdsFullStress(GeometryGraph graph)
{
if (graph == null)
{
return;
}
var mdsLayoutSettings = GetMdsSettings();
mdsLayoutSettings.IterationsWithMajorization = Math.Min((int)Math.Sqrt(graph.Nodes.Count), 30);
var mdsLayout = new MdsGraphLayout(mdsLayoutSettings, graph);
mdsLayout.Run(new CancelToken());
}
/// <summary>
/// Calculates the graph layout
/// </summary>
/// <exception cref="CancelException">Thrown when the layout is canceled.</exception>
#else
/// <summary>
/// Calculates the graph layout
/// </summary>
/// <exception cref="System.OperationCanceledException">Thrown when the layout is canceled.</exception>
#endif
public static void CalculateLayout(GeometryGraph geometryGraph, LayoutAlgorithmSettings settings, CancelToken cancelToken)
{
Console.WriteLine("starting CalculateLayout");
if (settings is RankingLayoutSettings)
{
var rankingLayoutSettings = settings as RankingLayoutSettings;
var rankingLayout = new RankingLayout(rankingLayoutSettings, geometryGraph);
rankingLayout.Run(cancelToken);
RouteAndLabelEdges(geometryGraph, settings, geometryGraph.Edges);
}
else if (settings is MdsLayoutSettings)
{
var mdsLayoutSettings = settings as MdsLayoutSettings;
var mdsLayout = new MdsGraphLayout(mdsLayoutSettings, geometryGraph);
mdsLayout.Run(cancelToken);
if (settings.EdgeRoutingSettings.EdgeRoutingMode != EdgeRoutingMode.None)
{
RouteAndLabelEdges(geometryGraph, settings, geometryGraph.Edges);
}
}
else if (settings is FastIncrementalLayoutSettings)
{
var incrementalSettings = settings as FastIncrementalLayoutSettings;
incrementalSettings.AvoidOverlaps = true;
var initialLayout = new InitialLayout(geometryGraph, incrementalSettings);
initialLayout.Run(cancelToken);
if (settings.EdgeRoutingSettings.EdgeRoutingMode != EdgeRoutingMode.None)
{
RouteAndLabelEdges(geometryGraph, settings, geometryGraph.Edges);
}
//incrementalSettings.IncrementalRun(geometryGraph);
}
else
{
var sugiyamaLayoutSettings = settings as SugiyamaLayoutSettings;
if (sugiyamaLayoutSettings != null)
{
ProcessSugiamaLayout(geometryGraph, sugiyamaLayoutSettings, cancelToken);
}
else
{
Debug.Assert(settings is LgLayoutSettings);
LayoutLargeGraphWithLayers(geometryGraph, settings, cancelToken);
}
}
}
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);
}
}
