PDL : get minutes from distance implementation and tests / euclidian distance to km

app/travel_resolver/libs/pathfinder/heuristic.py

@@ -1,6 +1,7 @@
 import math
+import travel_resolver.libs.pathfinder.variables as var
 
-def euclidean_distance(lat1 : float, lon1 : float, lat2 : float, lon2 : float):
+def euclidean_distance(lat1 : float, lon1 : float, lat2 : float, lon2 : float) -> float:
     """
     Calculate the Euclidean distance between two points given by their latitudes and longitudes.
     The coordinates are in degrees.
@@ -11,7 +12,7 @@ def euclidean_distance(lat1 : float, lon1 : float, lat2 : float, lon2 : float):
             lon2 (float): Longitude of the first point.
 
         Returns:
-            (float): The Euclidean distance (radians) between the two points.
+            (float): The Euclidean distance (kilometers) between the two points.
     """
     # Conversion des degrés en radians
     lat1, lon1 = math.radians(lat1), math.radians(lon1)
@@ -24,9 +25,9 @@ def euclidean_distance(lat1 : float, lon1 : float, lat2 : float, lon2 : float):
     # Distance euclidienne (approximation plane)
     distance = math.sqrt(delta_lat**2 + delta_lon**2)
     
-    return distance
+    return distance*var.EARTH_RADIUS
 
-def haversine_distance(lat1 : float, lon1 : float, lat2 : float, lon2 : float):
+def haversine_distance(lat1 : float, lon1 : float, lat2 : float, lon2 : float) -> float:
     """
     Calculates the distance as the crow flies between two points on the Earth
     (coordinates specified in degrees) using the Haversine formula.
@@ -39,9 +40,6 @@ def haversine_distance(lat1 : float, lon1 : float, lat2 : float, lon2 : float):
         Returns:
             (float): The distance as the crow flies (kilometers) between the two points.
     """
-    # Rayon de la Terre en kilomètres
-    R = 6371.0
-    
     # Conversion des degrés en radians
     lat1, lon1 = math.radians(lat1), math.radians(lon1)
     lat2, lon2 = math.radians(lat2), math.radians(lon2)
@@ -55,6 +53,22 @@ def haversine_distance(lat1 : float, lon1 : float, lat2 : float, lon2 : float):
     c = 2 * math.atan2(math.sqrt(a), math.sqrt(1 - a))
     
     # Distance à vol d'oiseau
-    distance = R * c
+    distance = var.EARTH_RADIUS * c
     
     return distance
+
+def get_minutes_from_distance(distance : float, needConversion : bool) -> float:
+    """
+    Get minutes estimation from heuristic distance computed by in kilometers or radians
+    Args:
+            distance (float): The converted distance.
+            needConversion (bool): Determine if conversion is needed.
+                If true, this distance is in kilometers.
+                Else, it is in radians.
+
+        Returns:
+            (float): The approximated minutes needed to travel the given distance.
+    """
+    speed : float = var.AVERAGE_KM_H_TRAIN_SPEED if needConversion else var.AVERAGE_RAD_MIN_TRAIN_SPEED
+    conversionRatio : float = 60 if needConversion else 1
+    return (distance/speed)*conversionRatio

app/travel_resolver/libs/pathfinder/variables.py

@@ -0,0 +1,3 @@
+AVERAGE_KM_H_TRAIN_SPEED = 100
+AVERAGE_RAD_MIN_TRAIN_SPEED = 0.000261
+EARTH_RADIUS = 6371

app/travel_resolver/tests/heuristic_test.py

@@ -1,5 +1,5 @@
 import unittest
-from travel_resolver.libs.pathfinder.heuristic import euclidean_distance,haversine_distance
+from travel_resolver.libs.pathfinder.heuristic import haversine_distance,get_minutes_from_distance,euclidean_distance
 
 class TestHeuristic(unittest.TestCase):
 
@@ -7,15 +7,27 @@ class TestHeuristic(unittest.TestCase):
         self.latParis, self.lonParis = 48.8566, 2.3522
         self.latLyon, self.lonLyon = 45.7640, 4.8357
 
-    def test_euclidian_distance(self):
-        expected_distance = 0.06922589910147367
+    def test_euclidean_distance(self):
+        expected_distance = 441.0382031754888
         distance = euclidean_distance(self.latParis, self.lonParis, self.latLyon, self.lonLyon)
         self.assertEqual(distance, expected_distance)
 
-    def test_haversin_distance(self):
+    def test_haversine_distance(self):
         expected_distance = 391.4989316742569
         distance = haversine_distance(self.latParis, self.lonParis, self.latLyon, self.lonLyon)
         self.assertEqual(distance, expected_distance)
 
+    def test_get_minutes_from_distance(self):
+        expected_time_euclidean = 264.62292190529325
+        euclidean_dist = euclidean_distance(self.latParis, self.lonParis, self.latLyon, self.lonLyon)
+        time_from_euclidean_distance = get_minutes_from_distance(euclidean_dist,True)
+
+        expected_time_haversine = 234.89935900455413
+        haversine_dist = haversine_distance(self.latParis, self.lonParis, self.latLyon, self.lonLyon)
+        time_from_haversine_distance = get_minutes_from_distance(haversine_dist,True)
+
+        self.assertEqual(time_from_euclidean_distance, expected_time_euclidean)
+        self.assertEqual(time_from_haversine_distance, expected_time_haversine)
+
 if __name__ == '__main__':
     unittest.main()