cost-matrix 0.1.0__py3-none-any.whl

cost_matrix/__init__.py

@@ -0,0 +1,4 @@
+from .euclidean_matrix import euclidean  # noqa F401
+from .manhattan_matrix import manhattan  # noqa F401
+from .osrm_matrix import osrm  # noqa F401
+from .spherical_matrix import spherical  # noqa F401

cost_matrix/euclidean_matrix.py

@@ -0,0 +1,5 @@
+import numpy as np
+
+
+def euclidean(sources: np.ndarray, destinations: np.ndarray) -> np.ndarray:
+    return np.linalg.norm(sources - destinations, axis=1)

cost_matrix/manhattan_matrix.py

@@ -0,0 +1,5 @@
+import numpy as np
+
+
+def manhattan(sources: np.ndarray, destinations: np.ndarray) -> np.ndarray:
+    return np.sum(np.abs(sources - destinations), axis=1)

cost_matrix/osrm_matrix.py

@@ -0,0 +1,136 @@
+from math import ceil
+
+import numpy as np
+import requests
+
+
+def osrm(
+    sources: np.ndarray,
+    destinations: np.ndarray,
+    server_address: str = "http://router.project-osrm.org",
+    batch_size: int = 150,
+    cost_type: str = "distances",
+) -> np.ndarray:
+    """Compute the OSRM cost matrix between sources and destinations"""
+
+    num_sources = sources.shape[0]
+    num_destinations = destinations.shape[0]
+    cost_matrix = np.zeros((num_sources, num_destinations))
+
+    num_batches_i = ceil(num_sources / batch_size)
+    num_batches_j = ceil(num_destinations / batch_size)
+
+    for i in range(num_batches_i):
+        start_i = i * batch_size
+        end_i = min((i + 1) * batch_size, num_sources)
+
+        for j in range(num_batches_j):
+            start_j = j * batch_size
+            end_j = min((j + 1) * batch_size, num_destinations)
+            sources_batch = sources[start_i:end_i]
+            destinations_batch = destinations[start_j:end_j]
+
+            cost_matrix[start_i:end_i, start_j:end_j] = (
+                _get_batch_osrm_distance(
+                    sources_batch,
+                    destinations_batch,
+                    server_address,
+                    cost_type=cost_type,
+                )
+            )
+
+    return cost_matrix
+
+
+def _get_batch_osrm_distance(
+    sources_batch: np.ndarray,
+    destinations_batch: np.ndarray,
+    server_address: str,
+    cost_type: str,
+):
+    """Request the OSRM cost matrix for a given batch"""
+
+    url = _format_osrm_url(
+        sources_batch, destinations_batch, server_address, cost_type
+    )
+    resp = requests.get(url)
+    resp.raise_for_status()
+
+    return np.array(resp.json()[cost_type])
+
+
+def _format_osrm_url(
+    sources_batch: np.ndarray,
+    destinations_batch: np.ndarray,
+    server_address: str,
+    cost_type: str,
+) -> str:
+    """Format OSRM url string with sources and destinations
+
+    Notes
+    -----
+    Consider the N sources in the form
+        (lat_src1, lgn_src1), (lat_src2, lgn_src2), ...
+
+    and the M destinations in the form
+        (lat_dest1, lgn_dest1), (lat_dest2, lgn_dest2), ...
+
+    This function converts these properties in a URL of the form
+        {OSRM_SERVER_ADDRESS}/table/v1/driving/
+        lng_src1,lat_src1;lng_src2,lat_src2;...;lng_srcN,lat_srcN;
+        lng_dest1,lat_dest1;lng_dest2,lat_dest2;...;lng_destM,lng_destM
+        ?sources=0;1;...;N-1
+        &destinations=N;N+1;...;N+M-1
+        &annotations=distance
+
+    In the simpler case when sources == destinations, the URL is simplified to
+        {OSRM_SERVER_ADDRESS}/table/v1/driving/
+        lng_src1,lat_src1;lng_src2,lat_src2;...;lng_srcN,lat_srcN
+        ?annotations=distance
+
+    Obs: Replace "distance" with "duration" if a time matrix is required
+    Obs2: The matrix type follows the singular form in the URL (e.g.,
+    "distance"), but the returned JSON follows the plural form (e.g.,
+    "distances"). Thus, we ignore the last letter of the input type
+    """
+
+    url_cost_type = cost_type[:-1]
+    sources_coord = ";".join(
+        f"{source[1]},{source[0]}" for source in sources_batch
+    )
+
+    # If sources == destinations, return a simpler URL early. Notice it needs
+    # at least two points, otherwise OSRM complains
+    if (
+        np.array_equal(sources_batch, destinations_batch)
+        and sources_batch.shape[0] > 1
+    ):
+        return (
+            f"{server_address}/table/v1/driving/"
+            f"{sources_coord}"
+            f"?annotations={url_cost_type}"
+        )
+
+    destinations_coord = ";".join(
+        f"{destination[1]},{destination[0]}"
+        for destination in destinations_batch
+    )
+    locations_coord = sources_coord + ";" + destinations_coord
+
+    # Get indices of sources and destinations in the form
+    # sources = 0,1,...,N' and destinations = N'+1,N'+2...N'+M'
+    num_sources = sources_batch.shape[0]
+    num_destinations = destinations_batch.shape[0]
+
+    sources_indices = ";".join(str(index) for index in range(num_sources))
+    destinations_indices = ";".join(
+        str(index)
+        for index in range(num_sources, num_sources + num_destinations)
+    )
+
+    return (
+        f"{server_address}/table/v1/driving/"
+        f"{locations_coord}"
+        f"?sources={sources_indices}&destinations={destinations_indices}"
+        f"&annotations={url_cost_type}"
+    )

