//
// SparseVisibilityGraphGenerator.cs
// MSAGL base class to create the visibility graph consisting of nlogn ScanSegment intersections for Rectilinear Edge Routing.
//
// Copyright Microsoft Corporation.

using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using Microsoft.Msagl.Core.DataStructures;
using Microsoft.Msagl.Core.Geometry;
using Microsoft.Msagl.Routing.Spline.ConeSpanner;

namespace Microsoft.Msagl.Routing.Rectilinear {
    // Scan direction is parallel to the sweepline which moves in the perpendicular direction;
    // i.e. scan direction is "sideways" along the sweepline.  We do several passes, following Clarkson et al.,
    // "Rectilinear shortest paths through polygonal obstacles in O(n (log n)2) time" (checked into the enlistment).
    //   1.  Enumerate all obstacles and load their extreme vertex coordinate projections to the perpendicular axis.
    //   2.  Run a scanline (in each direction) that:
    //      a.  Accumulates the vertices and generates obstacle-related Steiner points.
    //      b.  Generates the ScanSegments.
    //   3.  Iterate in parallel along the ScanSegments and *VertexPoints to determine the sparse intersections
    //       by binary division, as in the paper.
    //   4.  Finally we create the VisibilityVertices and VisibilityEdges along each ScanSegment from its
    //       list of intersections.
    // Differences from the paper largely are due to the paper's creation of non-orthogonal edges along
    // obstacle sides; instead, we create orthogonal edges to the lateral sides of the obstacle's bounding
    // box. Also, we support overlapped obstacles (interior edges are weighted, as in the non-sparse
    // implementation) and groups.
    internal partial class SparseVisibilityGraphGenerator : VisibilityGraphGenerator {
        /// <summary>
        /// The points of obstacle vertices encountered on horizontal scan.
        /// </summary>
        private readonly Set<Point> horizontalVertexPoints = new Set<Point>();

        /// <summary>
        /// The points of obstacle vertices encountered on vertical scan.
        /// </summary>
        private readonly Set<Point> verticalVertexPoints = new Set<Point>();

        /// <summary>
        /// The Steiner points generated at the bounding box of obstacles.
        /// These help ensure that we can "go around" the obstacle, as with the non-orthogonal edges in the paper.
        /// </summary>
        private readonly Set<Point> boundingBoxSteinerPoints = new Set<Point>();

        /// <summary>
        /// Accumulates distinct vertex projections to the X axis during sweep.
        /// </summary>
        private readonly Set<double> xCoordAccumulator = new Set<double>();

        /// <summary>
        /// Accumulates distinct vertex projections to the Y axis during sweep.
        /// </summary>
        private readonly Set<double> yCoordAccumulator = new Set<double>();

        /// <summary>
        /// ScanSegment vector locations on the Y axis; final array after sweep.
        /// </summary>
        private ScanSegmentVector horizontalScanSegmentVector;

        /// <summary>
        /// ScanSegment vector locations on the X axis; final array after sweep.
        /// </summary>
        private ScanSegmentVector verticalScanSegmentVector;

        /// <summary>
        /// The index from a coordinate to a horizontal vector slot.
        /// </summary>
        private readonly Dictionary<double, int> horizontalCoordMap = new Dictionary<double, int>();

        /// <summary>
        /// The index from a point to a vertical vector slot.
        /// </summary>
        private readonly Dictionary<double, int> verticalCoordMap = new Dictionary<double, int>();

        /// <summary>
        /// The index from a coordinate to a vector slot on the axis we are intersecting to.
        /// </summary>
        private Dictionary<double, int> perpendicularCoordMap;

        /// <summary>
        /// The segment vector we are intersecting along.
        /// </summary>
        private ScanSegmentVector parallelSegmentVector;

        /// <summary>
        /// The segment vector we are intersecting to.
        /// </summary>
        private ScanSegmentVector perpendicularSegmentVector;

        /// <summary>
        /// The comparer for points along the horizontal or vertical axis.
        /// </summary>
        private IComparer<Point> currentAxisPointComparer;

        internal SparseVisibilityGraphGenerator()
                : base(wantReflections: false) {
        }

        internal override void Clear() {
            base.Clear();
            this.Cleanup();
        }

