// ReSharper restore InconsistentNaming
private VisibilityEdge CreateEdge(VisibilityVertex first, VisibilityVertex second, double weight)
{
// All edges in the graph are ascending.
VisibilityVertex source = first;
VisibilityVertex target = second;
if (!PointComparer.IsPureLower(source.Point, target.Point))
{
source = second;
target = first;
}
var edge = new TollFreeVisibilityEdge(source, target, weight);
VisibilityGraph.AddEdge(edge);
this.AddedEdges.Add(edge);
return(edge);
}
public static Dictionary <string, object> ShortestPath(
Point startPoint,
Point endPoint,
List <Polygon> boundary,
List <Polygon> obstructions)
{
if (startPoint is null)
{
throw new ArgumentNullException(nameof(startPoint));
}
if (endPoint is null)
{
throw new ArgumentNullException(nameof(endPoint));
}
if (boundary is null)
{
throw new ArgumentNullException(nameof(boundary));
}
if (obstructions is null)
{
throw new ArgumentNullException(nameof(obstructions));
}
var gOrigin = GTGeom.Vertex.ByCoordinates(startPoint.X, startPoint.Y, startPoint.Z);
var gDestination = GTGeom.Vertex.ByCoordinates(endPoint.X, endPoint.Y, endPoint.Z);
// compute visibility graph
var visGraph = CreateVisibilityGraph(boundary, obstructions);
if (visGraph is null)
{
throw new InvalidOperationException("Failed to create visibility graph.");
}
var visibilityGraph = visGraph.graph as VisibilityGraph;
var graph = VisibilityGraph.ShortestPath(visibilityGraph, gOrigin, gDestination);
return(new Dictionary <string, object>()
{
{ pathOutputPort, LinesFromGraph(graph) },
{ lengthOutputPort, graph.edges.Select(e => e.Length).Sum() }
});
}
internal void ModifySkeletonWithNewBoundaryOnLayer(LgNodeInfo nodeInfo)
{
Dictionary <VisibilityEdge, VisibilityVertex> edgeSnapMap = GetEdgeSnapAtVertexMap(nodeInfo);
foreach (var t in edgeSnapMap)
{
VisibilityEdge edge = t.Key;
VisibilityGraph.RemoveEdge(edge);
var midleV = edgeSnapMap[edge];
if (nodeInfo.Center != edge.SourcePoint)
{
VisibilityGraph.AddEdge(edge.Source, midleV);
}
else
{
VisibilityGraph.AddEdge(midleV, edge.Target);
}
}
}
private void AddCrossingEdge(VisibilityGraph vg, VisibilityVertex lowVertex, VisibilityVertex highVertex, GroupBoundaryCrossing[] crossings)
{
VisibilityEdge edge = null;
if (null != HighestVisibilityVertex)
{
// We may have a case where point xx.xxxxx8 has added an ascending-direction crossing, and now we're on
// xx.xxxxx9 adding a descending-direction crossing. In that case there should already be a VisibilityEdge
// in the direction we want.
if (PointComparer.Equal(this.HighestVisibilityVertex.Point, highVertex.Point))
{
edge = vg.FindEdge(lowVertex.Point, highVertex.Point);
Debug.Assert(edge != null, "Inconsistent forward-backward sequencing in HighVisibilityVertex");
}
else
{
AppendHighestVisibilityVertex(lowVertex);
}
}
if (edge == null)
{
edge = AddVisibilityEdge(lowVertex, highVertex);
}
var crossingsArray = crossings.Select(c => c.Group.InputShape).ToArray();
var prevIsPassable = edge.IsPassable;
if (prevIsPassable == null)
{
edge.IsPassable = delegate { return(crossingsArray.Any(s => s.IsTransparent)); };
}
else
{
// Because we don't have access to the previous delegate's internals, we have to chain. Fortunately this
// will never be more than two deep. File Test: Groups_Forward_Backward_Between_Same_Vertices.
edge.IsPassable = delegate { return(crossingsArray.Any(s => s.IsTransparent) || prevIsPassable()); };
}
if (null == LowestVisibilityVertex)
{
SetInitialVisibilityVertex(lowVertex);
}
HighestVisibilityVertex = highVertex;
}
internal BundleRouter(GeometryGraph geometryGraph, SdShortestPath shortestPathRouter,
VisibilityGraph visibilityGraph, BundlingSettings bundlingSettings, double loosePadding, RectangleNode <Polyline> tightHierarchy,
RectangleNode <Polyline> looseHierarchy,
Dictionary <EdgeGeometry, Set <Polyline> > edgeLooseEnterable, Dictionary <EdgeGeometry, Set <Polyline> > edgeTightEnterable, Func <Port, Polyline> loosePolylineOfPort)
{
ValidateArg.IsNotNull(geometryGraph, "geometryGraph");
ValidateArg.IsNotNull(bundlingSettings, "bundlingSettings");
this.geometryGraph = geometryGraph;
this.bundlingSettings = bundlingSettings;
regularEdges = geometryGraph.Edges.Where(e => e.Source != e.Target).ToArray();
VisibilityGraph = visibilityGraph;
this.shortestPathRouter = shortestPathRouter;
LoosePadding = loosePadding;
LooseHierarchy = looseHierarchy;
TightHierarchy = tightHierarchy;
EdgeLooseEnterable = edgeLooseEnterable;
EdgeTightEnterable = edgeTightEnterable;
this.loosePolylineOfPort = loosePolylineOfPort;
}
internal void CreateSparseVerticesAndEdges(VisibilityGraph vg)
{
if (this.sparsePerpendicularCoords == null)
{
return;
}
AppendGroupCrossingsThroughPoint(vg, Start);
foreach (var perpCoord in this.sparsePerpendicularCoords.OrderBy(d => d))
{
var vertexLocation = this.CreatePointFromPerpCoord(perpCoord);
Debug.Assert(this.ContainsPoint(vertexLocation), "vertexLocation is not on Segment");
this.AppendVisibilityVertex(vg, vg.FindVertex(vertexLocation) ?? vg.AddVertex(vertexLocation));
}
AppendGroupCrossingsThroughPoint(vg, End);
GroupBoundaryPointAndCrossingsList = null;
this.sparsePerpendicularCoords.Clear();
this.sparsePerpendicularCoords = null;
}
void OnDrawGizmosSelected()
{
if (!_drawConnections)
{
return;
}
var drawablePoints = new List <GameObject>();
foreach (var obj in GameObject.FindGameObjectsWithTag("Waypoint"))
{
if (obj.activeInHierarchy)
{
drawablePoints.Add(obj);
}
}
foreach (var obj in GameObject.FindGameObjectsWithTag("PatrolPoint"))
{
if (obj.activeInHierarchy)
{
drawablePoints.Add(obj);
}
}
foreach (var obj in drawablePoints)
{
if (obj.CompareTag("Waypoint"))
{
Gizmos.color = Color.white;
}
else if (obj.CompareTag("PatrolPoint"))
{
Gizmos.color = Color.yellow;
}
if (VisibilityGraph.CanPointsSeeEachOther(transform.position, obj.transform.position))
{
Gizmos.DrawLine(transform.position, obj.transform.position);
}
}
}
public void DrawFromBoundaries(
Vector2 source, Vector2 target, Color color, VisibilityGraph graph
)
{
Vector3[] sourceAndTarget = { source, target };
foreach (Vector3 boundaryReflexPt in boundaryReflexPts)
{
foreach (Vector3 pt in sourceAndTarget)
{
Vector3[] vertices = DrawVisibilityEdge(
boundaryReflexPt, pt, color, false, true, false, true
);
if (vertices != null)
{
graph.AddEdge(vertices[0], vertices[1]);
}
}
}
}
public void TwoPorts()
{
var obstacles = new List <Polyline>();
var direction = new Point(0, 1);
var vg = new VisibilityGraph();
var ports = new Set <Point>();
ports.Insert(new Point(0, 0));
ports.Insert(new Point(0.1, 10));
Polyline border = null;
LineSweeper.Sweep(
obstacles,
direction,
Math.PI / 6,
vg,
ports,
border
);
}
internal RectFileReader(string fileName, int fileRoundingDigits)
{
comparer = new TestPointComparer(fileRoundingDigits);
UnpaddedObstacles = new List <Shape>();
PaddedObstacles = new List <Polyline>();
RoutingSpecs = new List <EdgeGeometry>();
HorizontalScanLineSegments = new List <LineSegment>();
VerticalScanLineSegments = new List <LineSegment>();
VisibilityGraph = new VisibilityGraph();
this.FreeRelativePortToShapeMap = new Dictionary <Port, Shape>();
this.inputFileReader = new StreamReader(fileName);
this.RandomObstacleArg = RectFileStrings.NullStr;
this.RandomObstacleDensity = RectFileStrings.NullStr;
// Input parameters
ReadHeader();
// Input detail
ReadInputObstacles();
ReadPorts();
ReadRoutingSpecs();
// Output detail.
ReadPaddedObstacles();
ReadConvexHulls();
ReadScanSegments();
ReadVisibilityGraph();
ReadPaths();
this.inputFileReader.Close();
if (0 == this.UnpaddedObstacles.Count)
{
Validate.Fail("No obstacles found in file");
}
}
/// <summary>
/// Builds the graph by collecting all <see cref="Waypoint"/> game objects in the scene,
/// and using their positions as the source data for <see cref="AStarNode"/>s.
/// </summary>
private void BuildGraph()
{
_waypointNodes = new Dictionary <Guid, AStarNode>();
var sceneWaypoints = GameObject.FindGameObjectsWithTag("Waypoint");
var nodes = new AStarNode[sceneWaypoints.Length];
// Create AStarNode instances for each Waypoint in the scene
for (int i = 0; i < sceneWaypoints.Length; i++)
{
var waypoint = sceneWaypoints[i].GetComponent <Waypoint>();
var node = new AStarNode(waypoint.transform.position);
nodes[i] = node;
_waypointNodes.Add(waypoint.Id, node);
}
// Build the visibility map according to the nodes in scene
_visibilityGraph = new VisibilityGraph(nodes);
_visibilityGraph.Build();
}
public void TwoInACone()
{
var obstacles = new List <Polyline>();
var direction = new Point(0, 1);
var vg = new VisibilityGraph();
var ports = new Set <Point>();
ports.Insert(new Point(0, 0));
ports.Insert(new Point(0.1, 10));
ports.Insert(new Point(-0.1, 10));
Polyline border = null;
LineSweeper.Sweep(
obstacles,
direction,
Math.PI / 6,
vg,
ports,
border
);
Assert.AreEqual(vg.Edges.Count(), 1);
}
private static void RunOnRandom(int i)
{
var ran = new Random(i);
var ps = new List <Point>();
for (int j = 0; j < 10; j++)
{
ps.Add(20 * (new Point(ran.NextDouble(), ran.NextDouble())));
}
var vg = new VisibilityGraph();
var dir = new Point(0, 1);
LineSweeper.Sweep(
new List <Polyline>(),
dir,
Math.PI / 6,
vg,
new Set <Point>(ps),
null
);
CheckVG(vg, ps, dir);
//Msagl.Routing.SplineRouter.ShowVisGraph(vg, null, null, null);
}
public void VisibilityFromPointColinearVerticesYAxis()
{
var a = Vertex.ByCoordinates(0, 0);
var b = Vertex.ByCoordinates(a.X + 20, a.Y); // 20, 0
var c = Vertex.ByCoordinates(b.X, b.Y + 10); // 20, 10
var d = Vertex.ByCoordinates(c.X - 10, c.Y); // 10, 10
var e = Vertex.ByCoordinates(d.X, d.Y + 10); // 10, 20
var f = Vertex.ByCoordinates(c.X, e.Y); // 20, 20
var g = Vertex.ByCoordinates(a.X, d.Y + 10); //0, 20
Polygon polygon = Polygon.ByVertices(new List <Vertex>()
{
a, b, c, d, e, f, g
}, true);
Graph baseGraph = new Graph(new List <Polygon>()
{
polygon
});
List <Vertex> vertices = VisibilityGraph.VertexVisibility(b, baseGraph);
Assert.AreEqual(5, vertices.Count);
}
public static Dictionary <string, object> Connectivity(
Visibility visGraph,
[DefaultArgument("null")] List <DSCore.Color> colours,
[DefaultArgument("null")] List <double> indices)
{
if (visGraph == null)
{
throw new ArgumentNullException("visGraph");
}
VisibilityGraph visibilityGraph = visGraph.graph as VisibilityGraph;
Visibility graph = new Visibility()
{
graph = visibilityGraph,
Factors = visibilityGraph.ConnectivityFactor()
};
if (colours != null && indices != null && colours.Count == indices.Count)
{
graph.colorRange = new Dictionary <double, DSCore.Color>();
// Create KeyValuePairs and sort them by index in case unordered.
var pairs = indices.Zip(colours, (i, c) => new KeyValuePair <double, DSCore.Color>(i, c)).OrderBy(kv => kv.Key);
// Adding values to colorRange dictionary
foreach (KeyValuePair <double, DSCore.Color> kv in pairs)
{
graph.colorRange.Add(kv.Key, kv.Value);
}
}
return(new Dictionary <string, object>()
{
{ graphOutput, graph },
{ factorsOutput, graph.Factors }
});
}
public static Surface IsovistFromPoint(
Point point,
List <Polygon> boundary,
[DefaultArgument("[]")] List <Polygon> obstructions)
{
var baseGraph = BaseGraph.ByBoundaryAndInternalPolygons(boundary, obstructions);
if (baseGraph == null)
{
throw new ArgumentNullException("graph");
}
if (point == null)
{
throw new ArgumentNullException("point");
}
GTGeom.Vertex origin = GTGeom.Vertex.ByCoordinates(point.X, point.Y, point.Z);
List <GTGeom.Vertex> vertices = VisibilityGraph.VertexVisibility(origin, baseGraph.graph);
var points = vertices.Select(v => GTGeom.Points.ToPoint(v)).ToList();
var polygon = Polygon.ByPoints(points);
// if polygon is self intersecting, make new polygon
if (polygon.SelfIntersections().Length > 0)
{
points.Add(point);
polygon = Polygon.ByPoints(points);
}
var surface = Surface.ByPatch(polygon);
polygon.Dispose();
points.ForEach(p => p.Dispose());
return(surface);
}
public void VisibilityFromPointColinearVerticesYAxis()
{
var a = gVertex.ByCoordinates(0, 0);
var b = gVertex.ByCoordinates(a.X + 20, a.Y);
var c = gVertex.ByCoordinates(b.X, b.Y + 10);
var d = gVertex.ByCoordinates(c.X - 10, c.Y);
var e = gVertex.ByCoordinates(d.X, d.Y + 10);
var f = gVertex.ByCoordinates(c.X, e.Y);
var g = gVertex.ByCoordinates(f.X, d.Y + 10);
var h = gVertex.ByCoordinates(a.X, g.Y);
gPolygon polygon = gPolygon.ByVertices(new List <gVertex>()
{
a, b, c, d, e, f, g, h
}, true);
Graph baseGraph = new Graph(new List <gPolygon>()
{
polygon
});
List <gVertex> vertices = VisibilityGraph.VertexVisibility(b, baseGraph);
Assert.NotNull(vertices);
}
public void TwoInAConeLargerOffset()
{
var obstacles = new List <Polyline>();
var direction = new Point(0, 1);
var vg = new VisibilityGraph();
var points = new List <Point> {
new Point(0, 0),
new Point(0.1, 10),
new Point(-0.1, 20)
};
var ports = new Set <Point>();
ports.Insert(points[0]);
ports.Insert(points[1]);
ports.Insert(points[2]);
Polyline border = null;
LineSweeper.Sweep(
obstacles,
direction,
Math.PI / 6,
vg,
ports,
border
);
Assert.AreEqual(vg.Edges.Count(), 2);
var orig = vg.FindVertex(points[0]);
var outOrig = new List <VisibilityEdge>(orig.OutEdges);
Assert.AreEqual(outOrig.Count, 1);
var v10 = vg.FindVertex(points[1]);
Assert.AreEqual(v10.OutEdges.Count(), 1);
//Assert.IsTrue(vg.FindEdge(
}
internal MultipleSourceMultipleTargetsShortestPathOnVisibilityGraph(IEnumerable <VisibilityVertex> sourceVisVertices,
IEnumerable <VisibilityVertex> targetVisVertices, VisibilityGraph visibilityGraph)
{
_visGraph = visibilityGraph;
visibilityGraph.ClearPrevEdgesTable();
foreach (var v in visibilityGraph.Vertices())
{
v.Distance = Double.PositiveInfinity;
}
sources = sourceVisVertices;
targets = new Set <VisibilityVertex>(targetVisVertices);
}
static internal IEnumerable <AxisEdge> WalkGraphEdgesInTopologicalOrderIfPossible(VisibilityGraph visibilityGraph)
{
//Here the visibility graph is always a DAG since the edges point only to North and East
// where possible
var sourcesQueue = new Queue <VisibilityVertex>();
var inDegreeLeftUnprocessed = new Dictionary <VisibilityVertex, int>();
InitQueueOfSources(sourcesQueue, inDegreeLeftUnprocessed, visibilityGraph);
while (sourcesQueue.Count > 0)
{
var visVertex = sourcesQueue.Dequeue();
foreach (var edge in visVertex.OutEdges)
{
var incomingEdges = inDegreeLeftUnprocessed[edge.Target]--;
if (incomingEdges == 1)//it is already zero in the dictionary; all incoming edges have been processed
{
sourcesQueue.Enqueue(edge.Target);
}
yield return((AxisEdge)edge);
}
}
}
static void InitQueueOfSources(Queue <VisibilityVertex> queue, IDictionary <VisibilityVertex, int> dictionary, VisibilityGraph graph)
{
foreach (var v in graph.Vertices())
{
int inDegree = v.InEdges.Count;
dictionary[v] = inDegree;
if (inDegree == 0)
{
queue.Enqueue(v);
}
}
Debug.Assert(queue.Count > 0);
}
static internal VisibilityEdge FindNextEdge(VisibilityGraph vg, VisibilityVertex vertex, Directions dir)
{
VisibilityVertex nextVertex = FindNextVertex(vertex, dir);
return((null == nextVertex) ? null : vg.FindEdge(vertex.Point, nextVertex.Point));
}
static internal void Assert(bool condition, string message, ObstacleTree obstacleTree, VisibilityGraph vg)
{
if (!condition)
{
Test_DumpVisibilityGraph(obstacleTree, vg);
Debug.Assert(condition, message);
}
}
public AStarPathFinder(VisibilityGraph visibilityGraph)
{
_visibilityGraph = visibilityGraph;
}
public VisibilityGraphForm(HexagonalMap map)
{
_visibilityGraph = new VisibilityGraph(map);
_graphDrawer = new HexagonalMapDrawer(_visibilityGraph.VisGraph);
InitializeComponent();
}
void CalculateTangentVisibilityGraph()
{
_visGraph = VisibilityGraph.GetVisibilityGraphForShortestPath(
SourcePoint, TargetPoint, obstacleCalculator.LooseObstacles, out sourceVisibilityVertex,
out targetVisibilityVertex);
}
void AddDirection(Point direction, Polyline borderPolyline, VisibilityGraph visibilityGraph)
{
LineSweeper.Sweep(_obstacles, direction, coneAngle, visibilityGraph, Ports, borderPolyline);
}
internal LgPathRouter()
{
_visGraph = new VisibilityGraph();
}
internal ConeSpanner(IEnumerable <Polyline> obstacles, VisibilityGraph visibilityGraph)
{
this._obstacles = VisibilityGraph.OrientHolesClockwise(obstacles);
this._visibilityGraph = visibilityGraph;
}
public SteinerCdt(VisibilityGraph visGraph, IEnumerable <LgNodeInfo> nodeInfos)
{
_visGraph = visGraph;
_nodeInfos = nodeInfos;
MakeSureThatNodeBoundariesAreInVisGraph(nodeInfos);
}
