r5py 0.1.2__py3-none-any.whl → 1.0.0__py3-none-any.whl

r5py/__init__.py

@@ -2,22 +2,28 @@
 
 """Python wrapper for the R5 routing analysis engine."""
 
-__version__ = "0.1.2"
+__version__ = "1.0.0"
 
 
 from .r5 import (
+    DetailedItineraries,
     DetailedItinerariesComputer,
+    Isochrones,
     RegionalTask,
     TransportMode,
     TransportNetwork,
+    TravelTimeMatrix,
     TravelTimeMatrixComputer,
 )
 
 __all__ = [
+    "DetailedItineraries",
     "DetailedItinerariesComputer",
+    "Isochrones",
     "RegionalTask",
     "TransportMode",
     "TransportNetwork",
+    "TravelTimeMatrix",
     "TravelTimeMatrixComputer",
     "__version__",
 ]

r5py/r5/__init__.py

@@ -4,9 +4,10 @@
 
 from .access_leg import AccessLeg
 from .breakdown_stat import BreakdownStat
-from .detailed_itineraries_computer import DetailedItinerariesComputer
+from .detailed_itineraries import DetailedItineraries, DetailedItinerariesComputer
 from .direct_leg import DirectLeg
 from .egress_leg import EgressLeg
+from .isochrones import Isochrones
 from .regional_task import RegionalTask
 from .scenario import Scenario
 from .street_layer import StreetLayer
@@ -14,16 +15,18 @@ from .transfer_leg import TransferLeg
 from .transit_leg import TransitLeg
 from .transport_mode import TransportMode
 from .transport_network import TransportNetwork