        private void Cleanup() {
            this.horizontalVertexPoints.Clear();
            this.verticalVertexPoints.Clear();
            this.boundingBoxSteinerPoints.Clear();
            this.xCoordAccumulator.Clear();
            this.yCoordAccumulator.Clear();
            this.horizontalCoordMap.Clear();
            this.verticalCoordMap.Clear();
        }

        /// <summary>
        /// Generate the visibility graph along which edges will be routed.
        /// </summary>
        /// <returns></returns>
        internal override void GenerateVisibilityGraph() {
            this.AccumulateVertexCoords();
            this.CreateSegmentVectorsAndPopulateCoordinateMaps();
            this.RunScanLineToCreateSegmentsAndBoundingBoxSteinerPoints();
            this.GenerateSparseIntersectionsFromVertexPoints();
            this.CreateScanSegmentTrees();

            HorizontalScanSegments.DevTraceVerifyVisibility();
            VerticalScanSegments.DevTraceVerifyVisibility();
            Debug_AssertGraphIsRectilinear(VisibilityGraph, ObstacleTree);

            this.Cleanup();
        }

        void AccumulateVertexCoords() {
            // Unlike the paper we only generate lines for extreme vertices (i.e. on the horizontal pass we
            // don't generate a horizontal vertex projection to the Y axis for a vertex that is not on the top
            // or bottom of the obstacle).  So we can just use the bounding box.
            foreach (var obstacle in this.ObstacleTree.GetAllObstacles()) {
                xCoordAccumulator.Insert(obstacle.VisibilityBoundingBox.Left);
                xCoordAccumulator.Insert(obstacle.VisibilityBoundingBox.Right);
                yCoordAccumulator.Insert(obstacle.VisibilityBoundingBox.Top);
                yCoordAccumulator.Insert(obstacle.VisibilityBoundingBox.Bottom);
            }
        }

        private void CreateSegmentVectorsAndPopulateCoordinateMaps() {
            this.horizontalScanSegmentVector = new ScanSegmentVector(yCoordAccumulator, true);
            this.verticalScanSegmentVector = new ScanSegmentVector(xCoordAccumulator, false);

            for (int slot = 0; slot < this.horizontalScanSegmentVector.Length; ++slot) {
                this.horizontalCoordMap[this.horizontalScanSegmentVector[slot].Coord] = slot;
            }
            for (int slot = 0; slot < this.verticalScanSegmentVector.Length; ++slot) {
                this.verticalCoordMap[this.verticalScanSegmentVector[slot].Coord] = slot;
            }
        }

        private void RunScanLineToCreateSegmentsAndBoundingBoxSteinerPoints() {
            // Do a scanline pass to create scan segments that span the entire height/width of the graph
            // (mixing overlapped with free segments as needed) and generate the type-2 Steiner points.
            base.GenerateVisibilityGraph();
            this.horizontalScanSegmentVector.ScanSegmentsComplete();
            this.verticalScanSegmentVector.ScanSegmentsComplete();
            this.xCoordAccumulator.Clear();
            this.yCoordAccumulator.Clear();
        }

        internal override void InitializeEventQueue(ScanDirection scanDir)
        {
            base.InitializeEventQueue(scanDir);
            this.SetVectorsAndCoordMaps(scanDir);
            this.AddAxisCoordinateEvents(scanDir);
        }

        private void AddAxisCoordinateEvents(ScanDirection scanDir) {
            // Normal event ordering will apply - and will thus order the ScanSegments created in the vectors.
            if (scanDir.IsHorizontal) {
                foreach (var coord in yCoordAccumulator) {
                    base.eventQueue.Enqueue(new AxisCoordinateEvent(new Point(ObstacleTree.GraphBox.Left - SentinelOffset, coord)));
                }
                return;
            }
            foreach (var coord in xCoordAccumulator) {
                base.eventQueue.Enqueue(new AxisCoordinateEvent(new Point(coord, ObstacleTree.GraphBox.Bottom - SentinelOffset)));
            }
        }

        protected override void ProcessCustomEvent(SweepEvent evt) {
            if (!ProcessAxisCoordinate(evt)) {
                base.ProcessCustomEvent(evt);
            }
        }

        private bool ProcessAxisCoordinate(SweepEvent evt) {
            var axisEvent = evt as AxisCoordinateEvent;
            if (null != axisEvent) {
                this.CreateScanSegmentsOnAxisCoordinate(axisEvent.Site);
                return true;
            }
            return false;
        }

