private bool IsPolylineRectangle() { if (this.PaddedPolyline.PolylinePoints.Count() != 4) { return(false); } var ppt = this.PaddedPolyline.StartPoint; var nextPpt = ppt.NextOnPolyline; var dir = CompassVector.DirectionsFromPointToPoint(ppt.Point, nextPpt.Point); if (!CompassVector.IsPureDirection(dir)) { return(false); } do { ppt = nextPpt; nextPpt = ppt.NextOnPolyline; var nextDir = CompassVector.DirectionsFromPointToPoint(ppt.Point, nextPpt.Point); // We know the polyline is clockwise. if (nextDir != CompassVector.RotateRight(dir)) { return(false); } dir = nextDir; } while (ppt != this.PaddedPolyline.StartPoint); return(true); }
internal static Directions GetPureDirection(Point a, Point b) { Assert_Rounded(a); Assert_Rounded(b); Directions dir = GetDirections(a, b); Debug.Assert(CompassVector.IsPureDirection(dir), "Impure direction found"); return(dir); }
internal void SetNewNext(Point p) { var nv = new LinkedPoint(p); var tmp = Next; Next = nv; nv.Next = tmp; Debug.Assert(CompassVector.IsPureDirection(Point, Next.Point)); }
/// <summary> /// /// </summary> /// <param name="direction"></param> /// <param name="obstacles"></param> /// <param name="axisEdgesToObstaclesTheyOriginatedFrom"></param> /// <param name="pathOrders"></param> /// <param name="axisEdges">edges to find the empty space around</param> internal FreeSpaceFinder(Directions direction, IEnumerable <Polyline> obstacles, Dictionary <AxisEdge, Polyline> axisEdgesToObstaclesTheyOriginatedFrom, Dictionary <AxisEdge, List <PathEdge> > pathOrders, IEnumerable <AxisEdge> axisEdges) : base(obstacles, new CompassVector(direction).ToPoint()) { DirectionPerp = new CompassVector(direction).Right.ToPoint(); PathOrders = pathOrders; xProjection = direction == Directions.North ? (PointProjection)X : MinusY; #if SHARPKIT //https://code.google.com/p/sharpkit/issues/detail?id=301 edgeContainersTree = new RbTree <AxisEdgesContainer>(new FreeSpaceFinderComparer(this)); #else edgeContainersTree = new RbTree <AxisEdgesContainer>(this); #endif SweepPole = CompassVector.VectorDirection(SweepDirection); Debug.Assert(CompassVector.IsPureDirection(SweepPole)); AxisEdges = axisEdges; AxisEdgesToObstaclesTheyOriginatedFrom = axisEdgesToObstaclesTheyOriginatedFrom; }
internal void ExtendEdgeChain(VisibilityVertex startVertex, Rectangle limitRect, LineSegment maxVisibilitySegment, PointAndCrossingsList pacList, bool isOverlapped) { var dir = PointComparer.GetDirections(maxVisibilitySegment.Start, maxVisibilitySegment.End); if (dir == Directions.None) { return; } Debug.Assert(CompassVector.IsPureDirection(dir), "impure max visibility segment"); // Shoot the edge chain out to the shorter of max visibility or intersection with the limitrect. StaticGraphUtility.Assert(PointComparer.Equal(maxVisibilitySegment.Start, startVertex.Point) || (PointComparer.GetPureDirection(maxVisibilitySegment.Start, startVertex.Point) == dir) , "Inconsistent direction found", ObstacleTree, VisGraph); double oppositeFarBound = StaticGraphUtility.GetRectangleBound(limitRect, dir); Point maxDesiredSplicePoint = StaticGraphUtility.IsVertical(dir) ? ApproximateComparer.Round(new Point(startVertex.Point.X, oppositeFarBound)) : ApproximateComparer.Round(new Point(oppositeFarBound, startVertex.Point.Y)); if (PointComparer.Equal(maxDesiredSplicePoint, startVertex.Point)) { // Nothing to do. return; } if (PointComparer.GetPureDirection(startVertex.Point, maxDesiredSplicePoint) != dir) { // It's in the opposite direction, so no need to do anything. return; } // If maxDesiredSplicePoint is shorter, create a new shorter segment. We have to pass both segments // through to the worker function so it knows whether it can go past maxDesiredSegment (which may be limited // by limitRect). var maxDesiredSegment = maxVisibilitySegment; if (PointComparer.GetDirections(maxDesiredSplicePoint, maxDesiredSegment.End) == dir) { maxDesiredSegment = new LineSegment(maxDesiredSegment.Start, maxDesiredSplicePoint); } ExtendEdgeChain(startVertex, dir, maxDesiredSegment, maxVisibilitySegment, pacList, isOverlapped); }
internal GroupBoundaryCrossing(Obstacle group, Directions dirToInside) { Debug.Assert(CompassVector.IsPureDirection(dirToInside), "Impure direction"); this.Group = group; this.DirectionToInside = dirToInside; }
internal static bool IsPureDirection(Directions dir) { return(CompassVector.IsPureDirection(dir)); }
internal static bool IsPureDirection(Point a, Point b) { Assert_Rounded(a); Assert_Rounded(b); return(CompassVector.IsPureDirection(GetDirections(a, b))); }
private int GetNumberOfBends(Directions entryDirToVertex, Directions dirToTarget) { return(CompassVector.IsPureDirection(dirToTarget) ? GetNumberOfBendsForPureDirection(entryDirToVertex, dirToTarget) : GetBendsForNotPureDirection(dirToTarget, entryDirToVertex, EntryDirectionsToTarget)); }