2020-04-14 00:42:04 +01:00
using System ;
using System.Collections.Generic ;
using System.Diagnostics ;
using System.Diagnostics.CodeAnalysis ;
using System.Linq ;
using Microsoft.Msagl.Core.DataStructures ;
using Microsoft.Msagl.Core.Geometry ;
using Microsoft.Msagl.Core.Geometry.Curves ;
using Microsoft.Msagl.Core.Layout ;
using Microsoft.Msagl.Core.ProjectionSolver ;
using Microsoft.Msagl.DebugHelpers ;
using Microsoft.Msagl.Routing.Visibility ;
namespace Microsoft.Msagl.Routing.Rectilinear.Nudging {
/// <summary>
/// following paper "Orthogonal Connector Routing" which is included in the project
/// </summary>
#if TEST_MSAGL
public
#else
internal
#endif
class Nudger {
bool HasGroups {
get { return ( null ! = HierarchyOfGroups ) & & ( HierarchyOfGroups . Count > 0 ) ; }
}
Dictionary < AxisEdge , Polyline > axisEdgesToObstaclesTheyOriginatedFrom ;
List < Path > Paths { get ; set ; }
IEnumerable < Polyline > Obstacles { get ; set ; }
internal VisibilityGraph PathVisibilityGraph { get ; set ; }
/// <summary>
/// "nudge" paths to decrease the number of intersections and stores the results inside WidePaths of "paths"
/// </summary>
/// <param name="paths">paths through the graph</param>
/// <param name="cornerFitRad">two parallel paths should be separated by this distance if it is feasible</param>
/// <param name="obstacles">polygonal convex obstacles organized in a tree; the obstacles here are padded original obstacles</param>
/// <param name="ancestorsSets"></param>
/// <returns></returns>
internal Nudger ( IEnumerable < Path > paths , double cornerFitRad , IEnumerable < Polyline > obstacles ,
Dictionary < Shape , Set < Shape > > ancestorsSets ) {
AncestorsSets = ancestorsSets ;
HierarchyOfGroups = RectangleNode < Shape > . CreateRectangleNodeOnEnumeration (
ancestorsSets . Keys . Where ( shape = > shape . IsGroup ) . Select ( group = > new RectangleNode < Shape > ( group , group . BoundingBox ) ) ) ;
Obstacles = obstacles ;
EdgeSeparation = 2 * cornerFitRad ;
Paths = new List < Path > ( paths ) ;
HierarchyOfObstacles =
RectangleNode < Polyline > . CreateRectangleNodeOnEnumeration (
obstacles . Select ( p = > new RectangleNode < Polyline > ( p , p . BoundingBox ) ) ) ;
MapPathsToTheirObstacles ( ) ;
}
Dictionary < Shape , Set < Shape > > AncestorsSets { get ; set ; }
void MapPathsToTheirObstacles ( ) {
PathToObstacles = new Dictionary < Path , Tuple < Polyline , Polyline > > ( ) ;
foreach ( var path in Paths )
MapPathToItsObstacles ( path ) ;
}
void MapPathToItsObstacles ( Path path ) {
var startNode = HierarchyOfObstacles . FirstHitNode ( path . PathPoints . First ( ) , ObstacleTest ) ;
var endNode = HierarchyOfObstacles . FirstHitNode ( path . PathPoints . Last ( ) , ObstacleTest ) ;
if ( ( null ! = startNode ) & & ( null ! = endNode ) ) {
PathToObstacles [ path ] = new Tuple < Polyline , Polyline > ( startNode . UserData , endNode . UserData ) ;
}
}
static HitTestBehavior ObstacleTest ( Point pnt , Polyline polyline ) {
return ( Curve . PointRelativeToCurveLocation ( pnt , polyline ) ! =
PointLocation . Outside )
? HitTestBehavior . Stop
: HitTestBehavior . Continue ;
}
/// <summary>
///
/// </summary>
protected RectangleNode < Polyline > HierarchyOfObstacles { get ; set ; }
/// <summary>
///
/// </summary>
protected RectangleNode < Shape > HierarchyOfGroups { get ; set ; }
internal void Calculate ( Directions direction , bool mergePaths ) {
NudgingDirection = direction ;
PathRefiner . RefinePaths ( Paths , mergePaths ) ;
// ShowPathsDebug(Paths);
GetPathOrdersAndPathGraph ( ) ;
MapAxisEdgesToTheirObstacles ( ) ;
DrawPaths ( ) ;
//ShowPathsDebug(Paths);
}
void MapAxisEdgesToTheirObstacles ( ) {
axisEdgesToObstaclesTheyOriginatedFrom = new Dictionary < AxisEdge , Polyline > ( ) ;
foreach ( var path in Paths )
MapPathEndAxisEdgesToTheirObstacles ( path ) ;
//The assignment above was too greedy. An edge belonging to interiour edges of some path can be marked by mistake.
foreach ( var path in Paths )
UmmapPathInteriourFromStrangerObstacles ( path ) ;
}
void UmmapPathInteriourFromStrangerObstacles ( Path path ) {
var firstUnmappedEdge = FindFirstUnmappedEdge ( path ) ;
if ( firstUnmappedEdge = = null ) return ;
var lastUnmappedEdge = FindLastUnmappedEdge ( path ) ;
for ( var edge = firstUnmappedEdge ; edge ! = null & & edge ! = lastUnmappedEdge ; edge = edge . Next )
axisEdgesToObstaclesTheyOriginatedFrom . Remove ( edge . AxisEdge ) ;
}
PathEdge FindLastUnmappedEdge ( Path path ) {
for ( var edge = path . LastEdge ; edge ! = null ; edge = edge . Prev )
if ( edge . AxisEdge . Direction ! = NudgingDirection )
return edge ;
return null ;
}
PathEdge FindFirstUnmappedEdge ( Path path ) {
for ( var edge = path . FirstEdge ; edge ! = null ; edge = edge . Next )
if ( edge . AxisEdge . Direction ! = NudgingDirection )
return edge ;
return null ;
}
void MapPathEndAxisEdgesToTheirObstacles ( Path path ) {
Tuple < Polyline , Polyline > coupleOfObstacles ;
if ( PathToObstacles . TryGetValue ( path , out coupleOfObstacles ) ) {
ProcessThePathStartToMapAxisEdgesToTheirObstacles ( path , coupleOfObstacles . Item1 ) ;
ProcessThePathEndToMapAxisEdgesToTheirObstacles ( path , coupleOfObstacles . Item2 ) ;
}
}
void ProcessThePathEndToMapAxisEdgesToTheirObstacles ( Path path , Polyline endPolyline ) {
for ( var edge = path . LastEdge ;
edge ! = null & & CompassVector . DirectionsAreParallel ( edge . Direction , NudgingDirection ) ;
edge = edge . Prev )
axisEdgesToObstaclesTheyOriginatedFrom [ edge . AxisEdge ] = endPolyline ;
}
void ProcessThePathStartToMapAxisEdgesToTheirObstacles ( Path path , Polyline startPolyline ) {
for ( var edge = path . FirstEdge ;
edge ! = null & & CompassVector . DirectionsAreParallel ( edge . Direction , NudgingDirection ) ;
edge = edge . Next )
axisEdgesToObstaclesTheyOriginatedFrom [ edge . AxisEdge ] = startPolyline ;
//possible bug here because an edge might ignore two obstacles if it connects them
}
void GetPathOrdersAndPathGraph ( ) {
var combinatorialNudger = new CombinatorialNudger ( Paths ) ;
PathOrders = combinatorialNudger . GetOrder ( ) ;
PathVisibilityGraph = combinatorialNudger . PathVisibilityGraph ;
}
/ *
[Conditional("DEBUG")]
void CheckPathsForSwitchbacks ( ) {
foreach ( var p in Paths )
CheckForSwitchbacks ( p . PathPoints . ToArray ( ) ) ;
}
* /
Directions NudgingDirection { get ; set ; }
#region debugging
#if TEST_MSAGL
static internal ICurve [ ] GetCurvesForShow ( IEnumerable < Path > paths , IEnumerable < Polyline > obstacles ) {
var ret = new List < ICurve > ( ) ;
foreach ( var path in paths ) {
var poly = new Polyline ( ) ;
foreach ( var point in path . PathPoints )
poly . AddPoint ( point ) ;
ret . Add ( poly ) ;
}
ret . AddRange ( obstacles . Cast < ICurve > ( ) ) ;
return ret . ToArray ( ) ;
}
#endif
#endregion
void DrawPaths ( ) {
SetWidthsOfArrowheads ( ) ;
CreateLongestNudgedSegments ( ) ;
FindFreeSpaceInDirection ( PathVisibilityGraph . Edges . Cast < AxisEdge > ( ) ) ;
MoveLongestSegsIdealPositionsInsideFeasibleIntervals ( ) ;
PositionShiftedEdges ( ) ;
}
void SetWidthsOfArrowheads ( ) {
foreach ( Path edgePath in Paths )
SetWidthsOfArrowheadsForEdge ( edgePath ) ;
}
static void SetWidthsOfArrowheadsForEdge ( Path path ) {
var edgeGeom = path . EdgeGeometry ;
if ( edgeGeom . TargetArrowhead ! = null ) {
PathEdge pathEdge = path . LastEdge ;
pathEdge . Width = Math . Max ( edgeGeom . TargetArrowhead . Width , pathEdge . Width ) ;
}
if ( edgeGeom . SourceArrowhead ! = null ) {
PathEdge pathEdge = path . FirstEdge ;
pathEdge . Width = Math . Max ( edgeGeom . SourceArrowhead . Width , pathEdge . Width ) ;
}
}
internal double EdgeSeparation { get ; set ; }
void PositionShiftedEdges ( ) {
//we are using 2*cornerFitRadius for the minimal edge separation
Solver = new UniformOneDimensionalSolver ( EdgeSeparation ) ;
foreach ( var segment in LongestNudgedSegs )
CreateVariablesOfLongestSegment ( segment ) ;
CreateConstraintsOfTheOrder ( ) ;
CreateConstraintsBetweenLongestSegments ( ) ;
Solver . Solve ( ) ;
ShiftPathEdges ( ) ;
}
void MoveLongestSegsIdealPositionsInsideFeasibleIntervals ( ) {
foreach ( var seg in LongestNudgedSegs )
MoveLongestSegIdealPositionsInsideFeasibleInterval ( seg ) ;
}
static void MoveLongestSegIdealPositionsInsideFeasibleInterval ( LongestNudgedSegment seg ) {
if ( seg . IsFixed ) return ;
var leftBound = seg . GetLeftBound ( ) ;
var rightBound = seg . GetRightBound ( ) ;
if ( seg . IdealPosition < leftBound )
seg . IdealPosition = leftBound ;
else if ( seg . IdealPosition > rightBound )
seg . IdealPosition = rightBound ;
}
void ShiftPathEdges ( ) {
foreach ( var path in Paths )
path . PathPoints = GetShiftedPoints ( path ) . ToArray ( ) ;
}
IEnumerable < Point > GetShiftedPoints ( Path path ) {
return RemoveSwitchbacksAndMiddlePoints ( GetShiftedPointsSimple ( path ) ) ;
}
/// <summary>
/// sometimes we have very small mistakes in the positions that have to be fixed
/// </summary>
/// <returns></returns>
static Point Rectilinearise ( Point a , Point b ) {
#if SHARPKIT //https://code.google.com/p/sharpkit/issues/detail?id=369 there are no structs in js
b = b . Clone ( ) ;
#endif
if ( a . X ! = b . X & & a . Y ! = b . Y ) {
var dx = Math . Abs ( a . X - b . X ) ;
var dy = Math . Abs ( a . Y - b . Y ) ;
if ( dx < dy )
b . X = a . X ;
else
b . Y = a . Y ;
}
return b ;
}
IEnumerable < Point > GetShiftedPointsSimple ( Path path ) {
var edge = path . FirstEdge ;
yield return ShiftedPoint ( edge . Source , edge . LongestNudgedSegment ) ;
foreach ( var e in path . PathEdges )
yield return ShiftedEdgePositionOfTarget ( e ) ;
}
Point ShiftedEdgePositionOfTarget ( PathEdge e ) {
return e . LongestNudgedSegment ! = null | | e . Next = = null
? ShiftedPoint ( e . Target , e . LongestNudgedSegment )
: ShiftedPoint ( e . Next . Source , e . Next . LongestNudgedSegment ) ;
}
Point ShiftedPoint ( Point point , LongestNudgedSegment segment ) {
if ( segment = = null )
return point ;
var t = Solver . GetVariablePosition ( segment . Id ) ;
return NudgingDirection = = Directions . North ? new Point ( t , point . Y ) : new Point ( point . X , - t ) ;
}
#region debug
2020-06-04 01:36:55 +01:00
// #if TEST_MSAGL
// internal static void ShowPathsFromPoints(IEnumerable<Path> paths, IEnumerable<Polyline> enumerable) {
// var dd = new List<DebugCurve>();
// if (enumerable != null)
// dd.AddRange(GetObstacleBoundaries(enumerable, "grey"));
// int i = 0;
// foreach (var p in paths)
// dd.AddRange(PathDebugCurvesFromPoints(p, DebugCurve.Colors[Math.Min(DebugCurve.Colors.Length, i++)]));
// LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(dd);
// }
//
// static IEnumerable<DebugCurve> PathDebugCurvesFromPoints(Path path, string color) {
// const double startWidth = 0.01;
// const double endWidth = 3;
//
// var pts = path.PathPoints.ToArray();
// double delta = (endWidth - startWidth) / (pts.Length - 1);
// for (int i = 0; i < pts.Length - 1; i++)
// yield return new DebugCurve(startWidth + delta * i, color, new LineSegment(pts[i], pts[i + 1]));
// }
//
// internal static void ShowParamPaths( Point s, Point e, params Path[] paths ) {
// ShowOrderedPaths(null,paths,s,e);
// }
//
// // ReSharper disable UnusedMember.Local
// internal static void ShowOrderedPaths(IEnumerable<Polyline> obstacles, IEnumerable<Path> paths, Point s, Point e) {
// // ReSharper restore UnusedMember.Local
// string[] colors = { "red", "green", "blue", "violet", "rose", "black" };
//
// const double startWidth = 0.001;
// const double endWidth = 0.1;
// var dd = new List<DebugCurve>();
// if (obstacles != null)
// dd.AddRange(GetObstacleBoundaries(obstacles, "grey"));
// int i = 0;
// foreach (var path in paths)
// dd.AddRange(GetTestPathAsDebugCurve(startWidth, endWidth, colors[Math.Min(colors.Length - 1, i++)], path));
//
// var ell = new DebugCurve(1, "black", new Ellipse(0.01, 0.01, s));
// dd.Add(ell);
// dd.Add(new DebugCurve(1, "black", new Ellipse(0.02, 0.02, e)));
// LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(dd.Concat(GetObstacleBoundaries(obstacles, "lightblue")));
// }
//
// static IEnumerable<DebugCurve> GetTestPathAsDebugCurve(double startWidth, double endWidth, string color, Path path) {
// if (path.PathEdges.Count() > 0) {
// int count = path.PathEdges.Count();
//
// double deltaW = count > 1 ? (endWidth - startWidth)/(count - 1) : 1;
// //if count ==1 the value of deltaW does not matter
// int i = 0;
// foreach (var e in path.PathEdges)
// yield return
// new DebugCurve(150, startWidth + deltaW*(i++), color, new LineSegment(e.Source, e.Target));
// }else {
// int count = path.PathPoints.Count();
// var pts = path.PathPoints.ToArray();
//
// var deltaW = count > 1 ? (endWidth - startWidth) / (count - 1) : 1;
// //if count ==1 the value of deltaW does not matter
// for (int i = 0; i < count - 1;i++ )
// yield return new DebugCurve(150, startWidth+deltaW*i, color, new LineSegment(pts[i], pts[i+1]));
// }
// }
//
// internal static IEnumerable<DebugCurve> GetTestEdgePathAsDebugCurves(double startWidth, double endWidth, string color, Path path) {
// int count = path.PathPoints.Count();
//
// double deltaW = count > 1 ? (endWidth - startWidth) / (count - 1) : 1; //if count ==1 the value of deltaW does not matter
// var points = path.PathPoints.ToArray();
// for (int i = 0; i < points.Length - 1; i++)
// yield return new DebugCurve(125, startWidth + deltaW * i, color, new LineSegment(points[i], points[i + 1]));
// }
//
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// static IEnumerable<DebugCurve> GetEdgePathFromPathEdgesAsDebugCurves(double startWidth, double endWidth, string color, Path path) {
// var points = path.PathPoints.ToArray();
//
// int count = points.Length;
//
// double deltaW = count > 1 ? (endWidth - startWidth) / (count - 1) : 1; //if count ==1 the value of deltaW does not matter
// for (int i = 0; i < points.Length - 1; i++)
// yield return new DebugCurve(120, startWidth + deltaW * i, color, new LineSegment(points[i], points[i + 1]));
// }
// // ReSharper disable UnusedMember.Local
//
// static internal void ShowEdgePaths(IEnumerable<Polyline> obstacles, IEnumerable<Path> edgePaths) {
// // ReSharper restore UnusedMember.Local
// List<DebugCurve> debCurves = GetDebCurvesOfPaths(obstacles, edgePaths);
//
// LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(debCurves);
// }
//
// internal static List<DebugCurve> GetDebCurvesOfPaths(IEnumerable<Polyline> enumerable, IEnumerable<Path> edgePaths) {
// var debCurves = GetObstacleBoundaries(enumerable, "black");
// int i = 0;
//
// foreach (var edgePath in edgePaths)
// debCurves.AddRange(GetTestEdgePathAsDebugCurves(0.2, 4, DebugCurve.Colors[(i++) % DebugCurve.Colors.Length], edgePath));
// return debCurves;
// }
//
// internal static void ShowPathsInLoop(IEnumerable<Polyline> enumerable, IEnumerable<Path> edgePaths, Point point) {
// foreach (var edgePath in edgePaths.Where(path=>(path.PathPoints.First()-point).Length<1 ||(path.PathPoints.Last()-point).Length<1 )) {
// var debCurves = GetObstacleBoundaries(enumerable, "black");
// debCurves.AddRange(GetTestEdgePathAsDebugCurves(0.1, 4, "red", edgePath));
// LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(debCurves);
// }
// }
//
//
// // ReSharper disable UnusedMember.Local
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// void ShowLongSegsWithIdealPositions(Directions dir) {
// // ReSharper restore UnusedMember.Local
// var debCurves = GetObstacleBoundaries(Obstacles, "black");
// int i = 0;
//
// debCurves.AddRange(LongestNudgedSegs.Select(ls => DebugCurveOfLongSeg(ls, DebugCurve.Colors[i++ % DebugCurve.Colors.Length], dir)));
//
// DebugCurveCollection.WriteToFile(debCurves, "c:/tmp/longSegs");
//
// LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(debCurves);
// }
//
// static DebugCurve DebugCurveOfLongSeg(LongestNudgedSegment ls, string s, Directions dir) {
// return new DebugCurve(1, s, LineSegOfLongestSeg(ls, dir));
// }
//
// static ICurve LineSegOfLongestSeg(LongestNudgedSegment ls, Directions dir) {
// var projectionToDir = dir == Directions.East ? (PointProjection)(p => p.X) : (p => p.Y);
// var min = Double.PositiveInfinity;
// var max = Double.NegativeInfinity;
// foreach (var edge in ls.Edges) {
// UpdateMinMaxWithPoint(ref min, ref max, projectionToDir, edge.Source);
// UpdateMinMaxWithPoint(ref min, ref max, projectionToDir, edge.Target);
// }
// return dir == Directions.East
// ? new LineSegment(min, -ls.IdealPosition, max, -ls.IdealPosition)
// : new LineSegment(ls.IdealPosition, min, ls.IdealPosition, max);
// }
//
// static void UpdateMinMaxWithPoint(ref double min, ref double max, PointProjection projectionToDir, Point point) {
// double p = projectionToDir(point);
// if (min > p)
// min = p;
// if (max < p)
// max = p;
// }
//
//
// // ReSharper disable UnusedMember.Local
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// void ShowPathsDebug(IEnumerable<Path> edgePaths) {
// var debCurves = GetObstacleBoundaries(Obstacles, "black");
// int i = 0;
//
// foreach (var edgePath in edgePaths)
// debCurves.AddRange(GetEdgePathFromPathEdgesAsDebugCurves(0.01, 0.4, DebugCurve.Colors[(i++) % DebugCurve.Colors.Length], edgePath));
//
// LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(debCurves);
// }
//
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// static IEnumerable<DebugCurve> PathDebugCurves(Path path, string color) {
// var d = path.PathEdges.Select(e => new DebugCurve(70, 0.5, color, new LineSegment(e.Source, e.Target)));
// return d.Concat(MarkPathVerts(path));
// }
//
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// private static IEnumerable<DebugCurve> MarkPathVerts(Path path) {
// bool first = true;
// var p = new Point();
// foreach (var p0 in path.PathPoints) {
// if (first) {
// yield return new DebugCurve(200, 1, "violet", CurveFactory.CreateDiamond(5, 5, p0));
// first = false;
// } else
// yield return new DebugCurve(100, 0.5, "brown", CurveFactory.CreateEllipse(1.5, 1.5, p0));
// p = p0;
// }
// yield return new DebugCurve(200, 1, "green", CurveFactory.CreateDiamond(3, 3, p));
// }
//
// static internal IEnumerable<DebugCurve> PathDebugCurvesFromPoint(Path path) {
// var l = new List<Point>(path.PathPoints);
// for (int i = 0; i < l.Count - 1; i++)
// yield return new DebugCurve(4, "red", new LineSegment(l[i], l[i + 1]));
// }
// //
// // ReSharper disable UnusedMember.Local
// // void ShowEdgesOfEdgePath(Path path){
// // ReSharper restore UnusedMember.Local
// // string[] colors = {"red", "brown", "purple"};
// // const double w0 = 1;
// // const double w1 = 3;
// // double dw = (w1 - w0)/path.OrientedSubpaths.Count;
// // int i = 0;
// // var dc = new List<DebugCurve>();
// // foreach (var s in path.OrientedSubpaths){
// // dc.AddRange(SubpathDebugCurves(w0 + dw*i, colors[Math.Min(i++, colors.Length - 1)], s));
// // }
// // LayoutAlgorithmSettings.ShowDebugCurves(dc.ToArray());
// // }
// //
// // static IEnumerable<DebugCurve> SubpathDebugCurves(double w, string color, OrientedSubpath subpath){
// // return subpath.LinkedPath.Select(e => new DebugCurve(w, color, new LineSegment(e.Source.Point, e.Target.Point)));
// // }
//
//
// static internal List<DebugCurve> GetObstacleBoundaries(IEnumerable<Polyline> obstacles, string color) {
// var debugCurves = new List<DebugCurve>();
// if (obstacles != null)
// debugCurves.AddRange(obstacles.Select(poly => new DebugCurve(50, 0.3, color, poly)));
// return debugCurves;
// }
// #endif
2020-04-14 00:42:04 +01:00
#endregion
void CreateConstraintsBetweenLongestSegments ( ) {
foreach ( var segment in LongestNudgedSegs )
CreateConstraintsBetweenLongestSegmentsForSegment ( segment ) ;
}
void CreateConstraintsBetweenLongestSegmentsForSegment ( LongestNudgedSegment segment ) {
var rightNeighbors = new Set < LongestNudgedSegment > ( ) ;
foreach ( var pathEdge in segment . Edges ) {
var axisEdge = pathEdge . AxisEdge ;
if ( axisEdge ! = null )
foreach ( var rightNeiAxisEdge in axisEdge . RightNeighbors )
foreach ( var longSeg in rightNeiAxisEdge . LongestNudgedSegments )
rightNeighbors . Insert ( longSeg ) ;
}
foreach ( var seg in rightNeighbors )
ConstraintTwoLongestSegs ( segment , seg ) ;
}
void CreateConstraintsOfTheOrder ( ) {
foreach ( var kv in PathOrders )
if ( ParallelToDirection ( kv . Key , NudgingDirection ) )
CreateConstraintsOfThePathOrder ( kv . Value ) ;
}
static bool ParallelToDirection ( VisibilityEdge edge , Directions direction ) {
switch ( direction ) {
case Directions . North :
case Directions . South :
return ApproximateComparer . Close ( edge . SourcePoint . X , edge . TargetPoint . X ) ;
default :
return ApproximateComparer . Close ( edge . SourcePoint . Y , edge . TargetPoint . Y ) ;
}
}
void CreateConstraintsOfThePathOrder ( IEnumerable < PathEdge > pathOrder ) {
PathEdge prevEdge = null ;
foreach ( var pathEdge in pathOrder . Where ( p = > p . LongestNudgedSegment ! = null ) ) {
if ( prevEdge ! = null )
ConstraintTwoLongestSegs ( prevEdge . LongestNudgedSegment , pathEdge . LongestNudgedSegment ) ;
prevEdge = pathEdge ;
}
}
void ConstraintTwoLongestSegs ( LongestNudgedSegment prevSeg , LongestNudgedSegment seg ) {
if ( ! prevSeg . IsFixed | | ! seg . IsFixed )
Solver . AddConstraint ( prevSeg . Id , seg . Id ) ;
}
UniformOneDimensionalSolver Solver { get ; set ; }
void CreateVariablesOfLongestSegment ( LongestNudgedSegment segment ) {
if ( ! segment . IsFixed ) {
var leftBound = segment . GetLeftBound ( ) ;
var rightBound = segment . GetRightBound ( ) ;
if ( leftBound > = rightBound ) { //don't move the segment from the way it was generated
Solver . AddFixedVariable ( segment . Id , SegmentPosition ( segment , NudgingDirection ) ) ;
segment . IsFixed = true ;
} else {
Solver . AddVariable ( segment . Id , SegmentPosition ( segment , NudgingDirection ) , segment . IdealPosition , segment . Width ) ;
// Debug.Assert(leftBound + Curve.DistanceEpsilon < rightBound); //this assert does not hold for overlaps
if ( leftBound ! = Double . NegativeInfinity )
Solver . SetLowBound ( leftBound , segment . Id ) ;
if ( rightBound ! = Double . PositiveInfinity )
Solver . SetUpperBound ( segment . Id , rightBound ) ;
}
} else
Solver . AddFixedVariable ( segment . Id , SegmentPosition ( segment , NudgingDirection ) ) ;
}
static double SegmentPosition ( SegmentBase segment , Directions direction ) {
return direction = = Directions . North ? segment . Start . X : - segment . Start . Y ;
}
2020-06-04 01:36:55 +01:00
// #if TEST_MSAGL
// // ReSharper disable UnusedMember.Local
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// void ShowSegmentBounds(LongestNudgedSegment segment) {
// // ReSharper restore UnusedMember.Local
// var dd = GetObstacleBoundaries(Obstacles, "black");
// var segtop = segment.Edges.Max(e => Math.Max(e.Source.Y, e.Target.Y));
// var segbottom = segment.Edges.Min(e => Math.Min(e.Source.Y, e.Target.Y));
// var segx = segment.Start.X;
// var seg = new DebugCurve(80, 1, "brown", new LineSegment(new Point(segx, segbottom), new Point(segx, segtop)));
//
// var leftbound = new DebugCurve(80, 1.0, "red", new LineSegment(new Point(segment.GetLeftBound(), segbottom),
// new Point(segment.GetLeftBound(), segtop)));
// var rightbound = new DebugCurve(80, 1, "green", new LineSegment(new Point(segment.GetRightBound(), segbottom),
// new Point(segment.GetRightBound(), segtop)));
// LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(dd.Concat(new[] { seg, leftbound, rightbound }));
// }
// // ReSharper disable UnusedMember.Local
// [SuppressMessage("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
// void ShowSegment(LongestNudgedSegment segment) {
// // ReSharper restore UnusedMember.Local
// var dd = GetObstacleBoundaries(Obstacles, "black");
// var segtop = segment.Edges.Max(e => Math.Max(e.Source.Y, e.Target.Y));
// var segbottom = segment.Edges.Min(e => Math.Min(e.Source.Y, e.Target.Y));
// var segx = segment.Start.X;
// var seg = new DebugCurve(80, 1, "brown", new LineSegment(new Point(segx, segbottom), new Point(segx, segtop)));
//
// LayoutAlgorithmSettings.ShowDebugCurvesEnumeration(dd.Concat(new[] { seg }));
//
// }
// #endif
2020-04-14 00:42:04 +01:00
List < LongestNudgedSegment > LongestNudgedSegs { get ; set ; }
Dictionary < AxisEdge , List < PathEdge > > PathOrders { get ; set ; }
/// <summary>
/// maps each path to the pair of obstacles; the first element of the pair is
/// where the path starts and the second where the path ends
/// </summary>
Dictionary < Path , Tuple < Polyline , Polyline > > PathToObstacles { get ; set ; }
void FindFreeSpaceInDirection ( IEnumerable < AxisEdge > axisEdges ) {
BoundAxisEdgesByRectsKnownInAdvance ( ) ;
var freeSpaceFinder = new FreeSpaceFinder ( NudgingDirection , Obstacles ,
axisEdgesToObstaclesTheyOriginatedFrom , PathOrders , axisEdges ) ;
freeSpaceFinder . FindFreeSpace ( ) ;
}
void BoundAxisEdgesByRectsKnownInAdvance ( ) {
foreach ( var path in Paths ) {
if ( HasGroups )
BoundPathByMinCommonAncestors ( path ) ;
BoundAxisEdgesAdjacentToSourceAndTargetOnEdge ( path ) ;
}
}
void BoundPathByMinCommonAncestors ( Path path ) {
foreach ( var rect in GetMinCommonAncestors ( path . EdgeGeometry ) . Select ( sh = > sh . BoundingBox ) )
foreach (
var edge in
path . PathEdges . Select ( e = > e . AxisEdge ) . Where (
axisEdge = > axisEdge . Direction = = NudgingDirection )
)
BoundAxisEdgeByRect ( rect , 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 ) ) ) ;
}
/// <summary>
///
/// </summary>
protected Dictionary < Port , Shape > PortToShapes { get ; private set ; }
Set < Shape > AncestorsForPort ( Port port ) {
Shape shape ;
if ( PortToShapes . TryGetValue ( port , out shape ) ) {
return AncestorsSets [ shape ] ;
}
// This is a FreePort or Waypoint; return all spatial parents.
return new Set < Shape > ( HierarchyOfGroups . AllHitItems ( new Rectangle ( port . Location , port . Location ) , null ) ) ;
}
void BoundAxisEdgeAdjacentToObstaclePort ( Port port , AxisEdge axisEdge ) {
if ( port is WaypointPort | | ( port . Curve = = null & & port . PortEntry = = null ) )
BoundAxisByPoint ( port . Location , axisEdge ) ;
else if ( port . PortEntry = = null ) {
if ( port . Curve . BoundingBox . Contains ( port . Location ) )
BoundAxisEdgeByRect ( port . Curve . BoundingBox , axisEdge ) ;
} else {
var portEntry = port . PortEntry as PortEntryOnCurve ;
if ( portEntry ! = null ) {
Rectangle rect ;
if ( FindPortEntryRectCrossingAxisEdge ( portEntry , axisEdge , out rect ) )
BoundAxisEdgeByRect ( rect , axisEdge ) ;
}
}
}
void BoundAxisByPoint ( Point point , AxisEdge axisEdge ) {
if ( axisEdge ! = null & & axisEdge . Direction = = NudgingDirection )
if ( NudgingDirection = = Directions . North ) {
axisEdge . BoundFromLeft ( point . X ) ;
axisEdge . BoundFromRight ( point . X ) ;
} else {
axisEdge . BoundFromLeft ( - point . Y ) ;
axisEdge . BoundFromRight ( - point . Y ) ;
}
}
static bool FindPortEntryRectCrossingAxisEdge ( PortEntryOnCurve portEntry , AxisEdge axisEdge , out Rectangle rect ) {
var ar = new Rectangle ( axisEdge . SourcePoint , axisEdge . TargetPoint ) ;
foreach ( Rectangle r in portEntry . AllowedRectangles ) {
if ( r . Intersects ( ar ) ) {
rect = r ;
return true ;
}
}
rect = Rectangle . CreateAnEmptyBox ( ) ;
return false ;
}
void BoundAxisEdgesAdjacentToSourceAndTargetOnEdge ( Path path ) {
BoundAxisEdgeAdjacentToObstaclePort ( path . EdgeGeometry . SourcePort , path . FirstEdge . AxisEdge ) ;
BoundAxisEdgeAdjacentToObstaclePort ( path . EdgeGeometry . TargetPort , path . LastEdge . AxisEdge ) ;
}
void BoundAxisEdgeByRect ( Rectangle rectangle , AxisEdge axisEdge ) {
if ( axisEdge ! = null & & axisEdge . Direction = = NudgingDirection )
if ( NudgingDirection = = Directions . North ) {
axisEdge . BoundFromLeft ( rectangle . Left ) ;
axisEdge . BoundFromRight ( rectangle . Right ) ;
} else {
axisEdge . BoundFromLeft ( - rectangle . Top ) ;
axisEdge . BoundFromRight ( - rectangle . Bottom ) ;
}
}
void CreateLongestNudgedSegments ( ) {
var projectionToPerp =
NudgingDirection = = Directions . East ? ( PointProjection ) FreeSpaceFinder . MinusY : FreeSpaceFinder . X ;
LongestNudgedSegs = new List < LongestNudgedSegment > ( ) ;
foreach ( var path in Paths )
CreateLongestNudgedSegmentsForPath ( path , projectionToPerp ) ;
}
void CreateLongestNudgedSegmentsForPath ( Path path , PointProjection projectionToPerp ) {
//ShowEdgesOfEdgePath(path);
GoOverPathAndCreateLongSegs ( path ) ;
CalculateIdealPositionsForLongestSegs ( path , projectionToPerp ) ;
}
static void CalculateIdealPositionsForLongestSegs ( Path path , PointProjection projectionToPerp ) {
LongestNudgedSegment currentLongSeg = null ;
LongestNudgedSegment ret = null ;
double prevOffset = projectionToPerp ( path . Start ) ;
foreach ( var edge in path . PathEdges ) {
if ( edge . LongestNudgedSegment ! = null ) {
currentLongSeg = edge . LongestNudgedSegment ;
if ( ret ! = null ) {
double t ;
SetIdealPositionForSeg ( ret , t = projectionToPerp ( ret . Start ) , prevOffset ,
projectionToPerp ( currentLongSeg . Start ) ) ;
prevOffset = t ;
ret = null ;
}
} else if ( currentLongSeg ! = null ) {
ret = currentLongSeg ;
currentLongSeg = null ;
}
}
if ( ret ! = null )
SetIdealPositionForSeg ( ret , projectionToPerp ( ret . Start ) , prevOffset , projectionToPerp ( path . End ) ) ;
else if ( currentLongSeg ! = null )
currentLongSeg . IdealPosition = projectionToPerp ( currentLongSeg . Start ) ;
}
static void SetIdealPositionForSeg ( LongestNudgedSegment segment , double segPosition , double offset0 , double offset1 ) {
var max = Math . Max ( offset0 , offset1 ) ;
var min = Math . Min ( offset0 , offset1 ) ;
if ( min + ApproximateComparer . DistanceEpsilon < segPosition )
if ( segPosition < max )
segment . IdealPosition = 0.5 * ( max + min ) ;
else
segment . IdealPosition = max ;
else
segment . IdealPosition = min ;
}
void GoOverPathAndCreateLongSegs ( Path path ) {
LongestNudgedSegment currentLongestSeg = null ;
var oppositeDir = CompassVector . OppositeDir ( NudgingDirection ) ;
foreach ( var edge in path . PathEdges ) {
var edgeDir = edge . Direction ;
if ( edgeDir = = NudgingDirection | | edgeDir = = oppositeDir ) {
if ( currentLongestSeg = = null )
#if SHARPKIT //https://code.google.com/p/sharpkit/issues/detail?id=368
{
edge . LongestNudgedSegment = currentLongestSeg = new LongestNudgedSegment ( LongestNudgedSegs . Count ) ;
LongestNudgedSegs . Add ( edge . LongestNudgedSegment ) ;
}
#else
LongestNudgedSegs . Add (
edge . LongestNudgedSegment =
currentLongestSeg = new LongestNudgedSegment ( LongestNudgedSegs . Count ) ) ;
#endif
else
edge . LongestNudgedSegment = currentLongestSeg ;
if ( edge . IsFixed )
currentLongestSeg . IsFixed = true ;
} else {
//the edge is perpendicular to "direction"
edge . LongestNudgedSegment = null ;
currentLongestSeg = null ;
}
}
}
static IEnumerable < Point > BuildPolylineForPath ( Path path ) {
#if SHARPKIT //https://code.google.com/p/sharpkit/issues/detail?id=369
var points = path . PathPoints . Select ( p = > p . Clone ( ) ) . ToArray ( ) ;
#else
var points = path . PathPoints . ToArray ( ) ;
#endif
ExtendPolylineToPorts ( ref points , path ) ;
for ( int i = 0 ; i < points . Length - 1 ; i + + )
Debug . Assert ( CompassVector . IsPureDirection ( points [ i ] , points [ i + 1 ] ) ) ;
return points ;
}
static void ExtendPolylineToPorts ( ref Point [ ] points , Path path ) {
ExtendPolylineToSourcePort ( ref points , path . EdgeGeometry . SourcePort . Location ) ;
ExtendPolylineToTargetPort ( ref points , path . EdgeGeometry . TargetPort . Location ) ;
// In some overlapped cases where the source or target vertex used for the path
// coincides with the target or source port location, we can end up with a single-point
// path. In that case, we just force a straightline path.
if ( points . Length < 2 ) {
points = new Point [ 2 ] ;
points [ 0 ] = path . EdgeGeometry . SourcePort . Location ;
points [ 1 ] = path . EdgeGeometry . TargetPort . Location ;
}
}
static void ExtendPolylineToTargetPort ( ref Point [ ] points , Point location ) {
int n = points . Length - 1 ;
var dir = CompassVector . VectorDirection ( points [ n - 1 ] , points [ n ] ) ;
if ( ProjectionsAreClose ( points [ n - 1 ] , dir , location ) ) {
//it might be that the last point on polyline is at the port already
//then we just drop the last point
points = points . Take ( n ) . ToArray ( ) ;
return ;
}
if ( dir = = Directions . East | | dir = = Directions . West )
points [ n ] . X = location . X ;
else
points [ n ] . Y = location . Y ;
}
static bool ProjectionsAreClose ( Point a , Directions dir , Point b ) {
if ( dir = = Directions . East | | dir = = Directions . West )
return ApproximateComparer . Close ( a . X , b . X ) ;
return ApproximateComparer . Close ( a . Y , b . Y ) ;
}
static void ExtendPolylineToSourcePort ( ref Point [ ] points , Point location ) {
var dir = CompassVector . VectorDirection ( points [ 0 ] , points [ 1 ] ) ;
if ( ProjectionsAreClose ( points [ 1 ] , dir , location ) ) {
//it might be that the second point on polyline is at the port already
//then we just drop the first point
points = points . Skip ( 1 ) . ToArray ( ) ;
return ;
}
if ( dir = = Directions . East | | dir = = Directions . West )
points [ 0 ] . X = location . X ;
else
points [ 0 ] . Y = location . Y ;
}
static IEnumerable < Point > RemoveSwitchbacksAndMiddlePoints ( IEnumerable < Point > points ) {
var en = points . GetEnumerator ( ) ;
en . MoveNext ( ) ;
var a = en . Current ;
yield return a ;
en . MoveNext ( ) ;
var b = en . Current ;
var prevDir = ( b - a ) . CompassDirection ;
while ( en . MoveNext ( ) ) {
var dir = ( en . Current - b ) . CompassDirection ;
if ( dir = = prevDir | | CompassVector . OppositeDir ( dir ) = = prevDir | | dir = = Directions . None ) //we continue walking along the same straight line, maybe going backwards!
b = en . Current ;
else {
if ( ! ApproximateComparer . Close ( a , b ) ) { //make sure that we are not returning the same point twice
yield return a = Rectilinearise ( a , b ) ;
}
b = en . Current ;
prevDir = dir ;
}
}
if ( ! ApproximateComparer . Close ( a , b ) )
yield return Rectilinearise ( a , b ) ;
}
/// <summary>
/// this function defines the final path coordinates
/// </summary>
/// <param name="paths">the set of paths, point sequences</param>
/// <param name="cornerFitRadius">the radius of the arc inscribed into the path corners</param>
/// <param name="paddedObstacles">an enumeration of padded obstacles</param>
/// <param name="ancestorsSets"></param>
/// <param name="removeStaircases"></param>
/// <returns>the mapping of the path to its modified path</returns>
internal static void NudgePaths ( IEnumerable < Path > paths , double cornerFitRadius , IEnumerable < Polyline > paddedObstacles , Dictionary < Shape , Set < Shape > > ancestorsSets , bool removeStaircases ) {
if ( ! paths . Any ( ) )
return ;
var nudger = new Nudger ( paths , cornerFitRadius , paddedObstacles , ancestorsSets ) ;
nudger . Calculate ( Directions . North , true ) ;
nudger . Calculate ( Directions . East , false ) ;
nudger . Calculate ( Directions . North , false ) ;
if ( removeStaircases )
nudger . RemoveStaircases ( ) ;
foreach ( var path in paths )
path . EdgeGeometry . Curve = new Polyline ( BuildPolylineForPath ( path ) ) ;
}
void RemoveStaircases ( ) {
StaircaseRemover . RemoveStaircases ( Paths , HierarchyOfObstacles ) ;
}
/ *
void RemoveStaircasesFromPath ( Path path ) {
var points = ( Point [ ] ) path . PathPoints ;
if ( points . Length < = 4 ) return ;
int i = FindStaircase ( points ) ;
if ( i = = - 1 ) return ;
var linkedList = new LinkedList < Point > ( points ) ;
var node = linkedList . First ;
for ( int j = 0 ; j < i ; j + + )
node = node . Next ; //getting to the i-th node
RemoveStaircaseOnNode ( node ) ;
node = node . Next ;
while ( true ) {
node = FindStaircaseAfterNode ( node ) ;
if ( node = = null ) break ;
RemoveStaircaseOnNode ( node ) ;
node = node . Next ;
}
}
LinkedListNode < Point > FindStaircaseAfterNode ( LinkedListNode < Point > n ) {
do {
var nn = n . Next ;
var nnn = nn . Next ;
var nnnn = nnn . Next ;
if ( nnn . Next = = null )
return null ;
if ( IsStaircase ( n . Value , nn . Value , nnn . Value , nnnn . Value ) )
return n ;
n = nn ;
} while ( true ) ;
}
bool IsStaircase ( Point a , Point b , Point c , Point d ) {
return false ;
}
void RemoveStaircaseOnNode ( LinkedListNode < Point > node ) {
throw new NotImplementedException ( ) ;
}
int FindStaircase ( Point [ ] points ) {
throw new NotImplementedException ( ) ;
}
* /
internal static Dictionary < Port , Shape > MapPortsToShapes ( IEnumerable < Shape > listOfShapes ) {
var portToShapes = new Dictionary < Port , Shape > ( ) ;
foreach ( Shape shape in listOfShapes )
foreach ( Port port in shape . Ports )
portToShapes [ port ] = shape ;
return portToShapes ;
}
}
}