simplified the bbox creation

backend/src/utils/get_time_separation.py

@@ -48,3 +48,35 @@ def get_time(p1: tuple[float, float], p2: tuple[float, float]) -> int:
     walk_time = walk_distance / AVERAGE_WALKING_SPEED * 60
 
     return round(walk_time)
+
+
+def get_distance(p1: tuple[float, float], p2: tuple[float, float]) -> int:
+    """
+    Calculate the time in minutes to travel from one location to another.
+
+    Args:
+        p1 (Tuple[float, float]): Coordinates of the starting location.
+        p2 (Tuple[float, float]): Coordinates of the destination.
+
+        Returns:
+        int: Time to travel from p1 to p2 in minutes.
+    """
+
+
+    if p1 == p2:
+        return 0
+    else:
+        # Compute the distance in km along the surface of the Earth
+        # (assume spherical Earth)
+        # this is the haversine formula, stolen from stackoverflow
+        # in order to not use any external libraries
+        lat1, lon1 = radians(p1[0]), radians(p1[1])
+        lat2, lon2 = radians(p2[0]), radians(p2[1])
+
+        dlon = lon2 - lon1
+        dlat = lat2 - lat1
+
+        a = sin(dlat / 2)**2 + cos(lat1) * cos(lat2) * sin(dlon / 2)**2
+        c = 2 * atan2(sqrt(a), sqrt(1 - a))
+
+        return EARTH_RADIUS_KM * c

backend/src/utils/landmarks_manager.py

@@ -79,7 +79,8 @@ class LandmarkManager:
         # use set to avoid duplicates, this requires some __methods__ to be set in Landmark
         all_landmarks = set()
 
-        bbox = self.create_bbox(center_coordinates, reachable_bbox_side)
+        # Create a bbox using the around
+        bbox = tuple((f"around:{reachable_bbox_side/2}", str(center_coordinates[0]), str(center_coordinates[1])))
         # list for sightseeing
         if preferences.sightseeing.score != 0:
             score_function = lambda score: score * 10 * preferences.sightseeing.score / 5
@@ -97,7 +98,7 @@ class LandmarkManager:
             score_function = lambda score: score * 10 * preferences.shopping.score / 5
             current_landmarks = self.fetch_landmarks(bbox, self.amenity_selectors['shopping'], preferences.shopping.type, score_function)
             # set time for all shopping activites :
-            for landmark in current_landmarks : landmark.duration = 45
+            for landmark in current_landmarks : landmark.duration = 30
             all_landmarks.update(current_landmarks)
 
 
@@ -151,36 +152,24 @@ class LandmarkManager:
             return 0
 
 
-    def create_bbox(self, coordinates: tuple[float, float], reachable_bbox_side: int) -> tuple[float, float, float, float]:
-        """
-        Create a bounding box around the given coordinates.
+    # def create_bbox(self, coordinates: tuple[float, float], reachable_bbox_side: int) -> tuple[float, float, float, float]:
+    #     """
+    #     Create a bounding box around the given coordinates.
 
-        Args:
-            coordinates (tuple[float, float]): The latitude and longitude of the center of the bounding box.
-            reachable_bbox_side (int): The side length of the bounding box in meters.
+    #     Args:
+    #         coordinates (tuple[float, float]): The latitude and longitude of the center of the bounding box.
+    #         reachable_bbox_side (int): The side length of the bounding box in meters.
 
-        Returns:
-            tuple[float, float, float, float]: The minimum latitude, minimum longitude, maximum latitude, and maximum longitude
-                                                defining the bounding box.
-        """
-        
-        lat = coordinates[0]
-        lon = coordinates[1]
+    #     Returns:
+    #         tuple[float, float, float, float]: The minimum latitude, minimum longitude, maximum latitude, and maximum longitude
+    #                                             defining the bounding box.
+    #     """
 
-        # Half the side length in km (since it's a square bbox)
-        half_side_length_km = reachable_bbox_side / 2 / 1000
+    #     # Half the side length in m (since it's a square bbox)
+    #     half_side_length_m = reachable_bbox_side / 2
 
-        # Convert distance to degrees
-        lat_diff = half_side_length_km / 111  # 1 degree latitude is approximately 111 km
-        lon_diff = half_side_length_km / (111 * math.cos(math.radians(lat)))  # Adjust for longitude based on latitude
+    #     return tuple((f"around:{half_side_length_m}", str(coordinates[0]), str(coordinates[1])))
 
-        # Calculate bbox
-        min_lat = lat - lat_diff
-        max_lat = lat + lat_diff
-        min_lon = lon - lon_diff
-        max_lon = lon + lon_diff
-
-        return min_lat, min_lon, max_lat, max_lon
 
 
     def fetch_landmarks(self, bbox: tuple, amenity_selector: dict, landmarktype: str, score_function: callable) -> list[Landmark]:
@@ -212,7 +201,9 @@ class LandmarkManager:
         for sel in dict_to_selector_list(amenity_selector):
             self.logger.debug(f"Current selector: {sel}")
 
-            query_conditions = ['count_tags()>5']
+            # query_conditions = ['count_tags()>5']
+            # if landmarktype == 'shopping' :       # use this later for shopping clusters
+            #     element_types = ['node']
             element_types = ['way', 'relation']
 
             if 'viewpoint' in sel :