cost_matrix/spherical_matrix.py

@@ -0,0 +1,31 @@
+import numpy as np
+
+EARTH_RADIUS_METERS = 6371000
+
+
+def spherical(sources: np.ndarray, destinations: np.ndarray) -> np.ndarray:
+    """Distance matrix using the Spherical distance"""
+
+    sources_rad = np.radians(sources)
+    destinations_rad = np.radians(destinations)
+
+    delta_lambda = sources_rad[:, [1]] - destinations_rad[:, 1]  # (N x M) lng
+    phi1 = sources_rad[:, [0]]  # (N x 1) array of source latitudes
+    phi2 = destinations_rad[:, 0]  # (1 x M) array of destination latitudes
+
+    delta_sigma = np.arctan2(
+        np.sqrt(
+            (np.cos(phi2) * np.sin(delta_lambda)) ** 2
+            + (
+                np.cos(phi1) * np.sin(phi2)
+                - np.sin(phi1) * np.cos(phi2) * np.cos(delta_lambda)
+            )
+            ** 2
+        ),
+        (
+            np.sin(phi1) * np.sin(phi2)
+            + np.cos(phi1) * np.cos(phi2) * np.cos(delta_lambda)
+        ),
+    )
+
+    return EARTH_RADIUS_METERS * delta_sigma

cost_matrix-0.1.0.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.1
+Name: cost-matrix
+Version: 0.1.0
+Summary: Designed to simplify the creation of cost matrices for optimization problems.
+Author: Luan
+Author-email: llvdmoraes@gmail.com
+Requires-Python: >=3.9,<3.13
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: requests (>=2.32.3,<3.0.0)
+Description-Content-Type: text/markdown
+
+# cost-matrix
+
+`cost-matrix` is a Python package designed to simplify the creation of cost matrices for optimization problems. Whether you're dealing with distance calculations or travel durations, `cost-matrix` provides a robust set of tools to meet your needs.
+
+This package is invaluable for anyone working on optimization problems, data analysis, or transportation planning. With its diverse range of distance calculation methods and integration with OSRM, it provides a comprehensive solution for generating cost matrices efficiently.
+
+## Key Features:
+- **Manhattan**: Compute distances based on orthogonal paths.
+- **Euclidean**: Calculate straight-line distances in a Cartesian plane.
+- **Spherical**: Calculate distances between geographical points considering the Earth's curvature.
+- **OSRM**: Integrate with the Open Source Routing Machine (OSRM) to obtain travel duration or distance matrices.
+
+## Installation
+
+To install the `cost-matrix` package, you can use pip:
+
+```sh
+pip install cost-matrix
+```
+
+
+## Example Usage:
+```python
+import numpy as np
+import cost_matrix
+
+# Define source and destination coordinates (latitude, longitude)
+sources = np.array([[37.7749, -122.4194], [34.0522, -118.2437]])  # San Francisco, Los Angeles
+destinations = np.array([[40.7128, -74.0060], [51.5074, -0.1278]])  # New York, London
+
+# Calculate Manhattan distance matrix
+manhattan_matrix = cost_matrix.manhattan(sources, destinations)
+print(manhattan_matrix)
+
+# Calculate Euclidean distance matrix
+euclidean_matrix = cost_matrix.euclidean(sources, destinations)
+print(euclidean_matrix)
+
+# Calculate Spherical distance matrix
+spherical_matrix = cost_matrix.spherical(sources, destinations)
+print(spherical_matrix)
+
+# Calculate OSRM travel distances matrix
+osrm_distance_matrix = cost_matrix.osrm(sources, destinations)
+print(osrm_distance_matrix)
+
+# Calculate OSRM travel durations matrix
+osrm_duration_matrix = cost_matrix.osrm(
+    sources, 
+    destinations, 
+    cost_type="durations", 
+    server_address="http://localhost:5000",
+    batch_size=250
+)
+print(osrm_duration_matrix)
+

cost_matrix-0.1.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+cost_matrix/__init__.py,sha256=9EaPsXe0SIuym34-CPmzUPSGJuBd2AkQZHqjcwlUywE,202
+cost_matrix/euclidean_matrix.py,sha256=a8uLh0COVb5duaKV6DMfG9HklkJX2dOARKfnnWxLxsc,155
+cost_matrix/manhattan_matrix.py,sha256=bWTTiIgvb0PDWSdfCXuffHEIgb9nNMb4w7Qwhe3EbaQ,155
+cost_matrix/osrm_matrix.py,sha256=VuuoQVRGxMjoN_eUfs9yur9lwINg8JZxB3SX-6cvBFk,4327
+cost_matrix/spherical_matrix.py,sha256=SxaihjkKyrp0den5w-VsimGcjjQEi-q-_cvxeTM3xyY,946
+cost_matrix-0.1.0.dist-info/METADATA,sha256=4TVrFT0TlklV7jcvRAJarKqi-TE2_TPMtSJJtVZTmIQ,2676
+cost_matrix-0.1.0.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+cost_matrix-0.1.0.dist-info/RECORD,,

cost_matrix-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 1.9.0
+Root-Is-Purelib: true
+Tag: py3-none-any