        protected override bool InsertPerpendicularReflectionSegment(Point start, Point end) {
            Debug.Assert(false, "base.wantReflections is false in Sparse mode so this should never be called");
// ReSharper disable HeuristicUnreachableCode
            return false;
// ReSharper restore HeuristicUnreachableCode
        }

        protected override bool InsertParallelReflectionSegment(Point start, Point end, Obstacle eventObstacle,
                BasicObstacleSide lowNborSide, BasicObstacleSide highNborSide, BasicReflectionEvent action) {
            Debug.Assert(false, "base.wantReflections is false in Sparse mode so this should never be called");
// ReSharper disable HeuristicUnreachableCode
            return false;
// ReSharper restore HeuristicUnreachableCode
        }

        protected override void ProcessVertexEvent(RBNode<BasicObstacleSide> lowSideNode,
                                                   RBNode<BasicObstacleSide> highSideNode, BasicVertexEvent vertexEvent) {
            var vertexPoints = (base.ScanDirection.IsHorizontal) ? this.horizontalVertexPoints : this.verticalVertexPoints;
            vertexPoints.Insert(vertexEvent.Site);

            // For easier reading...
            var lowNborSide = LowNeighborSides.LowNeighbor.Item;
            var highNborSide = HighNeighborSides.HighNeighbor.Item;
            var highDir = base.ScanDirection.Direction;
            var lowDir = base.ScanDirection.OppositeDirection;

            // Generate the neighbor side intersections, regardless of overlaps; these are the type-2 Steiner points.
            var lowSteiner = ScanLineIntersectSide(vertexEvent.Site, lowNborSide);
            var highSteiner = ScanLineIntersectSide(vertexEvent.Site, highNborSide);

            // Add the intersections at the neighbor bounding boxes if the intersection is not at a sentinel.  
            // Go in the opposite direction from the neighbor intersection to find the border between the Steiner 
            // point and vertexEvent.Site (unless vertexEvent.Site is inside the bounding box).
            if (ObstacleTree.GraphBox.Contains(lowSteiner)) {
                var bboxIntersectBeforeLowSteiner = StaticGraphUtility.RectangleBorderIntersect(lowNborSide.Obstacle.VisibilityBoundingBox, lowSteiner, highDir);
                if (PointComparer.IsPureLower(bboxIntersectBeforeLowSteiner, vertexEvent.Site)) {
                    this.boundingBoxSteinerPoints.Insert(bboxIntersectBeforeLowSteiner);
                }
            }
            if (ObstacleTree.GraphBox.Contains(highSteiner)) {
                var bboxIntersectBeforeHighSteiner = StaticGraphUtility.RectangleBorderIntersect(highNborSide.Obstacle.VisibilityBoundingBox, highSteiner, lowDir);
                if (PointComparer.IsPureLower(vertexEvent.Site, bboxIntersectBeforeHighSteiner)) {
                    this.boundingBoxSteinerPoints.Insert(bboxIntersectBeforeHighSteiner);
                }
            }

            // Add the corners of the bounding box of the vertex obstacle, if they are visible to the event site.
            // This ensures that we "go around" the obstacle, as with the non-orthogonal edges in the paper.
            Point lowCorner, highCorner;
            GetBoundingCorners(lowSideNode.Item.Obstacle.VisibilityBoundingBox, vertexEvent is OpenVertexEvent, this.ScanDirection.IsHorizontal,
                        out lowCorner, out highCorner);
            if (PointComparer.IsPureLower(lowSteiner, lowCorner) || lowNborSide.Obstacle.IsInSameClump(vertexEvent.Obstacle)) {
                vertexPoints.Insert(lowCorner);
            }
            if (PointComparer.IsPureLower(highCorner, highSteiner) || highNborSide.Obstacle.IsInSameClump(vertexEvent.Obstacle)) {
                vertexPoints.Insert(highCorner);
            }
        }

        private static void GetBoundingCorners(Rectangle boundingBox, bool isLowSide, bool isHorizontal, out Point lowCorner, out Point highCorner) {
            if (isLowSide) {
                lowCorner = boundingBox.LeftBottom;
                highCorner = isHorizontal ? boundingBox.RightBottom : boundingBox.LeftTop;
                return;
            }
            lowCorner = isHorizontal ? boundingBox.LeftTop : boundingBox.RightBottom;
            highCorner = boundingBox.RightTop;
        }

