v2.4.1 bugfix networkx A* failure

Author: jannikmi

.pre-commit-config.yaml

@@ -57,7 +57,7 @@ repos:
     rev: "0.48"
     hooks:
       - id: check-manifest
-        args: [ "--no-build-isolation", "--ignore",  "*.png,docs/*,publish.py,readthedocs.yml,poetry.lock,setup.py" ]
+        args: [ "--no-build-isolation", "--ignore",  "*.png,docs/*,publish.py,readthedocs.yml,poetry.lock,setup.py,scripts/*" ]
         additional_dependencies: [ numpy, poetry==1.1.11 ]
 
   - repo: https://github.com/asottile/pyupgrade

CHANGELOG.rst

@@ -6,6 +6,21 @@ TODOs
 * pending major release: remove separate prepare step?! initialise in one step during initialisation
 * Numba JIT compilation of utils. line speed profiling for highest impact of refactoring
 * allow input of complex geometries: input coords, and edges separately (polygons are special case)
+* drop simplify parameter
+
+2.4.1 (2022-08-22)
+-------------------
+
+* bugfix: catch the case where no path is possible in the graph in the ``networkx`` A* implementation
+* added speed benchmarks and performance section in the documentation with benchmark results
+
+internal:
+
+* optimisation: checking edges with the biggest angle range first
+* optimisation: skipping visibility checks for the last extremity
+* using optimised point in polygon check algorithm
+* using undirected Graph: The precomputed graph usually makes up the majority of the visibility graph (in comparison to the temporarily added edges for query start and goal nodes) and this precomputed part has to be undirected. Use undirected graph everywhere.
+* added test cases
 
 
 2.4.0 (2022-08-18)

docs/7_performance.rst

@@ -0,0 +1,23 @@
+
+Performance
+===========
+
+
+.. _speed-tests:
+
+Speed Benchmark Results
+-----------------------
+
+obtained on MacBook Pro (15-inch, 2017), 2,8 GHz Intel Core i7 and `extremitypathfinder` version ``2.4.1`` using the script
+``scripts/speed_benchmarks.py``
+
+
+::
+
+    speed_benchmarks.py::test_env_preparation_speed PASSED                   [ 50%]
+    avg. environment preparation time 7.4e-03 s/run, 1.4e+02 runs/s
+    averaged over 1,000 runs
+
+    speed_benchmarks.py::test_query_speed PASSED                             [100%]
+    avg. query time 7.1e-04 s/run, 1.4e+03 runs/s
+    averaged over 1,000 runs

docs/index.rst

@@ -20,6 +20,7 @@ python package for geometric shortest path computation in 2D multi-polygon or gr
     Usage <1_usage>
     About <3_about>
     API <4_api>
+    Performance <6_performance>
     Contributing <5_contributing>
     Changelog <6_changelog>
 

extremitypathfinder/configs.py

@@ -1,14 +1,3 @@
-from typing import Iterable, List, Optional, Tuple, Union
-
-import numpy as np
-
-COORDINATE_TYPE = Tuple[float, float]
-PATH_TYPE = List[COORDINATE_TYPE]
-LENGTH_TYPE = Optional[float]
-INPUT_NUMERICAL_TYPE = Union[float, int]
-InputCoords = Tuple[INPUT_NUMERICAL_TYPE, INPUT_NUMERICAL_TYPE]
-OBSTACLE_ITER_TYPE = Iterable[InputCoords]
-INPUT_COORD_LIST_TYPE = Union[np.ndarray, List]
 DEFAULT_PICKLE_NAME = "environment.pickle"
 
 # command line interface

extremitypathfinder/extremitypathfinder.py

@@ -4,14 +4,9 @@
 import networkx as nx
 import numpy as np
 
