internal RectilinearEdgeRouterWrapper RunGeomGraphWithFreePorts(string fileName, bool loadOnly)
{
var geomGraph = GeometryGraphReader.CreateFromFile(fileName);
if (loadOnly)
{
return(null);
}
var router = createRouterFunc(geomGraph.Nodes.Select(node => new Shape(node.BoundaryCurve)));
foreach (var edge in geomGraph.Edges)
{
// Use a null curve, for consistency with RectilinearVerifier.MakeAbsoluteObstaclePort
// treatment of UseFreePortsForObstaclePorts.
EdgeGeometry edgeGeom = edge.EdgeGeometry;
edgeGeom.SourcePort = new FloatingPort(null, edge.Source.Center);
edgeGeom.TargetPort = new FloatingPort(null, edge.Target.Center);
router.AddEdgeGeometryToRoute(edgeGeom);
}
router.Run();
if (null != ShowGraph)
{
ShowGraph(router);
}
return(router);
}
void SetEdgeGeometryCurve(EdgeGeometry edgeGeometry)
{
Polyline poly = new Polyline();
SdVertex curV = EdgesToRouteSources[edgeGeometry];
poly.AddPoint(curV.Point);
foreach (var edge in EdgesToRoutes[edgeGeometry])
{
if (edge.SourcePoint == curV.Point)
{
poly.AddPoint(edge.TargetPoint);
curV = edge.Target;
}
else
{
poly.AddPoint(edge.SourcePoint);
curV = edge.Source;
}
}
edgeGeometry.Curve = poly;
var clusterSourcePort = edgeGeometry.SourcePort as ClusterBoundaryPort;
if (clusterSourcePort != null)
{
ExtendPolylineStartToClusterBoundary(poly, clusterSourcePort.Curve);
}
var clusterTargetPort = edgeGeometry.TargetPort as ClusterBoundaryPort;
if (clusterTargetPort != null)
{
ExtendPolylineEndToClusterBoundary(poly, clusterTargetPort.Curve);
}
}
List <SdBoneEdge> RouteEdge(EdgeGeometry edgeGeometry)
{
CurrentEdgeGeometry = edgeGeometry;
for (int i = 0; i < vertexArray.Length; i++)
{
var sdv = vertexArray[i];
sdv.SetPreviousToNull();
sdv.IsSourceOfRouting = sdv.IsTargetOfRouting = false;
}
var transparentShapes = MakeTransparentShapesOfEdgeGeometry(edgeGeometry);
var ret = RouteEdgeWithGroups();
foreach (var shape in transparentShapes)
{
shape.IsTransparent = false;
}
/*List<LineSegment> ls = new List<LineSegment>();
* foreach (var e in ret)
* ls.Add(new LineSegment(e.SourcePoint, e.TargetPoint));
* SplineRouter.ShowVisGraph(this.VisibilityGraph, ObstacleHierarchy.GetAllLeaves(), null, ls);*/
return(ret);
}
internal Func <Tuple <Polyline, Polyline> > EdgeSourceAndTargetFunc(EdgeGeometry geomEdge)
{
return
(() =>
new Tuple <Polyline, Polyline>(LoosePolylineOfPort(geomEdge.SourcePort),
LoosePolylineOfPort(geomEdge.TargetPort)));
}
void InitEdgeData(EdgeGeometry geomEdge, int index)
{
var metroEdge = new Metroline((Polyline)geomEdge.Curve, geomEdge.LineWidth, EdgeSourceAndTargetFunc(geomEdge), index);
metrolines.Add(metroEdge);
PointToStations[metroEdge.Polyline.Start].BoundaryCurve = geomEdge.SourcePort.Curve;
PointToStations[metroEdge.Polyline.End].BoundaryCurve = geomEdge.TargetPort.Curve;
}
double AddedCapacityPenalty(EdgeGeometry edgeGeometry, IEnumerable <CdtEdge> enteredCdtEdges)
{
if (cdt == null)
{
return(0);
}
return(enteredCdtEdges.Sum(cdtEdge => AddedCapacityPenaltyForCdtEdge(cdtEdge, edgeGeometry)));
}
double SavedCapacityPenalty(EdgeGeometry edgeGeometry, IEnumerable <CdtEdge> abondonedEdges)
{
if (abondonedEdges == null)
{
return(0);
}
return(abondonedEdges.Sum(cdtEdge => SavedCapacityPenaltyOnCdtEdge(cdtEdge, edgeGeometry)));
}
void InitializeEdgeData()
{
metrolines = new List <Metroline>();
for (int i = 0; i < regularEdges.Length; i++)
{
EdgeGeometry geomEdge = regularEdges[i];
InitEdgeData(geomEdge, i);
}
}
public static Geometry CreateEdgeTargetArrow(EdgeGeometry edgeGeometry, double pathStrokeThickness)
{
var streamGeometry = new StreamGeometry();
using (StreamGeometryContext context = streamGeometry.Open())
CreateEdgeArrow(context, edgeGeometry.Curve.End, edgeGeometry.TargetArrowhead.TipPosition, pathStrokeThickness);
return(streamGeometry);
}
Point FigureOutHookLocation(Polyline poly, Port otherEdgeEndPort, EdgeGeometry edgeGeom)
{
var clusterPort = otherEdgeEndPort as ClusterBoundaryPort;
if (clusterPort == null)
{
return(FigureOutHookLocationForSimpleOtherPort(poly, otherEdgeEndPort, edgeGeom));
}
return(FigureOutHookLocationForClusterOtherPort(poly, clusterPort, edgeGeom));
}
internal RectilinearEdgeRouterWrapper RunGeomGraph(string fileName, bool loadOnly)
{
var geomGraph = GeometryGraphReader.CreateFromFile(fileName);
if (loadOnly)
{
return(null);
}
var nodeShapeMap = new Dictionary <Node, Shape>();
foreach (Node node in geomGraph.Nodes)
{
Shape shape = RectilinearInteractiveEditor.CreateShapeWithRelativeNodeAtCenter(node);
nodeShapeMap.Add(node, shape);
}
if (null != ShowShapes)
{
ShowShapes(nodeShapeMap.Values);
}
var router = createRouterFunc(nodeShapeMap.Values);
if (!this.NoPorts)
{
foreach (var 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);
}
}
if (null != ShowInitialObstacles)
{
ShowInitialObstacles(router);
}
router.Run();
if (null != ShowGraph)
{
ShowGraph(router);
}
return(router);
}
double SavedCostBetween(PolylinePoint aFirst, PolylinePoint aLast, EdgeGeometry edgeGeometry, IEnumerable <CdtEdge> edgesAbondonedByA)
{
double savedCost = 0;
//path length
savedCost += LengthBetween(aFirst, aLast);
//capacity
savedCost += SavedCapacityPenalty(edgeGeometry, edgesAbondonedByA);
return(savedCost);
}
double CostGrowth(Point aFirst, Point aLast,
Dictionary <Point, PolylinePoint> aPointMap,
Dictionary <Point, PolylinePoint> bPointMap,
bool aFirstBeforeALastOnB, EdgeGeometry edgeGeometry,
IEnumerable <CdtEdge> edgesAbondonedByA, IEnumerable <CdtEdge> edgesEnteredByA)
{
double savedCost = SavedCostBetween(aPointMap[aFirst], aPointMap[aLast], edgeGeometry, edgesAbondonedByA);
double addedCost = AddedCostBetweenAfterCollapse(bPointMap[aFirst], bPointMap[aLast], aFirstBeforeALastOnB, edgeGeometry, edgesEnteredByA);
return(addedCost - savedCost);
}
public override string GetStepParameters()
{
var parameters = new List <string>();
parameters.Add(EdgeStart != null ? EdgeStart.ToStepValue() : "$");
parameters.Add(EdgeEnd != null ? EdgeEnd.ToStepValue() : "$");
parameters.Add(EdgeGeometry != null ? EdgeGeometry.ToStepValue() : "$");
parameters.Add(SameSense != null ? SameSense.ToStepValue() : "$");
return(string.Join(", ", parameters.ToArray()));
}
/// <summary>
/// Reroute edge
/// </summary>
List <SdBoneEdge> RerouteEdge(EdgeGeometry edgeGeometry)
{
var route = EdgesToRoutes[edgeGeometry];
foreach (var edge in route)
{
edge.RemoveOccupiedEdge();
}
return(RouteEdge(edgeGeometry));
}
void AddEdgeGeometryToGraph(EdgeGeometry eg, GeometryGraph graph, Dictionary <ICurve, Node> nodeDictionary)
{
var sourceNode = GetOrCreateNode(eg.SourcePort, nodeDictionary);
var targetNode = GetOrCreateNode(eg.TargetPort, nodeDictionary);
var edge = new Edge(sourceNode, targetNode)
{
EdgeGeometry = eg
};
graph.Edges.Add(edge);
}
IEnumerable <Shape> GetMinCommonAncestors(EdgeGeometry edgeGeometry)
{
if (PortToShapes == null)
{
PortToShapes = MapPortsToShapes(AncestorsSets.Keys);
}
var commonAncestors = AncestorsForPort(edgeGeometry.SourcePort) *
AncestorsForPort(edgeGeometry.TargetPort);
return(commonAncestors.Where(anc => !anc.Children.Any(child => commonAncestors.Contains(child))));
}
private static IEnumerable <ICurve> ArrowHeadCurves(EdgeGeometry edgeGeom)
{
var start = edgeGeom.Curve.End;
var end = edgeGeom.TargetArrowhead.TipPosition;
var ang = Math.PI / 12;
var leftTip = end + (start - end).Rotate(ang);
var rightTip = end + (start - end).Rotate(-ang);
return(new List <ICurve> {
new LineSegment(leftTip, end), new LineSegment(rightTip, end)
});
}
internal void StopDrawingRubberEdge()
{
if (CurrentRubberEdge != null)
{
GViewer.Invalidate(
GViewer.CreateScreenRectFromTwoCornersInTheSource(
CurrentRubberEdge.BoundingBox.LeftTop,
CurrentRubberEdge.BoundingBox.RightBottom));
}
CurrentRubberEdge = null;
}
internal void DrawRubberEdge(EdgeGeometry edgeGeometry)
{
BBox rectToInvalidate = edgeGeometry.BoundingBox;
if (CurrentRubberEdge != null)
{
BBox b = CurrentRubberEdge.BoundingBox;
rectToInvalidate.Add(b);
}
CurrentRubberEdge = edgeGeometry;
GViewer.Invalidate(GViewer.CreateScreenRectFromTwoCornersInTheSource(rectToInvalidate.LeftTop,
rectToInvalidate.RightBottom));
}
internal static Geometry DefiningTargetArrowHead(EdgeGeometry edgeGeometry, double thickness)
{
if (edgeGeometry.TargetArrowhead == null || edgeGeometry.Curve == null)
{
return(null);
}
var streamGeometry = new StreamGeometry();
using (StreamGeometryContext context = streamGeometry.Open()) {
AddArrow(context, edgeGeometry.Curve.End,
edgeGeometry.TargetArrowhead.TipPosition, thickness);
return(streamGeometry);
}
}
internal virtual void UniteEdgeCurvesBetweenWaypoints()
{
foreach (var pair in this.edgeGeomsToSplittedEdgePaths)
{
EdgeGeometry edgeGeom = pair.Key;
IEnumerable <Path> splittedPieces = pair.Value;
var polyline = new Polyline(splittedPieces.First().EdgeGeometry.Curve as Polyline);
foreach (EdgeGeometry piece in splittedPieces.Skip(1).Select(path => path.EdgeGeometry))
{
polyline.AddRangeOfPoints((piece.Curve as Polyline).Skip(1));
}
edgeGeom.Curve = polyline;
}
}
private void ReadRoutingSpecs()
{
Match m;
this.VerifyIsNextLine(RectFileStrings.BeginRoutingSpecs);
// Get to the first line for consistency with the lookahead for waypoints, which will
// end up reading the following line.
this.NextLine();
for (;;)
{
if (!(m = ParseOrDone(RectFileStrings.ParseEdgeGeometry, RectFileStrings.EndRoutingSpecs)).Success)
{
break;
}
var sourceId = int.Parse(m.Groups["sourceId"].ToString());
var targetId = int.Parse(m.Groups["targetId"].ToString());
var arrowheadAtSource = bool.Parse(m.Groups["arrowheadAtSource"].ToString());
var arrowheadAtTarget = bool.Parse(m.Groups["arrowheadAtTarget"].ToString());
var arrowheadLength = double.Parse(m.Groups["arrowheadLength"].ToString());
var arrowheadWidth = double.Parse(m.Groups["arrowheadWidth"].ToString());
var lineWidth = double.Parse(m.Groups["lineWidth"].ToString());
Port sourcePort, targetPort;
Validate.IsTrue(idToPortMap.TryGetValue(sourceId, out sourcePort), CurrentLineError("Can't find source port"));
Validate.IsTrue(idToPortMap.TryGetValue(targetId, out targetPort), CurrentLineError("Can't find target port"));
var edgeGeom = new EdgeGeometry(sourcePort, targetPort)
{
LineWidth = lineWidth
};
if (arrowheadAtSource)
{
edgeGeom.SourceArrowhead = new Arrowhead {
Length = arrowheadLength, Width = arrowheadWidth
};
}
if (arrowheadAtTarget)
{
edgeGeom.TargetArrowhead = new Arrowhead {
Length = arrowheadLength, Width = arrowheadWidth
};
}
this.RoutingSpecs.Add(edgeGeom);
this.ReadWaypoints(edgeGeom);
}
}
internal static Geometry DefiningTargetArrowHead(EdgeGeometry edgeGeometry, double thickness)
{
if (edgeGeometry.TargetArrowhead == null || edgeGeometry.Curve == null)
{
return(null);
}
var pathGeometry = new PathGeometry();
pathGeometry.Figures = new PathFigureCollection();
AddArrow(pathGeometry, edgeGeometry.Curve.End, edgeGeometry.TargetArrowhead.TipPosition, thickness);
return(pathGeometry);
}
/// <summary>
/// Add an EdgeGeometry to route
/// </summary>
/// <param name="edgeGeometry"></param>
public void AddEdgeGeometryToRoute(EdgeGeometry edgeGeometry)
{
ValidateArg.IsNotNull(edgeGeometry, "edgeGeometry");
// The Port.Location values are not necessarily rounded by the caller. The values
// will be rounded upon acquisition in PortManager.cs. PointComparer.Equal expects
// all values to be rounded.
if (!PointComparer.Equal(ApproximateComparer.Round(edgeGeometry.SourcePort.Location)
, ApproximateComparer.Round(edgeGeometry.TargetPort.Location)))
{
EdgeGeometries.Add(edgeGeometry);
}
else
{
selfEdges.Add(edgeGeometry);
}
}
private static IEnumerable <Path> SplitEdgeGeomWithWaypoints(EdgeGeometry edgeGeom, IEnumerable <Point> waypoints)
{
var ret = new List <Path>();
IEnumerator <Point> wp0 = waypoints.GetEnumerator();
wp0.MoveNext();
ret.Add(new Path(new EdgeGeometry(edgeGeom.SourcePort, new WaypointPort(wp0.Current))));
IEnumerator <Point> wp1 = waypoints.GetEnumerator();
wp1.MoveNext();
while (wp1.MoveNext())
{
ret.Add(new Path(new EdgeGeometry(new WaypointPort(wp0.Current), new WaypointPort(wp1.Current))));
wp0.MoveNext();
}
ret.Add(new Path(new EdgeGeometry(new WaypointPort(wp0.Current), edgeGeom.TargetPort)));
return(ret);
}
public void DrawRubberEdge(EdgeGeometry edgeGeometry)
{
if (_rubberEdgePath == null)
{
_rubberEdgePath = new Path
{
Stroke = Brushes.Black,
StrokeThickness = GetBorderPathThickness() * 3
};
GraphCanvas.Children.Add(_rubberEdgePath);
_targetArrowheadPathForRubberEdge = new Path
{
Stroke = Brushes.Black,
StrokeThickness = GetBorderPathThickness() * 3
};
GraphCanvas.Children.Add(_targetArrowheadPathForRubberEdge);
}
_rubberEdgePath.Data = VisualsFactory.CreateEdgePath(edgeGeometry.Curve);
_targetArrowheadPathForRubberEdge.Data = VisualsFactory.CreateEdgeTargetArrow(edgeGeometry, edgeGeometry.LineWidth);
}
private void ReadWaypoints(EdgeGeometry edgeGeom)
{
if (!IsNextLine(RectFileStrings.Waypoints))
{
return;
}
var waypoints = new List <Point>();
Match m;
while ((m = TryParseNext(RectFileStrings.ParsePoint)).Success)
{
// We reuse ParsePoint because a span is just two doubles as well.
var x = double.Parse(m.Groups["X"].ToString());
var y = double.Parse(m.Groups["Y"].ToString());
waypoints.Add(new Point(x, y));
}
Validate.IsTrue(waypoints.Count > 0, CurrentLineError("Empty waypoint list"));
edgeGeom.Waypoints = waypoints;
}
void InitNodeEnterableLoosePolylines(Metroline metroline, EdgeGeometry regularEdge)
{
//If we have groups, EdgeLooseEnterable are precomputed.
var metrolineEnterable = EdgeLooseEnterable != null ? EdgeLooseEnterable[regularEdge] : new Set <Polyline>();
for (var p = metroline.Polyline.StartPoint.Next; p != null && p.Next != null; p = p.Next)
{
var v = PointToStations[p.Point];
if (v.EnterableLoosePolylines != null)
{
v.EnterableLoosePolylines *= metrolineEnterable;
}
else
{
v.EnterableLoosePolylines = new Set <Polyline>(metrolineEnterable);
}
}
AddLooseEnterableForMetrolineStartEndPoints(metroline);
}
void CreateCurveLine(Metroline line, EdgeGeometry edge)
{
var c = new Curve();
Point start = FindCurveStart(metroGraphData, metroOrdering, line);
Point currentEnd = start;
var hubSegsOfLine = HubSegsOfLine(metroGraphData, metroOrdering, line);
foreach (var seg in hubSegsOfLine)
{
if (seg == null)
{
continue;
}
c.AddSegment(new LineSegment(currentEnd, seg.Start));
c.AddSegment(seg);
currentEnd = seg.End;
}
c.AddSegment(new LineSegment(currentEnd, FindCurveEnd(metroGraphData, metroOrdering, line)));
edge.Curve = c;
}