        private void CreateScanSegmentsOnAxisCoordinate(Point site) {
            base.CurrentGroupBoundaryCrossingMap.Clear();

            // Iterate the ScanLine and create ScanSegments.  There will always be at least the two sentinel sides.
            var sideNode = base.scanLine.Lowest();
            var nextNode = base.scanLine.NextHigh(sideNode);
            var overlapDepth = 0;
            var start = site;
            bool isInsideOverlappedObstacle = false;
            for (; null != nextNode; nextNode = base.scanLine.NextHigh(nextNode)) {
                if (SkipSide(start, nextNode.Item)) {
                    continue;
                }

                if (nextNode.Item.Obstacle.IsGroup) {
                    // Do not create internal group crossings in non-overlapped obstacles.
                    if ((overlapDepth == 0) || isInsideOverlappedObstacle) {
                        HandleGroupCrossing(site, nextNode.Item);
                    }
                    continue;
                }

                var isLowSide = nextNode.Item is LowObstacleSide;
                if (isLowSide) {
                    if (overlapDepth > 0) {
                        ++overlapDepth;
                        continue;
                    }

                    // We are not overlapped, so create a ScanSegment from the previous side intersection to the
                    // intersection with the side in nextNode.Item.
                    start = CreateScanSegment(start, nextNode.Item, ScanSegment.NormalWeight);
                    base.CurrentGroupBoundaryCrossingMap.Clear();
                    overlapDepth = 1;
                    isInsideOverlappedObstacle = nextNode.Item.Obstacle.IsOverlapped;
                    continue;
                }

                // This is a HighObstacleSide.  If we've got overlap nesting, decrement the depth.
                Debug.Assert(overlapDepth > 0, "Overlap depth must be positive");
                --overlapDepth;
                if (overlapDepth > 0) {
                    continue;
                }

                // If we are not within an overlapped obstacle, don't bother creating the overlapped ScanSegment
                // as there will never be visibility connecting to it.
                start = (nextNode.Item.Obstacle.IsOverlapped || nextNode.Item.Obstacle.OverlapsGroupCorner)
                        ? this.CreateScanSegment(start, nextNode.Item, ScanSegment.OverlappedWeight)
                        : this.ScanLineIntersectSide(start, nextNode.Item);
                base.CurrentGroupBoundaryCrossingMap.Clear();
                isInsideOverlappedObstacle = false;
            }

            // The final piece.
            var end = base.ScanDirection.IsHorizontal
                    ? new Point(ObstacleTree.GraphBox.Right + SentinelOffset, start.Y)
                    : new Point(start.X, ObstacleTree.GraphBox.Top + SentinelOffset);
            this.parallelSegmentVector.CreateScanSegment(start, end, ScanSegment.NormalWeight,
                    base.CurrentGroupBoundaryCrossingMap.GetOrderedListBetween(start, end));
            this.parallelSegmentVector.ScanSegmentsCompleteForCurrentSlot();
        }

        private void HandleGroupCrossing(Point site, BasicObstacleSide groupSide) {
            if (!base.ScanLineCrossesObstacle(site, groupSide.Obstacle)) {
                return;
            }
            // Here we are always going left-to-right.  As in base.SkipToNeighbor, we don't stop traversal for groups,
            // neither do we create overlapped edges (unless we're inside a non-group obstacle).  Instead we turn
            // the boundary crossing on or off based on group membership at ShortestPath-time.  Even though this is
            // the sparse VG, we always create these edges at group boundaries so we don't skip over them.
            Directions dirToInsideOfGroup = (groupSide is LowObstacleSide) ? base.ScanDirection.Direction : base.ScanDirection.OppositeDirection;
            var intersect = this.ScanLineIntersectSide(site, groupSide);
            var crossing = base.CurrentGroupBoundaryCrossingMap.AddIntersection(intersect, groupSide.Obstacle, dirToInsideOfGroup);

            // The vertex crossing the edge is perpendicular to the group boundary.  A rectilinear group will also have
            // an edge parallel to that group boundary that includes the point of that crossing vertex; therefore we must
            // split that non-crossing edge at that vertex.
            AddPerpendicularCoordForGroupCrossing(intersect);

            // Similarly, the crossing edge's opposite vertex may be on a perpendicular segment.
            var interiorPoint = crossing.GetInteriorVertexPoint(intersect);
            AddPerpendicularCoordForGroupCrossing(interiorPoint);
        }

