/// <summary>
/// Create a RectilinearEdgeRouter from the passed obstacleNodes, with one port at the center of each obstacle,
/// and route between the obstacles, with default bend penalty.
/// </summary>
/// <param name="cornerFitRadius">The radius of the arc inscribed into path corners</param>
/// <param name="padding">The minimum padding from an obstacle's curve to its enclosing polyline</param>
/// <param name="obstacleNodes">The nodes of the graph</param>
/// <param name="geometryEdges">Edges defining the nodes to route between, and receiving the resultant paths</param>
/// <param name="edgeRoutingMode">Mode of the edges (Rectilinear or RectilinearToCenter).</param>
/// <param name="useSparseVisibilityGraph">Use a more memory-efficient but possibly path-suboptimal visibility graph</param>
static public void CreatePortsAndRouteEdges(double cornerFitRadius, double padding
, IEnumerable <Node> obstacleNodes, IEnumerable <Edge> geometryEdges
, EdgeRoutingMode edgeRoutingMode, bool useSparseVisibilityGraph)
{
CreatePortsAndRouteEdges(cornerFitRadius, padding, obstacleNodes, geometryEdges, edgeRoutingMode
, useSparseVisibilityGraph, false, SsstRectilinearPath.DefaultBendPenaltyAsAPercentageOfDistance);
}
private void SettingsUI()
{
BeginWindows();
windowPosition = GUI.Window(windowId, windowPosition, id =>
{
if (id != windowId)
{
return;
}
scrollPos = GUILayout.BeginScrollView(scrollPos, GUILayout.Width(windowPosition.width - 8));
GUIContent guiContent = new GUIContent(mode.ToString());
GUILayout.BeginHorizontal();
if (EditorGUILayout.DropdownButton(guiContent, FocusType.Passive))
{
Rect r = GUILayoutUtility.GetLastRect();
GenericMenu menu = new GenericMenu();
foreach (EdgeRoutingMode value in Enum.GetValues(typeof(EdgeRoutingMode)))
{
menu.AddItem(new GUIContent(value.ToString()), value == mode, () =>
{
mode = value;
RunLayout();
});
}
menu.DropDown(r);
}
if (GUILayout.Button("CENTER"))
{
ResetPosition();
}
GUILayout.EndHorizontal();
GUI.DragWindow();
infos = infos ?? GetInfos(typeof(SugiyamaLayoutSettings));
foreach (MemberInfo info in infos)
{
string name = info.Name;
object value = info.GetValue(settings);
if (value != null)
{
name += " " + value;
}
IEnumerable <Attribute> att = info.GetCustomAttributes(typeof(DescriptionAttribute));
if (att.Any())
{
DescriptionAttribute desc = att.First() as DescriptionAttribute;
if (desc != null)
{
name += " (" + desc.Description + ")";
}
}
GUILayout.Label(name);
}
GUILayout.EndScrollView();
}, "Settings");
EndWindows();
}
/// <summary>
/// Create a RectilinearEdgeRouter populated with the passed obstacles.
/// </summary>
/// <returns>The populated RectilinearEdgeRouter</returns>
static RectilinearEdgeRouter FillRouter(double cornerFitRadius, double padding, IEnumerable<Node> obstacleNodes, IEnumerable<Edge> geomEdges
, EdgeRoutingMode edgeRoutingMode, bool useSparseVisibilityGraph, bool useObstacleRectangles, double bendPenaltyAsAPercentageOfDistance) {
Debug.Assert((EdgeRoutingMode.Rectilinear == edgeRoutingMode) || (EdgeRoutingMode.RectilinearToCenter == edgeRoutingMode)
, "Non-rectilinear edgeRoutingMode");
var nodeShapeMap = new Dictionary<Node, Shape>();
foreach (Node node in obstacleNodes)
{
Shape shape = CreateShapeWithRelativeNodeAtCenter(node);
nodeShapeMap.Add(node, shape);
}
var router = new RectilinearEdgeRouter(nodeShapeMap.Values, padding, cornerFitRadius, useSparseVisibilityGraph, useObstacleRectangles)
{
RouteToCenterOfObstacles = (edgeRoutingMode == EdgeRoutingMode.RectilinearToCenter),
BendPenaltyAsAPercentageOfDistance = bendPenaltyAsAPercentageOfDistance
};
foreach (var geomEdge in geomEdges) {
var edgeGeom = geomEdge.EdgeGeometry;
edgeGeom.SourcePort = nodeShapeMap[geomEdge.Source].Ports.First();
edgeGeom.TargetPort = nodeShapeMap[geomEdge.Target].Ports.First();
router.AddEdgeGeometryToRoute(edgeGeom);
}
return router;
}
/// <summary>
/// Create a RectilinearEdgeRouter from the passed obstacleNodes, with one port at the center of each obstacle,
/// and route between the obstacles, with default bend penalty.
/// </summary>
/// <param name="cornerFitRadius">The radius of the arc inscribed into path corners</param>
/// <param name="padding">The minimum padding from an obstacle's curve to its enclosing polyline</param>
/// <param name="obstacleNodes">The nodes of the graph</param>
/// <param name="geometryEdges">Edges defining the nodes to route between, and receiving the resultant paths</param>
/// <param name="edgeRoutingMode">Mode of the edges (Rectilinear or RectilinearToCenter).</param>
/// <param name="useSparseVisibilityGraph">Use a more memory-efficient but possibly path-suboptimal visibility graph</param>
static public void CreatePortsAndRouteEdges(double cornerFitRadius, double padding
, IEnumerable<Node> obstacleNodes, IEnumerable<Edge> geometryEdges
, EdgeRoutingMode edgeRoutingMode, bool useSparseVisibilityGraph)
{
CreatePortsAndRouteEdges(cornerFitRadius, padding, obstacleNodes, geometryEdges, edgeRoutingMode
, useSparseVisibilityGraph, false, SsstRectilinearPath.DefaultBendPenaltyAsAPercentageOfDistance);
}
/// <summary>
/// Create a RectilinearEdgeRouter populated with the passed obstacles.
/// </summary>
/// <returns>The populated RectilinearEdgeRouter</returns>
static RectilinearEdgeRouter FillRouter(double cornerFitRadius, double padding, IEnumerable <Node> obstacleNodes, IEnumerable <Edge> geomEdges
, EdgeRoutingMode edgeRoutingMode, bool useSparseVisibilityGraph, bool useObstacleRectangles, double bendPenaltyAsAPercentageOfDistance)
{
Debug.Assert((EdgeRoutingMode.Rectilinear == edgeRoutingMode) || (EdgeRoutingMode.RectilinearToCenter == edgeRoutingMode)
, "Non-rectilinear edgeRoutingMode");
var nodeShapeMap = new Dictionary <Node, Shape>();
foreach (Node node in obstacleNodes)
{
Shape shape = CreateShapeWithRelativeNodeAtCenter(node);
nodeShapeMap.Add(node, shape);
}
var router = new RectilinearEdgeRouter(nodeShapeMap.Values, padding, cornerFitRadius, useSparseVisibilityGraph, useObstacleRectangles)
{
RouteToCenterOfObstacles = (edgeRoutingMode == EdgeRoutingMode.RectilinearToCenter),
BendPenaltyAsAPercentageOfDistance = bendPenaltyAsAPercentageOfDistance
};
foreach (var geomEdge in geomEdges)
{
var edgeGeom = geomEdge.EdgeGeometry;
edgeGeom.SourcePort = nodeShapeMap[geomEdge.Source].Ports.First();
edgeGeom.TargetPort = nodeShapeMap[geomEdge.Target].Ports.First();
router.AddEdgeGeometryToRoute(edgeGeom);
}
return(router);
}
/// <summary>
/// Create a RectilinearEdgeRouter from the passed obstacleNodes, with one port at the center of each obstacle,
/// and route between the obstacles.
/// </summary>
/// <param name="cornerFitRadius">The radius of the arc inscribed into path corners</param>
/// <param name="padding">The minimum padding from an obstacle's curve to its enclosing polyline</param>
/// <param name="obstacleNodes">The nodes of the graph</param>
/// <param name="geometryEdges">Edges defining the nodes to route between, and receiving the resultant paths</param>
/// <param name="edgeRoutingMode">Mode of the edges (Rectilinear or RectilinearToCenter).</param>
/// <param name="useSparseVisibilityGraph">Use a more memory-efficient but possibly path-suboptimal visibility graph</param>
/// <param name="useObstacleRectangles">Use obstacle bounding box rectangles in visibility graph</param>
/// <param name="bendPenaltyAsAPercentageOfDistance">The cost penalty for a bend in the path, as a percentage of the Manhattan distance
/// between the source target ports.</param>
static public void CreatePortsAndRouteEdges(double cornerFitRadius, double padding
, IEnumerable<Node> obstacleNodes, IEnumerable<Edge> geometryEdges
, EdgeRoutingMode edgeRoutingMode, bool useSparseVisibilityGraph
, bool useObstacleRectangles, double bendPenaltyAsAPercentageOfDistance) {
var r = FillRouter(cornerFitRadius, padding, obstacleNodes, geometryEdges, edgeRoutingMode, useSparseVisibilityGraph
, useObstacleRectangles, bendPenaltyAsAPercentageOfDistance);
r.Run();
CreateSelfEdges(geometryEdges.Where(e => e.SourcePort.Location == e.TargetPort.Location), cornerFitRadius);
}
/// <summary>
/// Create a RectilinearEdgeRouter from the passed obstacleNodes, with one port at the center of each obstacle,
/// and route between the obstacles.
/// </summary>
/// <param name="cornerFitRadius">The radius of the arc inscribed into path corners</param>
/// <param name="padding">The minimum padding from an obstacle's curve to its enclosing polyline</param>
/// <param name="obstacleNodes">The nodes of the graph</param>
/// <param name="geometryEdges">Edges defining the nodes to route between, and receiving the resultant paths</param>
/// <param name="edgeRoutingMode">Mode of the edges (Rectilinear or RectilinearToCenter).</param>
/// <param name="useSparseVisibilityGraph">Use a more memory-efficient but possibly path-suboptimal visibility graph</param>
/// <param name="useObstacleRectangles">Use obstacle bounding box rectangles in visibility graph</param>
/// <param name="bendPenaltyAsAPercentageOfDistance">The cost penalty for a bend in the path, as a percentage of the Manhattan distance
/// between the source target ports.</param>
static public void CreatePortsAndRouteEdges(double cornerFitRadius, double padding
, IEnumerable <Node> obstacleNodes, IEnumerable <Edge> geometryEdges
, EdgeRoutingMode edgeRoutingMode, bool useSparseVisibilityGraph
, bool useObstacleRectangles, double bendPenaltyAsAPercentageOfDistance, CancelToken ct = null)
{
var r = FillRouter(cornerFitRadius, padding, obstacleNodes, geometryEdges, edgeRoutingMode, useSparseVisibilityGraph
, useObstacleRectangles, bendPenaltyAsAPercentageOfDistance);
r.Run(ct);
CreateSelfEdges(geometryEdges.Where(e => e.SourcePort.Location == e.TargetPort.Location), cornerFitRadius);
}
public static ConnectorType GetDiagramConnectorType(EdgeRoutingMode routingMode)
{
if (routingMode == EdgeRoutingMode.StraightLine)
{
return(ConnectorType.Straight);
}
if (routingMode == EdgeRoutingMode.Spline || routingMode == EdgeRoutingMode.SplineBundling || routingMode == EdgeRoutingMode.SugiyamaSplines)
{
return(ConnectorType.Curved);
}
return(ConnectorType.RightAngle);
}
private void SettingsUI()
{
Rect r = new Rect(0, 0, 60, 20);
if (EditorGUI.DropdownButton(r, new GUIContent(mode.ToString()), FocusType.Passive))
{
GenericMenu menu = new GenericMenu();
foreach (EdgeRoutingMode value in Enum.GetValues(typeof(EdgeRoutingMode)))
{
menu.AddItem(new GUIContent(value.ToString()), value == mode, () =>
{
mode = value;
RunLayout();
});
}
menu.DropDown(r);
}
}
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;
}
}
static void RectilinearTestOnGeomGraph(EdgeRoutingMode edgeRoutingMode, bool useSparseVisibilityGraph, bool useObstacleRectangles,
double bendPenalty, int reps, Random random, GeometryGraph geomGraph, Point delta) {
Console.WriteLine("shifting nodes and calling RectilinearEdgeRouter {0} times", reps);
for (int i = 0; i < reps; i++) {
Console.WriteLine(i + 1);
ShiftNodes(random, geomGraph, delta);
// if(i<=567)
// continue;
if (i == -1) {
GeometryGraphWriter.Write(geomGraph, "c:/tmp/ch0");
#if TEST_MSAGL
LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(DebugCurvesFromGraph(geomGraph));
#endif
}
var nodeShapeMap = new Dictionary<Node, Shape>();
foreach (Node node in geomGraph.Nodes) {
Shape shape = RectilinearInteractiveEditor.CreateShapeWithRelativeNodeAtCenter(node);
nodeShapeMap[node] = shape;
}
var router = new RectilinearEdgeRouter(nodeShapeMap.Values, RectilinearEdgeRouter.DefaultPadding,
RectilinearEdgeRouter.DefaultCornerFitRadius, useSparseVisibilityGraph, useObstacleRectangles) {
RouteToCenterOfObstacles = edgeRoutingMode == EdgeRoutingMode.RectilinearToCenter,
BendPenaltyAsAPercentageOfDistance = bendPenalty
};
foreach (Edge edge in geomGraph.Edges) {
EdgeGeometry edgeGeom = edge.EdgeGeometry;
edgeGeom.SourcePort = nodeShapeMap[edge.Source].Ports.First();
edgeGeom.TargetPort = nodeShapeMap[edge.Target].Ports.First();
router.AddEdgeGeometryToRoute(edgeGeom);
}
router.UpdateObstacles(geomGraph.Nodes.Select(n => nodeShapeMap[n]));
router.Run();
}
}
LayoutAlgorithmSettings ReadSugiyamaLayoutSettings(EdgeRoutingMode edgeRoutingMode) {
var sugiyama = new SugiyamaLayoutSettings();
EdgeRoutingSettings routingSettings = sugiyama.EdgeRoutingSettings;
routingSettings.EdgeRoutingMode = edgeRoutingMode;
LayoutAlgorithmSettings layoutSettings = sugiyama;
sugiyama.MinNodeWidth = GetDoubleAttributeOrDefault(GeometryToken.MinNodeWidth, sugiyama.MinNodeWidth);
sugiyama.MinNodeHeight = GetDoubleAttributeOrDefault(GeometryToken.MinNodeHeight, sugiyama.MinimalHeight);
sugiyama.AspectRatio = GetDoubleAttributeOrDefault(GeometryToken.AspectRatio, sugiyama.AspectRatio);
sugiyama.NodeSeparation = GetDoubleAttributeOrDefault(GeometryToken.NodeSeparation, sugiyama.NodeSeparation);
sugiyama.ClusterMargin = sugiyama.NodeSeparation;
#if REPORTING
sugiyama.Reporting = GetBoolAttributeOrDefault(GeometryToken.Reporting, false);
#endif
sugiyama.RandomSeedForOrdering = GetIntAttributeOrDefault(GeometryToken.RandomSeedForOrdering,
sugiyama.RandomSeedForOrdering);
sugiyama.NoGainAdjacentSwapStepsBound = GetIntAttributeOrDefault(GeometryToken.NoGainStepsBound,
sugiyama.NoGainAdjacentSwapStepsBound);
sugiyama.MaxNumberOfPassesInOrdering = GetIntAttributeOrDefault(GeometryToken.MaxNumberOfPassesInOrdering,
sugiyama.MaxNumberOfPassesInOrdering);
sugiyama.RepetitionCoefficientForOrdering = GetIntAttributeOrDefault(GeometryToken.
RepetitionCoefficientForOrdering, sugiyama.RepetitionCoefficientForOrdering);
sugiyama.GroupSplit = GetIntAttributeOrDefault(GeometryToken.GroupSplit, sugiyama.GroupSplit);
sugiyama.LabelCornersPreserveCoefficient = GetDoubleAttribute(GeometryToken.LabelCornersPreserveCoefficient);
sugiyama.BrandesThreshold = GetIntAttributeOrDefault(GeometryToken.BrandesThreshold,
sugiyama.BrandesThreshold);
sugiyama.LayerSeparation = GetDoubleAttributeOrDefault(GeometryToken.LayerSeparation,
sugiyama.LayerSeparation);
var transform = new PlaneTransformation();
ReadTransform(transform);
return layoutSettings;
}
/// <summary>
///
/// </summary>
/// <param name="fileList"></param>
/// <param name="edgeRoutingMode"></param>
/// <param name="useSparseVisibilityGraph"></param>
/// <param name="useObstacleRectangles"></param>
/// <param name="bendPenalty"></param>
/// <param name="coneAngle"></param>
static void LoadGeomFilesTest(IEnumerable<string> fileList, EdgeRoutingMode edgeRoutingMode, bool useSparseVisibilityGraph,
bool useObstacleRectangles, double bendPenalty, double coneAngle) {
foreach (string s in fileList)
LoadGeomFileTest(s, edgeRoutingMode, useSparseVisibilityGraph, useObstacleRectangles, bendPenalty, coneAngle);
}
static internal bool RectRouting(EdgeRoutingMode mode) {
return mode == EdgeRoutingMode.Rectilinear || mode == EdgeRoutingMode.RectilinearToCenter;
}
static void ProcessFile(string fileName, int fileReps, bool show, bool mds, EdgeRoutingMode edgeRoutingMode, double bendPenalty,
ref int nOfBugs, bool bundling, int randomShifts, bool useSparseVisibilityGraph, bool useObstacleRectangles) {
Console.WriteLine(fileName);
var random = new Random(1);
for (int rep = 0; rep < fileReps; ++rep) {
try {
int line, column;
bool msaglFile;
Graph gwgraph = Form2.CreateDrawingGraphFromFile(fileName, out line, out column, out msaglFile);
if (msaglFile) {
using (var f = new Form2(false) {
EdgeRoutingMode = edgeRoutingMode,
UseObstacleRectangles = useObstacleRectangles}) {
f.GViewer.NeedToCalculateLayout=false;
if (edgeRoutingMode == EdgeRoutingMode.SplineBundling) {
var nodeSeparation = gwgraph.LayoutAlgorithmSettings.NodeSeparation;
GeometryGraph originalGraph=gwgraph.GeometryGraph;
var coneAngle = gwgraph.LayoutAlgorithmSettings.EdgeRoutingSettings.ConeAngle;
var padding = nodeSeparation / 3;
var loosePadding = SplineRouter.ComputeLooseSplinePadding(nodeSeparation, padding) * 2;
var br = new SplineRouter(originalGraph, padding, loosePadding, coneAngle,
gwgraph.LayoutAlgorithmSettings.EdgeRoutingSettings.BundlingSettings);
br.Run();
}
if (show)
{
f.StartPosition = FormStartPosition.CenterScreen;
// f.layerSeparationMult.Value = (decimal)(gwgraph.GraphAttr.LayerSep / gwgraph.GraphAttr.MinLayerSep);
f.Size = new Size(Screen.PrimaryScreen.WorkingArea.Width,
Screen.PrimaryScreen.WorkingArea.Height);
f.GViewer.Graph = gwgraph;
f.ShowDialog();
}
}
}
else
if (gwgraph != null) {
gwgraph.LayoutAlgorithmSettings.EdgeRoutingSettings.EdgeRoutingMode = edgeRoutingMode;
gwgraph.LayoutAlgorithmSettings.EdgeRoutingSettings.UseObstacleRectangles = useObstacleRectangles;
gwgraph.LayoutAlgorithmSettings.EdgeRoutingSettings.BendPenalty = bendPenalty;
using (var f = new Form2(false) {
EdgeRoutingMode = edgeRoutingMode,
UseObstacleRectangles = useObstacleRectangles,
BendPenalty = bendPenalty
}) {
if (mds) {
foreach (Microsoft.Msagl.Drawing.Node n in gwgraph.Nodes)
n.Attr.FillColor = Color.WhiteSmoke;
gwgraph.LayoutAlgorithmSettings = new MdsLayoutSettings {
EdgeRoutingSettings = {
EdgeRoutingMode = edgeRoutingMode,
BundlingSettings = bundling ? new BundlingSettings() : null
}
};
}
object ret = f.GViewer.CalculateLayout(gwgraph);
if (randomShifts > 0) {
var del = new Point(2, 2);
GeometryGraph geomGraph = f.GViewer.Graph.GeometryGraph;
for (int i = 0; i < randomShifts; i++) {
ShiftNodes(random, geomGraph, del);
if (edgeRoutingMode == EdgeRoutingMode.Rectilinear ||
edgeRoutingMode == EdgeRoutingMode.RectilinearToCenter)
RouteRectEdgesOfGeomGraph(edgeRoutingMode, useSparseVisibilityGraph, useObstacleRectangles, bendPenalty,
geomGraph, (SugiyamaLayoutSettings)gwgraph.LayoutAlgorithmSettings);
}
}
if (show) {
f.Text = Process.GetCurrentProcess().MainModule.FileName;
f.StartPosition = FormStartPosition.CenterScreen;
// f.layerSeparationMult.Value = (decimal)(gwgraph.GraphAttr.LayerSep / gwgraph.GraphAttr.MinLayerSep);
f.GViewer.SetCalculatedLayout(ret);
f.Size = new Size(Screen.PrimaryScreen.WorkingArea.Width,
Screen.PrimaryScreen.WorkingArea.Height);
f.ShowDialog();
}
}
} else
Console.WriteLine(" skipping - cannot parse");
}
catch (Exception e) {
nOfBugs++;
Console.WriteLine("bug " + nOfBugs);
if (fileReps > 1) {
Console.WriteLine(" (iteration: {0})", rep);
}
Console.WriteLine(e.ToString());
return;
}
if ((rep > 1) && (0 == (rep%100))) {
Console.WriteLine(" {0} reps", rep);
}
}
}
static void ProcessFileSpec(string fileSpec, int fileReps, bool show, bool mds, EdgeRoutingMode edgeRoutingMode, double bendPenalty,
bool bundling, int randomShifts, bool useSparseVisibilityGraph, bool useObstacleRectangles) {
// strPathFileSpec may be with or without directory or wildcards, e.g.:
// x.txt, Test\Data\x.txt, Test\Data\Rand*.txt
string fileName = Path.GetFileName(fileSpec);
string dirName = Path.GetDirectoryName(fileSpec);
dirName = Path.GetFullPath((0 == dirName.Length) ? "." : dirName);
int nOfBugs = 0;
FileSystemInfo[] fileInfos = new DirectoryInfo(dirName).GetFileSystemInfos(fileName);
if (0 == fileInfos.Length) {
Console.WriteLine("No matching files found for '{0}'", fileSpec);
return;
}
foreach (FileSystemInfo fileInfo in fileInfos)
ProcessFile(fileInfo.FullName, fileReps, show, mds, edgeRoutingMode, bendPenalty, ref nOfBugs, bundling, randomShifts,
useSparseVisibilityGraph, useObstacleRectangles);
}
static void ProcessFileList(string listFile, int fileReps, bool show, bool mds, EdgeRoutingMode edgeRoutingMode, double bendPenalty,
bool bundling, int randomShifts, bool useSparseVisibilityGraph, bool useObstacleRectangles) {
StreamReader sr;
try {
sr = new StreamReader(listFile);
}
catch (Exception e) {
Console.WriteLine(e.Message);
return;
}
string fileName;
int nOfBugs = 0;
while ((fileName = sr.ReadLine()) != null) {
if (String.IsNullOrEmpty(fileName)) continue;
fileName = Path.Combine(Path.GetDirectoryName(listFile), fileName.ToLower());
ProcessFile(fileName, fileReps, show, mds, edgeRoutingMode, bendPenalty, ref nOfBugs, bundling, randomShifts,
useSparseVisibilityGraph, useObstacleRectangles);
}
sr.Close();
}
static void RouteRectEdgesOfGeomGraph(EdgeRoutingMode edgeRoutingMode, bool useSparseVisibilityGraph, bool useObstacleRectangles,
double bendPenalty, GeometryGraph geomGraph, SugiyamaLayoutSettings settings) {
var nodeShapeMap = new Dictionary<Node, Shape>();
foreach (Node node in geomGraph.Nodes) {
Shape shape = RectilinearInteractiveEditor.CreateShapeWithRelativeNodeAtCenter(node);
nodeShapeMap[node] = shape;
}
var padding = (settings == null) ? 3 : settings.NodeSeparation / 3;
var router = new RectilinearEdgeRouter(nodeShapeMap.Values, padding, 3, useSparseVisibilityGraph, useObstacleRectangles)
{
RouteToCenterOfObstacles = edgeRoutingMode == EdgeRoutingMode.RectilinearToCenter,
BendPenaltyAsAPercentageOfDistance = bendPenalty
};
foreach (Edge edge in geomGraph.Edges) {
EdgeGeometry edgeGeom = edge.EdgeGeometry;
edgeGeom.SourcePort = nodeShapeMap[edge.Source].Ports.First();
edgeGeom.TargetPort = nodeShapeMap[edge.Target].Ports.First();
// Remove any path results retrieved from the geom file.
edgeGeom.Curve = null;
if (edgeGeom.SourceArrowhead != null)
{
edgeGeom.SourceArrowhead.TipPosition = new Point();
}
if (edgeGeom.TargetArrowhead != null)
{
edgeGeom.TargetArrowhead.TipPosition = new Point();
}
router.AddEdgeGeometryToRoute(edgeGeom);
}
router.Run();
}
static void LoadGeomFileTest(string s, EdgeRoutingMode edgeRoutingMode, bool useSparseVisibilityGraph,
bool useObstacleRectangles, double bendPenalty, double coneAngle) {
var random = new Random(1);
var delta = new Point(2, 2);
GeometryGraph geomGraph = GeometryGraphReader.CreateFromFile(s);
const int reps = 1000;
if (edgeRoutingMode == EdgeRoutingMode.Rectilinear || edgeRoutingMode == EdgeRoutingMode.RectilinearToCenter)
RectilinearTestOnGeomGraph(edgeRoutingMode, useSparseVisibilityGraph, useObstacleRectangles, bendPenalty, reps, random, geomGraph, delta);
else {
var router = new SplineRouter(geomGraph, 9, 0.95238095238095233, Math.PI/6, null);
router.Run();
#if TEST_MSAGL
LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(DebugCurvesFromGraph(geomGraph));
#endif
}
}
