SCI/FreeSCI/Pathfinding/Algorithms

Algorithms

In this section we discuss the algorithms that were considered and motivate our final choice. We describe the pathfinding algorithms in the Pathfinding section and the polygon containment algorithms in Polygon containment section.

Pathfinding

We learnt by observation that the input size generally does not exceed 100 nodes. At these small input sizes the asymptotic performance of an algorithm is not very significant. We decided that we did not want to sacrifice ease of implementation for an algorithm with better asymptotic behavior. We also decided to limit ourselves to true shortest path solutions, as we want Ego to take the shortest path to his destination. An optimal O(n log n) shortest path algorithm was discovered by Hershberger and Suri , but it is too complex to implement in such a short time frame. Simpler algorithms exist that are based on visibility graphs. For a polygon set P a visibility graph G contains all vertices of the polygons in P. The start and end point are added to G.G has an edge between two vertices v and w if the line (v, w) does not intersect the interior of any polygon in P. Once the visibility graph has been constructed the shortest path can be found by using an algorithm for determining the shortest path in a graph, such as Dijkstra’s algorithm. The visibility graph on n vertices contains n² edges in the worst case. This means that any shortest path algorithm based on visibility graphs will have at least O(n²) running time. The trivial algorithm determines the visibility of two vertices v and w by testing for an intersection between the line (v, w) and all edges in the input set, leading to O(n³) running time.

Optimal O(n²) visibility graph algorithms based on arrangements have been found .

Ghosh and Mount discovered an output sensitive O(E + n log n) algorithm , where E is the number of edges in the visibility graph. We finally opted to use an O(n₂ log n) algorithm by Lee. This algorithm is relatively easy to implement and is fast enough for the small input sizes we are dealing with in this application.

The algorithm iterates over the vertices and determines for each vertex v the set of vertices that is visible from v. The basic idea is to rotate a sweeping line clockwise around v. All edges that are currently intersected by the sweeping line are maintained in a tree T which is updated as the line rotates. The edges in T are ordered by distance from v. The sweeping line is implemented by sorting the vertices by angle around v and then processing them in that order.

For each vertex w in the sorted list the visibility is computed and T is updated by removing edges incident to w in anticlockwise direction, and adding edges incident to w in clockwise direction. Vertex w is visible if the following two conditions hold. The first condition is that the line (v, w) does not intersect the inside of the polygon of which w is a vertex, locally at w. The second is that the edge in T closest to v does not properly intersect the line (v, w). There are a few degenerate cases which we will not discuss here. A more in-depth discussion of this algorithm can be found in .

Polygon containment

For a point p and a possibly non-convex polygon P we need to be able to determine whether p is contained in P. One common method for solving this problem is the winding number approach. The winding number of a point p and a polygon P is the number of times P winds around p. For simple polygons this number is 1 when p is contained in P and 0 when p is not contained in P. We decided not to use this method based on a claim in that it is very inefficient.

However, we recently found claims to the contrary . In hindsight dismissing this method was premature.

The method we used is called the ray crossings approach. This method is based on counting the number of times a ray extending right from p intersects the boundary of P. p is contained in P if the number of ray crossings is odd.

In its basic form this algorithm considers points on bottom and left edges to be contained in P, and points on top and right edges not to be contained in P.

This property is desirable for some applications, but as we have seen in Section 3.4, we need a point on any edge of P to be considered to be contained in P. In order to overcome this we used an extended version of this algorithm that has the semantics we require.