        private void AddPerpendicularCoordForGroupCrossing(Point intersect) {
            var nonCrossingPerpSlot = this.FindPerpendicularSlot(intersect, 0);
            if (-1 != nonCrossingPerpSlot) {
                this.perpendicularSegmentVector[nonCrossingPerpSlot].AddPendingPerpendicularCoord(this.parallelSegmentVector.CurrentSlot.Coord);
            }
        }

        private bool SkipSide(Point start, BasicObstacleSide side) {
            if (side.Obstacle.IsSentinel) {
                return true;
            }

            // Skip sides of obstacles that we do not actually pass through.
            var bbox = side.Obstacle.VisibilityBoundingBox;
            if (base.ScanDirection.IsHorizontal) {
                return ((start.Y == bbox.Bottom) || (start.Y == bbox.Top));
            }
            return ((start.X == bbox.Left) || (start.X == bbox.Right));
        }

        private Point CreateScanSegment(Point start, BasicObstacleSide side, double weight) {
            var end = ScanLineIntersectSide(start, side);
            if (start != end) {
                this.parallelSegmentVector.CreateScanSegment(start, end, weight, CurrentGroupBoundaryCrossingMap.GetOrderedListBetween(start, end));
            }
            return end;
        }

        private void GenerateSparseIntersectionsFromVertexPoints() {
            this.VisibilityGraph = NewVisibilityGraph();

            // Generate the sparse intersections between ScanSegments based upon the ordered vertexPoints.
            GenerateSparseIntersectionsAlongHorizontalAxis();
            GenerateSparseIntersectionsAlongVerticalAxis();

            this.ConnectAdjoiningScanSegments();

            // Now each segment has the coordinates all of its intersections, so create the visibility graph.
            this.horizontalScanSegmentVector.CreateSparseVerticesAndEdges(this.VisibilityGraph);
            this.verticalScanSegmentVector.CreateSparseVerticesAndEdges(this.VisibilityGraph);
        }

        private void GenerateSparseIntersectionsAlongHorizontalAxis() {
            this.currentAxisPointComparer = new HorizontalPointComparer();
            var vertexPoints = this.horizontalVertexPoints.OrderBy(point => point, this.currentAxisPointComparer).GetEnumerator();
            var bboxSteinerPoints = new EnumeratorWrapper<Point>(this.boundingBoxSteinerPoints.OrderBy(point => point, this.currentAxisPointComparer));
            base.ScanDirection = ScanDirection.HorizontalInstance;
            SetVectorsAndCoordMaps(base.ScanDirection);
            this.GenerateSparseIntersections(vertexPoints, bboxSteinerPoints);
        }

        private void GenerateSparseIntersectionsAlongVerticalAxis() {
            this.currentAxisPointComparer = new VerticalPointComparer();
            var vertexPoints = this.verticalVertexPoints.OrderBy(point => point, this.currentAxisPointComparer).GetEnumerator();
            var bboxSteinerPoints = new EnumeratorWrapper<Point>(this.boundingBoxSteinerPoints.OrderBy(point => point, this.currentAxisPointComparer));
            base.ScanDirection = ScanDirection.VerticalInstance;
            SetVectorsAndCoordMaps(base.ScanDirection);
            this.GenerateSparseIntersections(vertexPoints, bboxSteinerPoints);
        }

        private void SetVectorsAndCoordMaps(ScanDirection scanDir) {
            if (scanDir.IsHorizontal) {
                this.parallelSegmentVector = this.horizontalScanSegmentVector;
                this.perpendicularSegmentVector = this.verticalScanSegmentVector;
                this.perpendicularCoordMap = this.verticalCoordMap;
            } else {
                this.parallelSegmentVector = this.verticalScanSegmentVector;
                this.perpendicularSegmentVector = this.horizontalScanSegmentVector;
                this.perpendicularCoordMap = this.horizontalCoordMap;
            }
        }

        private void ConnectAdjoiningScanSegments() {
            // Ensure there is a vertex at the end/start point of two ScanSegments; these will always differ in overlappedness.
            this.horizontalScanSegmentVector.ConnectAdjoiningSegmentEndpoints();
            this.verticalScanSegmentVector.ConnectAdjoiningSegmentEndpoints();
        }