-from .travel_time_matrix_computer import TravelTimeMatrixComputer
+from .travel_time_matrix import TravelTimeMatrix, TravelTimeMatrixComputer
 from .trip import Trip
 from .trip_planner import TripPlanner
 
 __all__ = [
     "AccessLeg",
     "BreakdownStat",
+    "DetailedItineraries",
     "DetailedItinerariesComputer",
     "DirectLeg",
     "EgressLeg",
+    "Isochrones",
     "RegionalTask",
     "Scenario",
     "SpeedConfig",
@@ -32,6 +35,7 @@ __all__ = [
     "TransitLeg",
     "TransportMode",
     "TransportNetwork",
+    "TravelTimeMatrix",
     "TravelTimeMatrixComputer",
     "Trip",
     "TripPlanner",

r5py/r5/{base_travel_time_matrix_computer.py → base_travel_time_matrix.py}

@@ -6,6 +6,7 @@ import math
 import multiprocessing
 import warnings
 
+import geopandas
 import numpy
 import shapely
 
@@ -14,7 +15,7 @@ from .regional_task import RegionalTask
 from .transport_network import TransportNetwork
 
 
-__all__ = ["BaseTravelTimeMatrixComputer"]
+__all__ = ["BaseTravelTimeMatrix"]
 
 
 # R5 fills cut-off (NULL) values with MAX_INT32
@@ -26,13 +27,26 @@ MAX_INT32 = (2**31) - 1
 NUM_THREADS = math.ceil(multiprocessing.cpu_count() * 0.5)
 
 
-class BaseTravelTimeMatrixComputer:
+class BaseTravelTimeMatrix(geopandas.GeoDataFrame):
     """Base class for travel time computers between many origins and destinations."""
 
     MAX_INT32 = MAX_INT32
 
     NUM_THREADS = NUM_THREADS
 
+    _r5py_attributes = [
+        "_destinations",
+        "_destinations_crs",
+        "_origins",
+        "_origins_crs",
+        "destinations",
+        "origins",
+        "request",
+        "snap_to_network",
+        "transport_network",
+        "verbose",
+    ]
+
     def __init__(
         self,
         transport_network,
@@ -71,6 +85,8 @@ class BaseTravelTimeMatrixComputer:
             ``max_time_cycling``, ``max_time_driving``, ``speed_cycling``, ``speed_walking``,
             ``max_public_transport_rides``, ``max_bicycle_traffic_stress``
         """
+        geopandas.GeoDataFrame.__init__(self)
+
         if not isinstance(transport_network, TransportNetwork):
             transport_network = TransportNetwork(*transport_network)
         self.transport_network = transport_network
@@ -89,6 +105,13 @@ class BaseTravelTimeMatrixComputer:
 
         self.verbose = Config().arguments.verbose
 
+    def __setattr__(self, attr, val):
+        """Catch our own attributes here so we don’t mess with (geo)pandas columns."""
+        if attr in self._r5py_attributes:
+            object.__setattr__(self, attr, val)
+        else:
+            super().__setattr__(attr, val)
+
     @property
     def destinations(self):
         """The destinations of this travel time matrix (`geopandas.GeoDataFrame`)."""
@@ -159,8 +182,6 @@ class BaseTravelTimeMatrixComputer:
 
                 setattr(self, f"_{which_end}", points.copy())
 
-            self.snap_to_network = False  # prevent repeated snapping on same point sets
-
     @property
     def origins(self):
         """The origins of this travel time matrix (`geopandas.GeoDataFrame`)."""

r5py/r5/{detailed_itineraries_computer.py → detailed_itineraries.py}

@@ -7,23 +7,33 @@
 import copy
 import warnings
 
+try:
+    from warnings import deprecated
+except ImportError:  # Python<=3.12
+    from typing_extensions import deprecated
+
 import geopandas
 import joblib
 import pandas
 
-from .base_travel_time_matrix_computer import BaseTravelTimeMatrixComputer
+from .base_travel_time_matrix import BaseTravelTimeMatrix
 from .trip import Trip
 from .trip_planner import ACCURATE_GEOMETRIES, TripPlanner
 
 
-__all__ = ["DetailedItinerariesComputer"]
+__all__ = ["DetailedItineraries", "DetailedItinerariesComputer"]
 
 
-class DetailedItinerariesComputer(BaseTravelTimeMatrixComputer):
+class DetailedItineraries(BaseTravelTimeMatrix):
     """Compute detailed itineraries between many origins and destinations."""
 
     COLUMNS = ["from_id", "to_id", "option"] + Trip.COLUMNS
 
+    _r5py_attributes = BaseTravelTimeMatrix._r5py_attributes + [
+        "all_to_all",
+        "od_pairs",
+    ]
+
     def __init__(
         self,
         transport_network,
@@ -36,6 +46,10 @@ class DetailedItinerariesComputer(BaseTravelTimeMatrixComputer):
         """
         Compute travel times between many origins and destinations.
 
+        ``r5py.DetailedItineraries`` are child classes of
+        ``geopandas.GeoDataFrame`` and support all of their methods and
+        properties, see https://geopandas.org/en/stable/docs.html
+
         Arguments
         ---------
         transport_network : r5py.TransportNetwork | tuple(str, list(str), dict)
@@ -58,10 +72,10 @@ class DetailedItinerariesComputer(BaseTravelTimeMatrixComputer):
             if `int`, use `snap_to_network` meters as the search radius.
         force_all_to_all : bool, default False
             If ``origins`` and ``destinations`` have the same length, by
-            default, ``DetailedItinerariesComputer`` finds routes between pairs
+            default, ``DetailedItineraries`` finds routes between pairs
             of origins and destinations, i.e., it routes from origin #1 to
             destination #1, origin #2 to destination #2, ... .
-            Set ``all_to_all=True`` to route from each origin to all
+            Set ``force_all_to_all=True`` to route from each origin to all
             destinations (this is the default, if ``origins`` and ``destinations``
             have different lengths, or if ``destinations`` is omitted)
         **kwargs : mixed
@@ -70,7 +84,7 @@ class DetailedItinerariesComputer(BaseTravelTimeMatrixComputer):
             ``access_modes``, ``egress_modes``, ``max_time``, ``max_time_walking``,
             ``max_time_cycling``, ``max_time_driving``, ``speed_cycling``, ``speed_walking``,
             ``max_public_transport_rides``, ``max_bicycle_traffic_stress``
-            Not that not all arguments might make sense in this context, and the
+            Note that not all arguments might make sense in this context, and the
             underlying R5 engine might ignore some of them.
         """
         super().__init__(
@@ -106,7 +120,23 @@ class DetailedItinerariesComputer(BaseTravelTimeMatrixComputer):
         else:
             self.all_to_all = force_all_to_all
 
-    def compute_travel_details(self):
+        data = self._compute()
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                message=(
+                    "You are adding a column named 'geometry' to a GeoDataFrame "
+                    "constructed without an active geometry column"
+                ),
+                category=FutureWarning,
+            )
+            for column in data.columns:
+                self[column] = data[column]
+            self.set_geometry("geometry")
+
+        del self.transport_network
+
+    def _compute(self):
         """
         Compute travel times from all origins to all destinations.
 
@@ -114,15 +144,20 @@ class DetailedItinerariesComputer(BaseTravelTimeMatrixComputer):
         -------
         geopandas.GeoDataFrame
             The resulting detailed routes. For each origin/destination pair,
+            multiple route alternatives (‘options’) might be reported that each
+            consist of one or more segments. Each segment represents one row.
             multiple route alternatives (‘options’) might be reported that each consist of
             one or more segments. Each segment represents one row.
+
             The data frame comprises of the following columns: `from_id`,
             `to_id`, `option` (`int`), `segment` (`int`), `transport_mode`
             (`r5py.TransportMode`), `departure_time` (`datetime.datetime`),
             `distance` (`float`, metres), `travel_time` (`datetime.timedelta`),
-            `wait_time` (`datetime.timedelta`), `route` (`str`, public transport
-            route number or name), `geometry` (`shapely.LineString`)
-            TODO: Add description of output data frame columns and format
+            `wait_time` (`datetime.timedelta`), `feed` (`str`, the feed name
+            used), `agency_id` (`str` the public transport agency identifier),
+            `route_id` (`str`, public transport route ID), `start_stop_id`
+            (`str`, the GTFS stop_id for boarding), `end_stop_id` (`str`, the
+            GTFS stop_id for alighting), `geometry` (`shapely.LineString`)
         """
         self._prepare_origins_destinations()
 
@@ -204,3 +239,34 @@ class DetailedItinerariesComputer(BaseTravelTimeMatrixComputer):
         # fmt: on
 
         return pandas.DataFrame(trips, columns=self.COLUMNS)
+
+
+@deprecated(
+    "Use `DetailedItineraries` instead, `DetailedItinerariesComputer will be deprecated in a future release."
+)
+class DetailedItinerariesComputer:
+    """Compute detailed itineraries between many origins and destinations."""
+
+    def __init__(self, *args, **kwargs):
+        """Compute detailed itineraries between many origins and destinations."""
+        self._detailed_itineraries = DetailedItineraries(*args, **kwargs)
+
+    def compute_travel_details(self):
+        """
+        Compute travel times from all origins to all destinations.
+
+        Returns
+        -------
+        geopandas.GeoDataFrame
+            The resulting detailed routes. For each origin/destination pair,
+            multiple route alternatives (‘options’) might be reported that each consist of
+            one or more segments. Each segment represents one row.
+            The data frame comprises of the following columns: `from_id`,
+            `to_id`, `option` (`int`), `segment` (`int`), `transport_mode`
+            (`r5py.TransportMode`), `departure_time` (`datetime.datetime`),
+            `distance` (`float`, metres), `travel_time` (`datetime.timedelta`),
+            `wait_time` (`datetime.timedelta`), `route` (`str`, public transport
+            route number or name), `geometry` (`shapely.LineString`)
+            TODO: Add description of output data frame columns and format
+        """
+        return self._detailed_itineraries

r5py/r5/isochrones.py

@@ -0,0 +1,351 @@
+#!/usr/bin/env python3
+
+
+"""Compute polygons of equal travel time from a destination."""
+
+
+import datetime
+import warnings
+
+import geohexgrid
+import geopandas
+import pandas
+import pyproj
+import shapely
+import simplification.cutil
+
+from .base_travel_time_matrix import BaseTravelTimeMatrix
+from .transport_mode import TransportMode
+from .travel_time_matrix import TravelTimeMatrix
+from ..util import GoodEnoughEquidistantCrs, SpatiallyClusteredGeoDataFrame
+
+
+__all__ = ["Isochrones"]
+
+
+EMPTY_POINT = shapely.Point()
+R5_CRS = "EPSG:4326"
+
+CONCAVE_HULL_BUFFER_SIZE = 20.0  # metres
+CONCAVE_HULL_RATIO = 0.3
+
+VERY_SMALL_BUFFER_SIZE = 0.001  # turn points into polygons
+
+
+class Isochrones(BaseTravelTimeMatrix):
+    """Compute polygons of equal travel time from a destination."""
+
+    _r5py_attributes = BaseTravelTimeMatrix._r5py_attributes + [
+        "_isochrones",
+        "isochrones",
+        "point_grid_resolution",
+        "point_grid_sample_ratio",
+    ]
+
+    def __init__(
+        self,
+        transport_network,
+        origins,
+        isochrones=pandas.timedelta_range(
+            start=datetime.timedelta(minutes=0),
+            end=datetime.timedelta(hours=1),
+            freq=datetime.timedelta(minutes=15),
+        ),
+        point_grid_resolution=100,
+        point_grid_sample_ratio=1.0,
+        **kwargs,
+    ):
+        """
+        Compute polygons of equal travel time from one or more destinations.
+
+        ``r5py.Isochrones`` are child classes of ``geopandas.GeoDataFrame`` and
+        support all of their methods and properties, see
+        https://geopandas.org/en/stable/docs.html
+
+        Arguments
+        ---------
+        transport_network : r5py.TransportNetwork | tuple(str, list(str), dict)
+            The transport network to route on. This can either be a readily
+            initialised r5py.TransportNetwork or a tuple of the parameters
+            passed to ``TransportNetwork.__init__()``: the path to an OpenStreetMap
+            extract in PBF format, a list of zero of more paths to GTFS transport
+            schedule files, and a dict with ``build_config`` options.
+        origins : geopandas.GeoDataFrame | shapely.Point
+            Place(s) to find a route _from_
+            Must be/have a point geometry. If multiple origin points are passed,
+            isochrones will be computed as minimum travel time from any of them.
+        isochrones : pandas.TimedeltaIndex | collections.abc.Iterable[int]
+            For which interval to compute isochrone polygons. An iterable of
+            integers is interpreted as minutes.
+        point_grid_resolution : int
+            Distance in meters between points in the regular grid of points laid over the
+            transport network’s extent that is used to compute isochrones.
+            Increase this value for performance, decrease it for precision.
+        point_grid_sample_ratio : float
+            Share of points of the point grid that are used in computation,
+            ranging from 0.01 to 1.0.
+            Increase this value for performance, decrease it for precision.
+        **kwargs : mixed
+            Any arguments than can be passed to r5py.RegionalTask:
+            ``departure``, ``departure_time_window``, ``percentiles``, ``transport_modes``,
+            ``access_modes``, ``egress_modes``, ``max_time``, ``max_time_walking``,
+            ``max_time_cycling``, ``max_time_driving``, ``speed_cycling``, ``speed_walking``,
+            ``max_public_transport_rides``, ``max_bicycle_traffic_stress``
+            Note that not all arguments might make sense in this context, and the
+            underlying R5 engine might ignore some of them.
+            If percentiles are specified, the lowest one will be used for
+            isochrone computation.
+        """
+        geopandas.GeoDataFrame.__init__(self)
+        BaseTravelTimeMatrix.__init__(
+            self,
+            transport_network,
+            **kwargs,
+        )
+
+        self.EQUIDISTANT_CRS = GoodEnoughEquidistantCrs(self.transport_network.extent)
+
+        if isinstance(origins, shapely.Geometry):
+            origins = geopandas.GeoDataFrame(
+                {
+                    "id": [
+                        "origin",
+                    ],
+                    "geometry": [
+                        origins,
+                    ],
+                },
+                crs=R5_CRS,
+            )
+        self.origins = origins
+        self.isochrones = isochrones
+
+        self.point_grid_resolution = point_grid_resolution
+        self.point_grid_sample_ratio = max(0.01, min(1.0, point_grid_sample_ratio))
+
+        travel_times = TravelTimeMatrix(
+            transport_network,
+            origins=self.origins,
+            destinations=self.destinations,
+            max_time=self.isochrones.max(),
+            **kwargs,
+        )
+
+        data = self._compute_isochrones_from_travel_times(travel_times)
+
+        with warnings.catch_warnings():
+            warnings.filterwarnings(
+                "ignore",
+                message=(
+                    "You are adding a column named 'geometry' to a GeoDataFrame "
+                    "constructed without an active geometry column"
+                ),
+                category=FutureWarning,
+            )
+            for column in data.columns:
+                self[column] = data[column]
+            self.set_geometry("geometry")
+
+        del self.transport_network
+
+    def _compute_isochrones_from_travel_times(self, travel_times):
+        travel_times = travel_times.dropna().groupby("to_id").min().reset_index()
+
+        if self.request.percentiles == [50]:
+            travel_time_column = "travel_time"
+        else:
+            travel_time_column = f"travel_time_p{self.request.percentiles[0]:d}"
+
+        isochrones = {
+            "travel_time": [],
+            "geometry": [],
+        }
+
+        for isochrone in self.isochrones:
+            reached_nodes = (
+                self.destinations.set_index("id")
+                .join(
+                    travel_times[
+                        travel_times[travel_time_column]
+                        <= (isochrone.total_seconds() / 60)
+                    ].set_index("to_id"),
+                    how="inner",
+                )
+                .reset_index()
+            )
+
+            # isochrone polygons might be disjoint (e.g., around metro stops)
+            if not reached_nodes.empty:
+                reached_nodes = SpatiallyClusteredGeoDataFrame(
+                    reached_nodes, eps=(2.0 * self.point_grid_resolution)
+                ).to_crs(self.EQUIDISTANT_CRS)
+                isochrone_polygons = pandas.concat(
+                    [
+                        (
+                            reached_nodes[reached_nodes["cluster"] != -1]
+                            .dissolve(by="cluster")
+                            .concave_hull(ratio=CONCAVE_HULL_RATIO)
+                            .buffer(VERY_SMALL_BUFFER_SIZE)
+                        ),
+                        (
+                            reached_nodes[reached_nodes["cluster"] == -1].buffer(
+                                VERY_SMALL_BUFFER_SIZE
+                            )
+                        ),
+                    ]
+                ).union_all()
+
+                isochrones["travel_time"].append(isochrone)
+                isochrones["geometry"].append(isochrone_polygons)
+
+        isochrones = geopandas.GeoDataFrame(
+            isochrones, geometry="geometry", crs=self.EQUIDISTANT_CRS
+        )
+
+        # clip smaller isochrones by larger isochrones
+        # (concave_hull’s ratio parameter depends on input shapes and does not
+        # produce the same results, e.g., around bridges or at the coast line)
+        for row in range(len(isochrones) - 2, 0, -1):
+            isochrones.loc[row, "geometry"] = shapely.intersection(
+                isochrones.loc[row, "geometry"], isochrones.loc[row + 1, "geometry"]
+            )
+
+        isochrones["geometry"] = (
+            isochrones["geometry"]
+            .buffer(CONCAVE_HULL_BUFFER_SIZE)
+            .boundary.apply(
+                lambda geometry: (
+                    geometry
+                    if isinstance(geometry, shapely.MultiLineString)
+                    else shapely.MultiLineString([geometry])
+                )
+            )
+            .apply(
+                lambda multilinestring: (
+                    shapely.MultiLineString(
+                        [
+                            simplification.cutil.simplify_coords_vwp(
+                                linestring.coords,
+                                self.point_grid_resolution * 5.0,
+                            )
+                            for linestring in multilinestring.geoms
+                        ]
+                    )
+                )
+            )
+            .to_crs(R5_CRS)
+        )
+
+        return isochrones
+
+    @property
+    def destinations(self):
+        """A regular grid of points covering the range of the chosen transport mode."""
+        try:
+            return self._destinations
+        except AttributeError:
+            destinations = self._regular_point_grid
+            destinations["geometry"] = self.transport_network.snap_to_network(
+                destinations["geometry"]
+            )
+            destinations = destinations[destinations["geometry"] != EMPTY_POINT]
+            destinations["geometry"] = destinations["geometry"].normalize()
+            destinations = destinations.drop_duplicates()
+
+            # with snapping, sometimes we end up with clumps of points
+            # below, we try to form clusters, from all clusters we retain
+            # one geometry, only
+            destinations = SpatiallyClusteredGeoDataFrame(
+                destinations, eps=(0.5 * self.point_grid_resolution)
+            )
+            destinations = pandas.concat(
+                [
+                    (
+                        destinations[destinations["cluster"] != -1]
+                        .groupby("cluster")
+                        .first()
+                        .set_crs(R5_CRS)
+                    ),
+                    destinations[destinations["cluster"] == -1],
+                ]
+            )[["id", "geometry"]].copy()
+
+            if self.point_grid_sample_ratio < 1.0:
+                destinations = destinations.sample(frac=self.point_grid_sample_ratio)
+
+            self._destinations = destinations
+
+            return destinations
+
+    @destinations.setter
+    def destinations(self, destinations):
+        # https://bugs.python.org/issue14965
+        super(self.__class__, self.__class__).destinations.__set__(self, destinations)
+
+    @property
+    def isochrones(self):
+        """
+        Compute isochrones for these travel times.
+
+        pandas.TimedeltaIndex | collections.abc.Iterable[int]
+        An iterable of integers is interpreted as minutes.
+        """
+        try:
+            return self._isochrones
+        except AttributeError:
+            raise
+
+    @isochrones.setter
+    def isochrones(self, isochrones):
+        if not isinstance(isochrones, pandas.TimedeltaIndex):
+            isochrones = pandas.to_timedelta(isochrones, unit="minutes")
+        try:
+            # do not compute for 0 travel time
+            isochrones = isochrones.drop(datetime.timedelta(0))
+        except KeyError:
+            pass
+        self._isochrones = isochrones
+
+    @property
+    def _regular_point_grid(self):
+        extent = shapely.ops.transform(
+            pyproj.Transformer.from_crs(
+                R5_CRS,
+                self.EQUIDISTANT_CRS,
+                always_xy=True,
+            ).transform,
+            self.transport_network.extent,
+        )
+
+        grid = geohexgrid.make_grid_from_bounds(
+            *extent.bounds,
+            self.point_grid_resolution,
+            crs=self.EQUIDISTANT_CRS,
+        )
+        grid["geometry"] = grid["geometry"].centroid
+        grid["id"] = grid.index
+        grid = grid[["id", "geometry"]].to_crs(R5_CRS)
+
+        # for walking and cycling, we can clip the extent to an area reachable
+        # by the (well-defined) travel speeds:
+        if set(self.request.transport_modes) <= set(
+            (TransportMode.WALK, TransportMode.BICYCLE)
+        ):
+            if TransportMode.WALK in self.request.transport_modes:
+                speed = self.request.speed_walking
+            if TransportMode.BICYCLE in self.request.transport_modes:
+                speed = self.request.speed_cycling
+
+            speed = speed * (1000.0 / 3600.0) * 1.1  # km/h -> m/s, plus a bit of buffer
+
+            grid = grid.clip(
+                (
+                    pandas.concat([self.origins] * 2)  # workaround until
+                    # https://github.com/pyproj4/pyproj/issues/1309 is fixed
+                    .to_crs(self.EQUIDISTANT_CRS)
+                    .buffer(speed * max(self.isochrones).total_seconds())
+                    .to_crs(R5_CRS)
+                )
+            )
+
+        return grid.copy()

r5py/r5/regional_task.py

@@ -53,11 +53,11 @@ class RegionalTask:
         A RegionalTask wraps a `com.conveyal.r5.analyst.cluster.RegionalTask`,
         which is used to specify the details of a requested computation.
         RegionalTasks underlie virtually all major computations carried out,
-        such as, e.g., `TravelTimeMatrixComputer` or `AccessibilityEstimator`.
+        such as, e.g., `TravelTimeMatrix` or `AccessibilityEstimator`.
 
         In **r5py**, there is usually no need to explicitely create a
         `RegionalTask`. Rather, the constructors to the computation classes
-        (`TravelTimeMatrixComputer`, `AccessibilityEstimator`, ...) accept the
+        (`TravelTimeMatrix`, `AccessibilityEstimator`, ...) accept the
         arguments, and pass them through to an internally handled
         `RegionalTask`.
 

r5py/r5/street_layer.py

@@ -22,6 +22,9 @@ __all__ = ["StreetLayer"]
 start_jvm()
 
 
+EMPTY_POINT = shapely.Point()
+
+
 class StreetLayer:
     """Wrap a com.conveyal.r5.streets.StreetLayer."""
 
@@ -72,13 +75,14 @@ class StreetLayer:
             Closest location on the street network or `POINT EMPTY` if no
             such location could be found within `radius`
         """
-        if split := self._street_layer.findSplit(point.y, point.x, radius, street_mode):
+        try:
+            split = self._street_layer.findSplit(point.y, point.x, radius, street_mode)
             return shapely.Point(
                 split.fixedLon / com.conveyal.r5.streets.VertexStore.FIXED_FACTOR,
                 split.fixedLat / com.conveyal.r5.streets.VertexStore.FIXED_FACTOR,
             )
-        else:
-            return shapely.Point()
+        except (AttributeError, TypeError):
+            return EMPTY_POINT
 
 
 @jpype._jcustomizer.JConversion(