-from extremitypathfinder.configs import (
-    DEFAULT_PICKLE_NAME,
-    INPUT_COORD_LIST_TYPE,
-    LENGTH_TYPE,
-    OBSTACLE_ITER_TYPE,
-    PATH_TYPE,
-    InputCoords,
-)
+from extremitypathfinder import types as t
+from extremitypathfinder.configs import DEFAULT_PICKLE_NAME
+from extremitypathfinder.types import InputCoord, InputCoordList, Length, ObstacleIterator, Path
 from extremitypathfinder.utils import (
     check_data_requirements,
     cmp_reps_n_distances,
@@ -43,9 +38,9 @@ class PolygonEnvironment:
     holes: List[np.ndarray]
     extremity_indices: List[int]
     reprs_n_distances: Dict[int, np.ndarray]
-    graph: nx.DiGraph
+    graph: t.Graph
     # TODO
-    temp_graph: Optional[nx.DiGraph] = None  # for storing and plotting the graph during a query
+    temp_graph: Optional[t.Graph] = None  # for storing and plotting the graph during a query
     boundary_polygon: np.ndarray
     coords: np.ndarray
     edge_vertex_idxs: np.ndarray
@@ -68,8 +63,8 @@ def all_vertices(self) -> List[Tuple]:
 
     def store(
         self,
-        boundary_coordinates: INPUT_COORD_LIST_TYPE,
-        list_of_hole_coordinates: INPUT_COORD_LIST_TYPE,
+        boundary_coordinates: InputCoordList,
+        list_of_hole_coordinates: InputCoordList,
         validate: bool = False,
     ):
         """saves the passed input polygons in the environment
@@ -155,7 +150,7 @@ def store_grid_world(
         self,
         size_x: int,
         size_y: int,
-        obstacle_iter: OBSTACLE_ITER_TYPE,
+        obstacle_iter: ObstacleIterator,
         simplify: bool = True,
         validate: bool = False,
     ):
@@ -247,11 +242,11 @@ def get_visible_idxs(
 
     def find_shortest_path(
         self,
-        start_coordinates: InputCoords,
-        goal_coordinates: InputCoords,
+        start_coordinates: InputCoord,
+        goal_coordinates: InputCoord,
         free_space_after: bool = True,
         verify: bool = True,
-    ) -> Tuple[PATH_TYPE, LENGTH_TYPE]:
+    ) -> Tuple[Path, Length]:
         """computes the shortest path and its length between start and goal node
 
         :param start_coordinates: a (x,y) coordinate tuple representing the start node
@@ -317,7 +312,10 @@ def find_shortest_path(
         # graph = self.graph
         # nr_edges_before = len(graph.edges)
 
-        # add unidirectional edges in the direction: extremity (v) -> goal
+        # add edges: extremity (i) <-> goal
+        # Note: also here unnecessary edges in the graph could be deleted
+        # optimising the graph here however is more expensive than beneficial,
+        # as the graph is only being used for a single query
         for i in visibles_goal:
             graph.add_edge(i, goal, weight=vert_idx2dist[i])
 
@@ -333,16 +331,10 @@ def find_shortest_path(
             # The start node does not have any neighbours. Hence there is no possible path to the goal.
             return [], None
 
-        # add edges in the direction: start -> extremity
-        # Note: also here unnecessary edges in the graph could be deleted
-        # optimising the graph here however is more expensive than beneficial,
-        # as the graph is only being used for a single query
+        # add edges: start <-> extremity (i)
         for i in visibles_start:
             graph.add_edge(start, i, weight=vert_idx2dist[i])
 
-        def l2_distance(n1, n2):
-            return get_distance(n1, n2, self.reprs_n_distances)
-
         # apply mapping to start and goal index as well
         start_mapped = find_identical_single(start, graph.nodes, self.reprs_n_distances)
         if start_mapped != start:
@@ -354,7 +346,13 @@ def l2_distance(n1, n2):
 
         self._idx_start_tmp, self._idx_goal_tmp = start_mapped, goal_mapped  # for plotting
 
-        id_path = nx.astar_path(graph, start_mapped, goal_mapped, heuristic=l2_distance, weight="weight")
+        def l2_distance(n1, n2):
+            return get_distance(n1, n2, self.reprs_n_distances)
+
+        try:
+            id_path = nx.astar_path(graph, start_mapped, goal_mapped, heuristic=l2_distance, weight="weight")
+        except nx.exception.NetworkXNoPath:
+            return [], None
 
         # clean up
         # TODO re-use the same graph. need to keep track of all merged edges

extremitypathfinder/plotting.py

@@ -3,9 +3,9 @@
 from os.path import abspath, exists, join
 
 import matplotlib.pyplot as plt
-import networkx as nx
 from matplotlib.patches import Polygon
 
+from extremitypathfinder import types as t
 from extremitypathfinder.extremitypathfinder import PolygonEnvironment
 
 EXPORT_RESOLUTION = 200  # dpi
@@ -123,7 +123,7 @@ def draw_prepared_map(map):
         plt.show()
 
 
-def draw_with_path(map, graph: nx.DiGraph, vertex_path):
+def draw_with_path(map, graph: t.Graph, vertex_path):
     fig, ax = plt.subplots()
 
     coords = map._coords_tmp
@@ -172,7 +172,7 @@ def draw_only_path(map, vertex_path, start_coordinates, goal_coordinates):
         plt.show()
 
 
-def draw_graph(map, graph: nx.DiGraph):
+def draw_graph(map, graph: t.Graph):
     fig, ax = plt.subplots()
 
     nodes = graph.nodes

extremitypathfinder/types.py

@@ -0,0 +1,13 @@
+from typing import Iterable, List, Optional, Tuple, Union
+
+import networkx as nx
+import numpy as np
+
+Coordinate = Tuple[float, float]
+Path = List[Coordinate]
+Length = Optional[float]
+InputNumerical = Union[float, int]
+InputCoord = Tuple[InputNumerical, InputNumerical]
+InputCoordList = Union[np.ndarray, List[InputCoord]]
+ObstacleIterator = Iterable[InputCoord]
+Graph = nx.Graph