        internal class HorizontalPointComparer : IComparer<Point> {
            // Order by vertical first, then horizontal.
            public int Compare(Point lhs, Point rhs) {
                var cmp = lhs.Y.CompareTo(rhs.Y);
                return (0 != cmp) ? cmp : lhs.X.CompareTo(rhs.X);
            }
        }

        public class VerticalPointComparer : IComparer<Point> {
            // Order by horizontal first, then vertical.
            public int Compare(Point lhs, Point rhs) {
                var cmp = lhs.X.CompareTo(rhs.X);
                return (0 != cmp) ? cmp : lhs.Y.CompareTo(rhs.Y);
            }
        }

        private void GenerateSparseIntersections(IEnumerator<Point> vertexPoints, EnumeratorWrapper<Point> bboxSteinerPoints) {
            this.perpendicularSegmentVector.ResetForIntersections();
            this.parallelSegmentVector.ResetForIntersections();

            // Position the enumerations to the first point.
            vertexPoints.MoveNext();
            bboxSteinerPoints.MoveNext();
            foreach (var item in parallelSegmentVector.Items) {
                for (;;) {
                    if (!item.CurrentSegment.ContainsPoint(vertexPoints.Current)) {
                        // Done accumulating intersections for the current segment; move to the next segment.
                        if (!this.AddSteinerPointsToInterveningSegments(vertexPoints.Current, bboxSteinerPoints, item)
                                || !item.TraverseToSegmentContainingPoint(vertexPoints.Current)) {
                            // Done with this vectorItem, move to the next item.
                            break;
                        }
                    }

                    this.AddPointsToCurrentSegmentIntersections(bboxSteinerPoints, item);
                    this.GenerateIntersectionsFromVertexPointForCurrentSegment(vertexPoints.Current, item);

                    if (item.PointIsCurrentEndAndNextStart(vertexPoints.Current)) {
                        // MoveNext will always return true because the test to enter this block returned true.
                        item.MoveNext();
                        Debug.Assert(item.HasCurrent, "MoveNext ended before EndAndNextStart");
                        continue;
                    }

                    if (!vertexPoints.MoveNext()) {
                        // No more vertexPoints; we're done.
                        Debug.Assert(!bboxSteinerPoints.HasCurrent, "Some boundingBoxSteinerPoints remain");
                        return;
                    }
                }
            }

            // We should have exited in the "no more vertexPoints" case above.
            Debug.Assert(false, "Mismatch in points and segments");
        }

        private bool AddSteinerPointsToInterveningSegments(Point currentVertexPoint, EnumeratorWrapper<Point> bboxSteinerPoints, ScanSegmentVectorItem item) {
            // With overlaps, we may have bboxSteinerPoints on segments that do not contain vertices.
            while (bboxSteinerPoints.HasCurrent && (this.currentAxisPointComparer.Compare(bboxSteinerPoints.Current, currentVertexPoint) == -1)) {
                if (!item.TraverseToSegmentContainingPoint(bboxSteinerPoints.Current)) {
                    // Done with this vectorItem, move to the next item.
                    return false;
                }
                this.AddPointsToCurrentSegmentIntersections(bboxSteinerPoints, item);
            }
            return true;
        }

        private void AddPointsToCurrentSegmentIntersections(EnumeratorWrapper<Point> pointsToAdd, ScanSegmentVectorItem parallelItem) {
            // The first Steiner point should be in the segment, unless we have a non-orthogonal or overlapped or both situation
            // that results in no Steiner points having been generated, or Steiner points being generated on a segment that has
            // the opposite overlap state from the segment containing the corresponding vertex.
            for (; pointsToAdd.HasCurrent && parallelItem.CurrentSegment.ContainsPoint(pointsToAdd.Current); pointsToAdd.MoveNext()) {
                int steinerSlot = this.FindPerpendicularSlot(pointsToAdd.Current, 0);
                this.AddSlotToSegmentIntersections(parallelItem, steinerSlot);
            }
        }

