private static VisibilityVertex TraverseToFirstVertexAtOrAbove(VisibilityVertex startVertex, Point start, Direction dir)
{
var returnVertex = startVertex;
var oppositeDir = CompassVector.OppositeDir(dir);
for ( ; ;)
{
var nextVertex = StaticGraphUtility.FindNextVertex(returnVertex, dir);
// This returns Directions. None on a match.
if ((null == nextVertex) || (PointComparer.GetDirections(nextVertex.Point, start) == oppositeDir))
{
break;
}
returnVertex = nextVertex;
}
return(returnVertex);
}
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 VisibilityEdge FindNearestPerpendicularOrContainingEdge(VisibilityVertex startVertex
, Directions dir, Point pointLocation)
{
// Similar to FindPerpendicularEdge, but first try to move closer to pointLocation,
// as long as there are edges going in 'dir' that extend to pointLocation.
Directions dirTowardLocation = ~dir& PointComparer.GetDirections(startVertex.Point, pointLocation);
// If Directions. None then pointLocation is collinear.
VisibilityVertex currentVertex = startVertex;
Directions currentDirTowardLocation = dirTowardLocation;
// First move toward pointLocation far as we can.
while (Directions.None != currentDirTowardLocation)
{
VisibilityVertex nextVertex = StaticGraphUtility.FindNextVertex(currentVertex, dirTowardLocation);
if (null == nextVertex)
{
break;
}
if (0 != (CompassVector.OppositeDir(dirTowardLocation)
& PointComparer.GetDirections(nextVertex.Point, pointLocation)))
{
break;
}
currentVertex = nextVertex;
currentDirTowardLocation = ~dir& PointComparer.GetDirections(currentVertex.Point, pointLocation);
}
// Now find the first vertex that has a chain that intersects pointLocation, if any, moving away
// from pointLocation until we find it or arrive back at startVertex.
VisibilityEdge perpEdge;
while (true)
{
perpEdge = FindPerpendicularOrContainingEdge(currentVertex, dir, pointLocation);
if ((null != perpEdge) || (currentVertex == startVertex))
{
break;
}
currentVertex = StaticGraphUtility.FindNextVertex(currentVertex, CompassVector.OppositeDir(dirTowardLocation));
}
return(perpEdge);
}
private SegmentAndCrossings GetSegmentAndCrossings(VisibilityVertex startVertex, Directions dirToExtend, TransientGraphUtility transUtil)
{
var dirIndex = CompassVector.ToIndex(dirToExtend);
var segmentAndCrossings = this.maxVisibilitySegmentsAndCrossings[dirIndex];
if (null == segmentAndCrossings)
{
PointAndCrossingsList pacList;
var maxVisibilitySegment = transUtil.ObstacleTree.CreateMaxVisibilitySegment(startVertex.Point, dirToExtend, out pacList);
segmentAndCrossings = new SegmentAndCrossings(maxVisibilitySegment, pacList);
this.maxVisibilitySegmentsAndCrossings[dirIndex] = segmentAndCrossings;
}
else
{
// For a waypoint this will be a target and then a source, so there may be a different lateral edge to
// connect to. In that case make sure we are consistent in directions - back up the start point if needed.
if (PointComparer.GetDirections(startVertex.Point, segmentAndCrossings.Item1.Start) == dirToExtend)
{
segmentAndCrossings.Item1.Start = startVertex.Point;
}
}
return(segmentAndCrossings);
}
static bool IsPointPastSegmentEnd(LineSegment maxSegment, Point point)
{
return(PointComparer.GetDirections(maxSegment.Start, maxSegment.End) == PointComparer.GetDirections(maxSegment.End, point));
}
// The return value is whether we should try a second pass if this is called on the first pass,
// using spliceTarget to wrap up dead-ends on the target side.
bool ExtendSpliceWorker(VisibilityVertex spliceSource, Directions extendDir, Directions spliceTargetDir
, LineSegment maxDesiredSegment, LineSegment maxVisibilitySegment
, bool isOverlapped, out VisibilityVertex spliceTarget)
{
// This is called after having created at least one extension vertex (initially, the
// first one added outside the obstacle), so we know extendVertex will be there. spliceSource
// is the vertex to the OppositeDir(spliceTargetDir) of that extendVertex.
VisibilityVertex extendVertex = StaticGraphUtility.FindNextVertex(spliceSource, spliceTargetDir);
spliceTarget = StaticGraphUtility.FindNextVertex(extendVertex, spliceTargetDir);
for (; ;)
{
if (!GetNextSpliceSource(ref spliceSource, spliceTargetDir, extendDir))
{
break;
}
// spliceSource is now on the correct edge relative to the desired nextExtendPoint.
// spliceTarget is in the opposite direction of the extension-line-to-spliceSource.
Point nextExtendPoint = StaticGraphUtility.FindBendPointBetween(extendVertex.Point
, spliceSource.Point, CompassVector.OppositeDir(spliceTargetDir));
// We test below for being on or past maxDesiredSegment; here we may be skipping
// over maxDesiredSegmentEnd which is valid since we want to be sure to go to or
// past limitRect, but be sure to stay within maxVisibilitySegment.
if (IsPointPastSegmentEnd(maxVisibilitySegment, nextExtendPoint))
{
break;
}
spliceTarget = GetSpliceTarget(ref spliceSource, spliceTargetDir, nextExtendPoint);
//StaticGraphUtility.Test_DumpVisibilityGraph(ObstacleTree, VisGraph);
if (null == spliceTarget)
{
// This may be because spliceSource was created just for Group boundaries. If so,
// skip to the next nextExtendVertex location.
if (this.IsSkippableSpliceSourceWithNullSpliceTarget(spliceSource, extendDir))
{
continue;
}
// We're at a dead-end extending from the source side, or there is an intervening obstacle, or both.
// Don't splice across lateral group boundaries.
if (ObstacleTree.SegmentCrossesAnObstacle(spliceSource.Point, nextExtendPoint))
{
return(false);
}
}
// We might be walking through a point where a previous chain dead-ended.
VisibilityVertex nextExtendVertex = VisGraph.FindVertex(nextExtendPoint);
if (null != nextExtendVertex)
{
if ((null == spliceTarget) || (null != this.VisGraph.FindEdge(extendVertex.Point, nextExtendPoint)))
{
// We are probably along a ScanSegment so visibility in this direction has already been determined.
// Stop and don't try to continue extension from the opposite side. If we continue splicing here
// it might go across an obstacle.
if (null == spliceTarget)
{
Debug_VerifyNonOverlappedExtension(isOverlapped, extendVertex, nextExtendVertex, spliceSource: null, spliceTarget: null);
FindOrAddEdge(extendVertex, nextExtendVertex, isOverlapped ? ScanSegment.OverlappedWeight : ScanSegment.NormalWeight);
}
return(false);
}
// This should always have been found in the find-the-next-target loop above if there is
// a vertex (which would be nextExtendVertex, which we just found) between spliceSource
// and spliceTarget. Even for a sparse graph, an edge should not skip over a vertex.
StaticGraphUtility.Assert(spliceTarget == StaticGraphUtility.FindNextVertex(nextExtendVertex, spliceTargetDir)
, "no edge exists between an existing nextExtendVertex and spliceTarget"
, ObstacleTree, VisGraph);
}
else
{
StaticGraphUtility.Assert((null == spliceTarget) ||
spliceTargetDir == PointComparer.GetPureDirection(nextExtendPoint, spliceTarget.Point)
, "spliceTarget is not to spliceTargetDir of nextExtendVertex"
, ObstacleTree, VisGraph);
nextExtendVertex = this.AddVertex(nextExtendPoint);
}
FindOrAddEdge(extendVertex, nextExtendVertex, isOverlapped ? ScanSegment.OverlappedWeight : ScanSegment.NormalWeight);
Debug_VerifyNonOverlappedExtension(isOverlapped, extendVertex, nextExtendVertex, spliceSource, spliceTarget);
// This will split the edge if targetVertex is non-null; otherwise we are at a dead-end
// on the target side so must not create a vertex as it would be inside an obstacle.
FindOrAddEdge(spliceSource, nextExtendVertex, isOverlapped ? ScanSegment.OverlappedWeight : ScanSegment.NormalWeight);
if (isOverlapped)
{
isOverlapped = this.SeeIfSpliceIsStillOverlapped(extendDir, nextExtendVertex);
}
extendVertex = nextExtendVertex;
// Test GetDirections because it may return Directions. None.
if (0 == (extendDir & PointComparer.GetDirections(nextExtendPoint, maxDesiredSegment.End)))
{
// At or past the desired max extension point, so we're done.
spliceTarget = null;
break;
}
}
return(null != spliceTarget);
}
internal bool HasGroupCrossingBeforePoint(Point point)
{
if (!this.HasGroupCrossings)
{
return(false);
}
var pac = StaticGraphUtility.IsAscending(this.OutwardDirection) ? this.pointAndCrossingsList.First : this.pointAndCrossingsList.Last;
return(PointComparer.GetDirections(this.MaxVisibilitySegment.Start, pac.Location) == PointComparer.GetDirections(pac.Location, point));
}