dbc522a224
Modified weapon scripts to eliminate specialized projectile behavior - allows charged weapons to have projectiles and modify weapon stats when charged Added machine gun weapon & VFX Moved third party code to Plugins folder to improve compile times
994 lines
44 KiB
C#
994 lines
44 KiB
C#
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
|
|
// #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
|
|
#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;
|
|
}
|
|
|
|
// #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
|
|
|
|
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;
|
|
}
|
|
}
|
|
}
|