        private void GenerateIntersectionsFromVertexPointForCurrentSegment(Point site, ScanSegmentVectorItem parallelItem) {
            int perpStartSlot = this.FindPerpendicularSlot(parallelItem.CurrentSegment.Start, 1);
            int perpEndSlot = this.FindPerpendicularSlot(parallelItem.CurrentSegment.End, -1);
            int siteSlot = this.FindPerpendicularSlot(site, 0);

            // See comments in FindIntersectingSlot; we don't add non-extreme vertices in the perpendicular direction
            // so in some heavily-overlapped scenarios, we may not have any intersections within this scan segment.
            if (perpStartSlot >= perpEndSlot) {
                return;
            }

            this.AddSlotToSegmentIntersections(parallelItem, perpStartSlot);
            this.AddSlotToSegmentIntersections(parallelItem, perpEndSlot);
            if ((siteSlot > perpStartSlot) && (siteSlot < perpEndSlot)) {
                this.AddSlotToSegmentIntersections(parallelItem, siteSlot);
                this.AddBinaryDivisionSlotsToSegmentIntersections(parallelItem, perpStartSlot, siteSlot, perpEndSlot);
            }
        }
 
        // These are called when the site may not be in the vector.
        private int FindPerpendicularSlot(Point site, int directionIfMiss) {
            return FindIntersectingSlot(perpendicularSegmentVector, perpendicularCoordMap, site, directionIfMiss);
        }

        private static int FindIntersectingSlot(ScanSegmentVector segmentVector, Dictionary<double, int> coordMap, Point site, int directionIfMiss) {
            var coord = segmentVector.GetParallelCoord(site);
            int slot;
            if (coordMap.TryGetValue(coord, out slot)) {
                return slot;
            }

            // There are a few cases where the perpCoord is not in the map:
            // 1.  The first ScanSegment in a slot will have a Start at the sentinel, which is before the first 
            //     perpendicular segment; similarly, the last ScanSegment in a slot will have an out-of-range End.
            // 2.  Sequences of overlapped/nonoverlapped scan segments that pass through obstacles.  Their start
            //     and end points are not in vertexPoints because they were not vertex-derived, so we find the
            //     closest bracketing coordinates that are in the vectors.
            // 3.  Non-extreme vertices in the perpendicular direction (e.g. for a triangle, we add the X's of
            //     the left and right to the coords, but not of the top).
            // 4.  Non-rectilinear group side intersections.
            return (0 == directionIfMiss) ? -1 : segmentVector.FindNearest(coord, directionIfMiss);
        }

        private void AddSlotToSegmentIntersections(ScanSegmentVectorItem parallelItem, int perpSlot) {
            ScanSegmentVectorItem perpItem = this.perpendicularSegmentVector[perpSlot];
            parallelItem.CurrentSegment.AddSparseVertexCoord(perpItem.Coord);
            perpItem.AddPerpendicularCoord(parallelItem.Coord);
        }

        private void AddBinaryDivisionSlotsToSegmentIntersections(ScanSegmentVectorItem parallelItem, int startSlot, int siteSlot, int endSlot) {
            // The input parameters' slots have already been added to the segment's coords.  
            // If there was no object to the low or high side, then the start or end slot was already
            // the graphbox max (0 or perpSegmentVector.Length, respectively).  So start dividing.
            int low = 0;
            int high = this.perpendicularSegmentVector.Length - 1;

            // Terminate when we are one away because we don't have an edge from a point to itself.
            while ((high - low) > 1) {
                int mid = low + ((high - low) / 2);

                // We only use the half of the graph that the site is in, so arbitrarily decide that it is
                // in the lower half if it is at the midpoint.
                if (siteSlot <= mid) {
                    high = mid;
                    if ((siteSlot < high) && (high <= endSlot)) {
                        this.AddSlotToSegmentIntersections(parallelItem, high);
                    }
                    continue;
                }
                low = mid;
                if ((siteSlot > low) && (low >= startSlot)) {
                    this.AddSlotToSegmentIntersections(parallelItem, low);
                }
            }
        }

        // Create the ScanSegmentTrees that functions as indexes for port-visibility splicing.
        private void CreateScanSegmentTrees() {
            CreateScanSegmentTree(this.horizontalScanSegmentVector, this.HorizontalScanSegments);
            CreateScanSegmentTree(this.verticalScanSegmentVector, this.VerticalScanSegments);
        }

        private static void CreateScanSegmentTree(ScanSegmentVector segmentVector, ScanSegmentTree segmentTree) {
            foreach (var item in segmentVector.Items) {
                for (var segment = item.FirstSegment; segment != null; segment = segment.NextSegment) {
                    if (segment.HasVisibility()) {
                        segmentTree.InsertUnique(segment);
                    }
                }
            }
        }
    }
}