anydev/anyway
anydev/anyway
0
0
Fork 0
Code Issues Pull Requests 3 Actions Packages Projects Releases Wiki Activity

style corrections, documentation, duplicate removal, flow improvement

Browse Source
This commit is contained in:
Remy Moll 2024-07-25 17:15:18 +02:00
parent 80b3d5b012
commit 2863c99d7c
12 changed files with 314 additions and 348 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
backend/src/constants.py
View File

@ -14,6 +14,6 @@ OSM_CACHE_DIR = Path(cache_dir_string)
logger = logging.getLogger(__name__)
logging.basicConfig(
level = logging.DEBUG,
level = logging.INFO,
format = '%(asctime)s - %(name)s\t- %(levelname)s\t- %(message)s'
)

47
backend/src/main.py
View File

@ -1,16 +1,20 @@
from backend.src.example_optimizer import solve_optimization
# from refiner import refine_optimization
from landmarks_manager import LandmarkManager
from structs.landmarks import Landmark
from structs.landmarktype import LandmarkType
from structs.preferences import Preferences
import logging
from fastapi import FastAPI, Query, Body
from structs.landmark import Landmark
from structs.preferences import Preferences
from structs.linked_landmarks import LinkedLandmarks
from utils.landmarks_manager import LandmarkManager
from utils.optimizer import Optimizer
from utils.refiner import Refiner
logger = logging.getLogger(__name__)
app = FastAPI()
manager = LandmarkManager()
# TODO: needs a global variable to store the landmarks accross function calls
# linked_tour = []
optimizer = Optimizer()
refiner = Refiner(optimizer=optimizer)
@app.post("/route/new")
@ -22,19 +26,23 @@ def main1(preferences: Preferences, start: tuple[float, float], end: tuple[float
:param end: the coordinates of the finishing point as a tuple of floats (as url query parameters)
:return: the uuid of the first landmark in the optimized route
'''
if preferences is None :
if preferences is None:
raise ValueError("Please provide preferences in the form of a 'Preference' BaseModel class.")
if start is None:
raise ValueError("Please provide the starting coordinates as a tuple of floats.")
if end is None:
end = start
logger.info("No end coordinates provided. Using start=end.")
start_landmark = Landmark(name='start', type='start', location=(start[0], start[1]), osm_type='start', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
end_landmark = Landmark(name='end', type='end', location=(end[0], end[1]), osm_type='end', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
start_landmark = Landmark(name='start', type=LandmarkType(landmark_type='start'), location=(start[0], start[1]), osm_type='start', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
end_landmark = Landmark(name='end', type=LandmarkType(landmark_type='end'), location=(end[0], end[1]), osm_type='end', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
# Generate the landmarks from the start location
landmarks, landmarks_short = LandmarkManager.get_landmark_lists(preferences=preferences, coordinates=start.location)
print([l.name for l in landmarks_short])
landmarks, landmarks_short = manager.generate_landmarks_list(
center_coordinates = start,
preferences = preferences
)
# insert start and finish to the landmarks list
landmarks_short.insert(0, start_landmark)
landmarks_short.append(end_landmark)
@ -44,14 +52,13 @@ def main1(preferences: Preferences, start: tuple[float, float], end: tuple[float
detour = 30 # minutes
# First stage optimization
base_tour = solve_optimization(landmarks_short, max_walking_time*60, True)
base_tour = optimizer.solve_optimization(max_walking_time*60, landmarks_short)
# Second stage optimization
# refined_tour = refine_optimization(landmarks, base_tour, max_walking_time*60+detour, True)
refined_tour = refiner.refine_optimization(landmarks, base_tour, max_walking_time*60, detour)
# linked_tour = ...
# return linked_tour[0].uuid
return base_tour[0].uuid
linked_tour = LinkedLandmarks(refined_tour)
return linked_tour[0].uuid

1
backend/src/parameters/optimizer_parameters.yaml
View File

@ -1,3 +1,4 @@
detour_factor: 1.4
detour_corridor_width: 200
average_walking_speed: 4.8
max_landmarks: 7

3
backend/src/structs/landmarks.py → backend/src/structs/landmark.py
View File

@ -33,5 +33,6 @@ class Landmark(BaseModel) :
return self.uuid.int
def __str__(self) -> str:
return f'Landmark: [{self.name}, {self.location}, {self.attractiveness}]'
time_to_next_str = f", time_to_next={self.time_to_reach_next}" if self.time_to_reach_next else ""
return f'Landmark({self.type}): [{self.name} @{self.location}, score={self.attractiveness}{time_to_next_str}]'

48
backend/src/structs/linked_landmarks.py Normal file
View File

@ -0,0 +1,48 @@
import uuid
from .landmark import Landmark
from utils.get_time_separation import get_time
class LinkedLandmarks:
"""
A list of landmarks that are linked together, e.g. in a route.
Each landmark serves as a node in the linked list, but since we expect these to be consumed through the rest API, a pythonic reference to the next landmark is not well suited. Instead we use the uuid of the next landmark to reference the next landmark in the list. This is not very efficient, but appropriate for the expected use case ("short" trips with onyl few landmarks).
"""
_landmarks = list[Landmark]
total_time = int
uuid = str
def __init__(self, data: list[Landmark] = None) -> None:
"""
Initialize a new LinkedLandmarks object. This expects an ORDERED list of landmarks, where the first landmark is the starting point and the last landmark is the end point.
Args:
data (list[Landmark], optional): The list of landmarks that are linked together. Defaults to None.
"""
self.uuid = uuid.uuid4()
self._landmarks = data if data else []
self._link_landmarks()
def _link_landmarks(self) -> None:
"""
Create the links between the landmarks in the list by setting their .next_uuid and the .time_to_next attributes.
"""
self.total_time = 0
for i, landmark in enumerate(self._landmarks[:-1]):
landmark.next_uuid = self._landmarks[i + 1].uuid
time_to_next = get_time(landmark.location, self._landmarks[i + 1].location)
landmark.time_to_reach_next = time_to_next
self.total_time += time_to_next
self._landmarks[-1].next_uuid = None
self._landmarks[-1].time_to_reach_next = 0
def __getitem__(self, index: int) -> Landmark:
return self._landmarks[index]
def __str__(self) -> str:
return f"LinkedLandmarks, total time: {self.total_time} minutes, {len(self._landmarks)} stops: [\n\t{'\n\t'.join([str(landmark) for landmark in self._landmarks])}\n]"

32
backend/src/tester.py
View File

@ -1,17 +1,19 @@
import pandas as pd
from typing import List
from landmarks_manager import LandmarkManager
import logging
from fastapi.encoders import jsonable_encoder
from optimizer import Optimizer
from refiner import Refiner
from structs.landmarks import Landmark
from utils.landmarks_manager import LandmarkManager
from utils.optimizer import Optimizer
from utils.refiner import Refiner
from structs.landmark import Landmark
from structs.linked_landmarks import LinkedLandmarks
from structs.preferences import Preferences, Preference
logger = logging.getLogger(__name__)
# Helper function to create a .txt file with results
def write_data(L: List[Landmark], file_name: str):
def write_data(L: list[Landmark], file_name: str):
data = pd.DataFrame()
i = 0
@ -23,8 +25,10 @@ def write_data(L: List[Landmark], file_name: str):
data.to_json(file_name, indent = 2, force_ascii=False)
def test(start_coords: tuple[float, float], finish_coords: tuple[float, float] = None) -> List[Landmark]:
def test(start_coords: tuple[float, float], finish_coords: tuple[float, float] = None) -> list[Landmark]:
manager = LandmarkManager()
optimizer = Optimizer()
refiner = Refiner(optimizer=optimizer)
preferences = Preferences(
@ -42,7 +46,7 @@ def test(start_coords: tuple[float, float], finish_coords: tuple[float, float] =
score = 5),
max_time_minute=180,
detour_tolerance_minute=0
detour_tolerance_minute=30
)
# Create start and finish
@ -71,15 +75,15 @@ def test(start_coords: tuple[float, float], finish_coords: tuple[float, float] =
landmarks_short.append(finish)
# First stage optimization
optimizer = Optimizer(max_time=preferences.max_time_minute, landmarks=landmarks_short)
base_tour = optimizer.solve_optimization()
base_tour = optimizer.solve_optimization(max_time=preferences.max_time_minute, landmarks=landmarks_short)
# Second stage using linear optimization
refiner = Refiner(max_time = preferences.max_time_minute, detour = preferences.detour_tolerance_minute)
refined_tour = refiner.refine_optimization(all_landmarks=landmarks, base_tour=base_tour)
refined_tour = refiner.refine_optimization(all_landmarks=landmarks, base_tour=base_tour, max_time = preferences.max_time_minute, detour = preferences.detour_tolerance_minute)
linked_tour = LinkedLandmarks(refined_tour)
logger.info(f"Optimized route: {linked_tour}")
return refined_tour
return linked_tour
#test(tuple((48.8344400, 2.3220540))) # Café Chez César

106
backend/src/utils.py
View File

@ -1,106 +0,0 @@
import yaml
from typing import List, Tuple
from geopy.distance import geodesic
from structs.landmarks import Landmark
import constants
def get_time(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.
detour (float): Detour factor affecting the distance.
speed (float): Walking speed in kilometers per hour.
Returns:
int: Time to travel from p1 to p2 in minutes.
"""
with constants.OPTIMIZER_PARAMETERS_PATH.open('r') as f:
parameters = yaml.safe_load(f)
detour_factor = parameters['detour_factor']
average_walking_speed = parameters['average_walking_speed']
# Compute the straight-line distance in km
if p1 == p2 :
return 0
else:
dist = geodesic(p1, p2).kilometers
# Consider the detour factor for average cityto deterline walking distance (in km)
walk_dist = dist*detour_factor
# Time to walk this distance (in minutes)
walk_time = walk_dist/average_walking_speed*60
return round(walk_time)
# Same as link_list but does it on a already ordered list
def link_list_simple(ordered_visit: List[Landmark])-> List[Landmark] :
L = []
j = 0
total_dist = 0
while j < len(ordered_visit)-1 :
elem = ordered_visit[j]
next = ordered_visit[j+1]
elem.next_uuid = next.uuid
d = get_time(elem.location, next.location)
elem.time_to_reach_next = d
if elem.name not in ['start', 'finish'] :
elem.must_do = True
L.append(elem)
j += 1
total_dist += d
L.append(next)
return L, total_dist
# Take the most important landmarks from the list
def take_most_important(landmarks: List[Landmark], N_important) -> List[Landmark] :
L = len(landmarks)
L_copy = []
L_clean = []
scores = [0]*len(landmarks)
names = []
name_id = {}
for i, elem in enumerate(landmarks) :
if elem.name not in names :
names.append(elem.name)
name_id[elem.name] = [i]
L_copy.append(elem)
else :
name_id[elem.name] += [i]
scores = []
for j in name_id[elem.name] :
scores.append(L[j].attractiveness)
best_id = max(range(len(scores)), key=scores.__getitem__)
t = name_id[elem.name][best_id]
if t == i :
for old in L_copy :
if old.name == elem.name :
old.attractiveness = L[t].attractiveness
scores = [0]*len(L_copy)
for i, elem in enumerate(L_copy) :
scores[i] = elem.attractiveness
res = sorted(range(len(scores)), key = lambda sub: scores[sub])[-(N_important-L):]
for i, elem in enumerate(L_copy) :
if i in res :
L_clean.append(elem)
return L_clean

39
backend/src/utils/get_time_separation.py Normal file
View File

@ -0,0 +1,39 @@
import yaml
from geopy.distance import geodesic
import constants
with constants.OPTIMIZER_PARAMETERS_PATH.open('r') as f:
parameters = yaml.safe_load(f)
DETOUR_FACTOR = parameters['detour_factor']
AVERAGE_WALKING_SPEED = parameters['average_walking_speed']
def get_time(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.
detour (float): Detour factor affecting the distance.
speed (float): Walking speed in kilometers per hour.
Returns:
int: Time to travel from p1 to p2 in minutes.
"""
# Compute the straight-line distance in km
if p1 == p2 :
return 0
else:
dist = geodesic(p1, p2).kilometers
# Consider the detour factor for average cityto deterline walking distance (in km)
walk_dist = dist*DETOUR_FACTOR
# Time to walk this distance (in minutes)
walk_time = walk_dist/AVERAGE_WALKING_SPEED*60
return round(walk_time)

4
backend/src/landmarks_manager.py → backend/src/utils/landmarks_manager.py
View File

@ -10,8 +10,8 @@ config.put_throttle = 0
config.maxlag = 0
from structs.preferences import Preferences, Preference
from structs.landmarks import Landmark
from utils import take_most_important
from structs.landmark import Landmark
from .take_most_important import take_most_important
import constants

195
backend/src/optimizer.py → backend/src/utils/optimizer.py
View File

@ -1,12 +1,12 @@
import yaml, logging
import numpy as np
from typing import List, Tuple
from scipy.optimize import linprog
from collections import defaultdict, deque
from geopy.distance import geodesic
from structs.landmarks import Landmark
from structs.landmark import Landmark
from .get_time_separation import get_time
import constants
@ -17,17 +17,13 @@ class Optimizer:
logger = logging.getLogger(__name__)
landmarks: List[Landmark] # list of landmarks
max_time: int = None # max visit time (in minutes)
detour: int = None # accepted max detour time (in minutes)
detour_factor: float # detour factor of straight line vs real distance in cities
average_walking_speed: float # average walking speed of adult
max_landmarks: int # max number of landmarks to visit
def __init__(self, max_time: int, landmarks: List[Landmark]) :
self.max_time = max_time
self.landmarks = landmarks
def __init__(self) :
# load parameters from file
with constants.OPTIMIZER_PARAMETERS_PATH.open('r') as f:
@ -37,25 +33,6 @@ class Optimizer:
self.max_landmarks = parameters['max_landmarks']
def print_res(self, L: List[Landmark]):
"""
Print the suggested order of landmarks to visit and log the total time walked.
Args:
L (List[Landmark]): List of landmarks in the suggested visit order.
"""
self.logger.info(f'The following order is suggested : ')
dist = 0
for elem in L :
if elem.time_to_reach_next is not None :
self.logger.info(f" {elem.name}, time to next = {elem.time_to_reach_next}")
dist += elem.time_to_reach_next
else :
self.logger.info(f" {elem.name}")
self.logger.info(f'Minutes walked : {dist}')
self.logger.info(f'Visited {len(L)-2} landmarks')
# Prevent the use of a particular solution
def prevent_config(self, resx):
@ -63,10 +40,10 @@ class Optimizer:
Prevent the use of a particular solution by adding constraints to the optimization.
Args:
resx (List[float]): List of edge weights.
resx (list[float]): List of edge weights.
Returns:
Tuple[List[int], List[int]]: A tuple containing a new row for constraint matrix and new value for upper bound vector.
Tuple[list[int], list[int]]: A tuple containing a new row for constraint matrix and new value for upper bound vector.
"""
for i, elem in enumerate(resx):
@ -101,7 +78,7 @@ class Optimizer:
L (int): Number of landmarks.
Returns:
Tuple[np.ndarray, List[int]]: A tuple containing a new row for constraint matrix and new value for upper bound vector.
Tuple[np.ndarray, list[int]]: A tuple containing a new row for constraint matrix and new value for upper bound vector.
"""
l1 = [0]*L*L
@ -129,7 +106,7 @@ class Optimizer:
resx (list): List of edge weights.
Returns:
Tuple[List[int], Optional[List[List[int]]]]: A tuple containing the visit order and a list of any detected circles.
Tuple[list[int], Optional[list[list[int]]]]: A tuple containing the visit order and a list of any detected circles.
"""
# first round the results to have only 0-1 values
@ -189,34 +166,8 @@ class Optimizer:
return order, all_journeys_nodes
def get_time(self, 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.
"""
# Compute the straight-line distance in km
if p1 == p2 :
return 0
else:
dist = geodesic(p1, p2).kilometers
# Consider the detour factor for average cityto deterline walking distance (in km)
walk_dist = dist*self.detour_factor
# Time to walk this distance (in minutes)
walk_time = walk_dist/self.average_walking_speed*60
return round(walk_time)
def init_ub_dist(self, landmarks: List[Landmark], max_steps: int):
def init_ub_dist(self, landmarks: list[Landmark], max_steps: int):
"""
Initialize the objective function coefficients and inequality constraints for the optimization problem.
@ -224,11 +175,11 @@ class Optimizer:
The goal is to maximize the objective function subject to the constraints A*x < b and A_eq*x = b_eq.
Args:
landmarks (List[Landmark]): List of landmarks.
landmarks (list[Landmark]): List of landmarks.
max_steps (int): Maximum number of steps allowed.
Returns:
Tuple[List[float], List[float], List[int]]: Objective function coefficients, inequality constraint coefficients, and the right-hand side of the inequality constraint.
Tuple[list[float], list[float], list[int]]: Objective function coefficients, inequality constraint coefficients, and the right-hand side of the inequality constraint.
"""
# Objective function coefficients. a*x1 + b*x2 + c*x3 + ...
@ -240,7 +191,7 @@ class Optimizer:
dist_table = [0]*len(landmarks)
c.append(-spot1.attractiveness)
for j, spot2 in enumerate(landmarks) :
t = self.get_time(spot1.location, spot2.location)
t = get_time(spot1.location, spot2.location)
dist_table[j] = t
closest = sorted(dist_table)[:22]
for i, dist in enumerate(dist_table) :
@ -260,7 +211,7 @@ class Optimizer:
L (int): Number of landmarks.
Returns:
Tuple[np.ndarray, List[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
Tuple[np.ndarray, list[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
"""
ones = [1]*L
@ -287,7 +238,7 @@ class Optimizer:
L (int): Number of landmarks.
Returns:
Tuple[np.ndarray, List[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
Tuple[np.ndarray, list[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
"""
upper_ind = np.triu_indices(L,0,L)
@ -318,7 +269,7 @@ class Optimizer:
L (int): Number of landmarks.
Returns:
Tuple[List[np.ndarray], List[int]]: Equality constraint coefficients and the right-hand side of the equality constraints.
Tuple[list[np.ndarray], list[int]]: Equality constraint coefficients and the right-hand side of the equality constraints.
"""
l = [0]*L*L
@ -333,15 +284,15 @@ class Optimizer:
return [l], [0]
def respect_user_must_do(self, landmarks: List[Landmark]) :
def respect_user_must_do(self, landmarks: list[Landmark]) :
"""
Generate constraints to ensure that landmarks marked as 'must_do' are included in the optimization.
Args:
landmarks (List[Landmark]): List of landmarks, where some are marked as 'must_do'.
landmarks (list[Landmark]): List of landmarks, where some are marked as 'must_do'.
Returns:
Tuple[np.ndarray, List[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
Tuple[np.ndarray, list[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
"""
L = len(landmarks)
@ -359,15 +310,15 @@ class Optimizer:
return A, b
def respect_user_must_avoid(self, landmarks: List[Landmark]) :
def respect_user_must_avoid(self, landmarks: list[Landmark]) :
"""
Generate constraints to ensure that landmarks marked as 'must_avoid' are skipped in the optimization.
Args:
landmarks (List[Landmark]): List of landmarks, where some are marked as 'must_avoid'.
landmarks (list[Landmark]): List of landmarks, where some are marked as 'must_avoid'.
Returns:
Tuple[np.ndarray, List[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
Tuple[np.ndarray, list[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
"""
L = len(landmarks)
@ -394,7 +345,7 @@ class Optimizer:
L (int): Number of landmarks.
Returns:
Tuple[np.ndarray, List[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
Tuple[np.ndarray, list[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
"""
l_start = [1]*L + [0]*L*(L-1) # sets departures only for start (horizontal ones)
@ -422,7 +373,7 @@ class Optimizer:
L (int): Number of landmarks.
Returns:
Tuple[np.ndarray, List[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
Tuple[np.ndarray, list[int]]: Inequality constraint coefficients and the right-hand side of the inequality constraints.
"""
A = [0]*L*L
@ -443,16 +394,16 @@ class Optimizer:
return A, b
def link_list(self, order: List[int], landmarks: List[Landmark])->List[Landmark] :
def link_list(self, order: list[int], landmarks: list[Landmark])->list[Landmark] :
"""
Compute the time to reach from each landmark to the next and create a list of landmarks with updated travel times.
Args:
order (List[int]): List of indices representing the order of landmarks to visit.
landmarks (List[Landmark]): List of all landmarks.
order (list[int]): List of indices representing the order of landmarks to visit.
landmarks (list[Landmark]): List of all landmarks.
Returns:
List[Landmark]]: The updated linked list of landmarks with travel times
list[Landmark]]: The updated linked list of landmarks with travel times
"""
L = []
@ -463,7 +414,7 @@ class Optimizer:
next = landmarks[order[j+1]]
# get attributes
elem.time_to_reach_next = self.get_time(elem.location, next.location)
elem.time_to_reach_next = get_time(elem.location, next.location)
elem.must_do = True
elem.location = (round(elem.location[0], 5), round(elem.location[1], 5))
elem.next_uuid = next.uuid
@ -478,21 +429,28 @@ class Optimizer:
# Main optimization pipeline
def solve_optimization (self, hide_log=False) :
def solve_optimization(
self,
max_time: int,
landmarks: list[Landmark],
) -> list[Landmark]:
"""
Main optimization pipeline to solve the landmark visiting problem.
This method sets up and solves a linear programming problem with constraints to find an optimal tour of landmarks,
considering user-defined must-visit landmarks, start and finish points, and ensuring no cycles are present.
Args:
max_time (int): Maximum time allowed for the tour in minutes.
landmarks (list[Landmark]): List of landmarks to visit.
Returns:
List[Landmark]: The optimized tour of landmarks with updated travel times, or None if no valid solution is found.
list[Landmark]: The optimized tour of landmarks with updated travel times, or None if no valid solution is found.
"""
L = len(self.landmarks)
L = len(landmarks)
# SET CONSTRAINTS FOR INEQUALITY
c, A_ub, b_ub = self.init_ub_dist(self.landmarks, self.max_time) # Add the distances from each landmark to the other
c, A_ub, b_ub = self.init_ub_dist(landmarks, max_time) # Add the distances from each landmark to the other
A, b = self.respect_number(L) # Respect max number of visits (no more possible stops than landmarks).
A_ub = np.vstack((A_ub, A), dtype=np.int16)
b_ub += b
@ -503,10 +461,10 @@ class Optimizer:
# SET CONSTRAINTS FOR EQUALITY
A_eq, b_eq = self.init_eq_not_stay(L) # Force solution not to stay in same place
A, b = self.respect_user_must_do(self.landmarks) # Check if there are user_defined must_see. Also takes care of start/goal
A, b = self.respect_user_must_do(landmarks) # Check if there are user_defined must_see. Also takes care of start/goal
A_eq = np.vstack((A_eq, A), dtype=np.int8)
b_eq += b
A, b = self.respect_user_must_avoid(self.landmarks) # Check if there are user_defined must_see. Also takes care of start/goal
A, b = self.respect_user_must_avoid(landmarks) # Check if there are user_defined must_see. Also takes care of start/goal
A_eq = np.vstack((A_eq, A), dtype=np.int8)
b_eq += b
A, b = self.respect_start_finish(L) # Force start and finish positions
@ -524,51 +482,38 @@ class Optimizer:
# Raise error if no solution is found
if not res.success :
raise ArithmeticError("No solution could be found, the problem is overconstrained. Please adapt your must_dos")
raise ArithmeticError("No solution could be found, the problem is overconstrained. Please adapt your must_dos")
# If there is a solution, we're good to go, just check for connectiveness
else :
order, circles = self.is_connected(res.x)
#nodes, edges = is_connected(res.x)
i = 0
timeout = 80
while circles is not None and i < timeout:
A, b = self.prevent_config(res.x)
A_ub = np.vstack((A_ub, A))
b_ub += b
#A_ub, b_ub = prevent_circle(order, len(landmarks), A_ub, b_ub)
for circle in circles :
A, b = self.prevent_circle(circle, L)
A_eq = np.vstack((A_eq, A))
b_eq += b
res = linprog(c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq = b_eq, bounds=x_bounds, method='highs', integrality=3)
if not res.success :
raise ArithmeticError("Solving failed because of overconstrained problem")
return None
order, circles = self.is_connected(res.x)
#nodes, edges = is_connected(res.x)
i = 0
timeout = 80
while circles is not None and i < timeout:
A, b = self.prevent_config(res.x)
A_ub = np.vstack((A_ub, A))
b_ub += b
#A_ub, b_ub = prevent_circle(order, len(landmarks), A_ub, b_ub)
for circle in circles :
A, b = self.prevent_circle(circle, L)
A_eq = np.vstack((A_eq, A))
b_eq += b
res = linprog(c, A_ub=A_ub, b_ub=b_ub, A_eq=A_eq, b_eq = b_eq, bounds=x_bounds, method='highs', integrality=3)
if not res.success :
raise ArithmeticError("Solving failed because of overconstrained problem")
return None
order, circles = self.is_connected(res.x)
#nodes, edges = is_connected(res.x)
if circles is None :
break
# print(i)
i += 1
if i == timeout :
raise TimeoutError(f"Optimization took too long. No solution found after {timeout} iterations.")
# Add the times to reach and stop optimizing
tour = self.link_list(order, self.landmarks)
# logging
if not hide_log :
if i != 0 :
self.logger.info(f"Neded to recompute paths {i} times")
self.print_res(tour) # how to do better ?
self.logger.info(f"Total score : {int(-res.fun)}")
return tour
if circles is None :
break
# print(i)
i += 1
if i == timeout :
raise TimeoutError(f"Optimization took too long. No solution found after {timeout} iterations.")
#sort the landmarks in the order of the solution
tour = [landmarks[i] for i in order]
self.logger.debug(f"Re-optimized {i} times, score: {int(-res.fun)}")
return tour

147
backend/src/refiner.py → backend/src/utils/refiner.py
View File

@ -1,12 +1,11 @@
import yaml, logging
from shapely import buffer, LineString, Point, Polygon, MultiPoint, concave_hull
from typing import List, Tuple
from math import pi
from structs.landmarks import Landmark
from optimizer import Optimizer
from utils import get_time, link_list_simple, take_most_important
from structs.landmark import Landmark
from . import take_most_important, get_time_separation
from .optimizer import Optimizer
import constants
@ -15,31 +14,30 @@ class Refiner :
logger = logging.getLogger(__name__)
max_time: int = None # max visit time (in minutes)
detour: int = None # accepted max detour time (in minutes)
detour_factor: float # detour factor of straight line vs real distance in cities
detour_corridor_width: float # width of the corridor around the path
average_walking_speed: float # average walking speed of adult
max_landmarks: int # max number of landmarks to visit
optimizer: Optimizer # optimizer object
def __init__(self, max_time: int, detour: int) :
self.max_time = max_time
self.detour = detour
def __init__(self, optimizer: Optimizer) :
self.optimizer = optimizer
# load parameters from file
with constants.OPTIMIZER_PARAMETERS_PATH.open('r') as f:
parameters = yaml.safe_load(f)
self.detour_factor = parameters['detour_factor']
self.detour_corridor_width = parameters['detour_corridor_width']
self.average_walking_speed = parameters['average_walking_speed']
self.max_landmarks = parameters['max_landmarks'] + 4
def create_corridor(self, landmarks: List[Landmark], width: float) :
def create_corridor(self, landmarks: list[Landmark], width: float) :
"""
Create a corridor around the path connecting the landmarks.
Args:
landmarks (List[Landmark]): the landmark path around which to create the corridor
landmarks (list[Landmark]): the landmark path around which to create the corridor
width (float): Width of the corridor in meters.
Returns:
@ -54,12 +52,12 @@ class Refiner :
return obj
def create_linestring(self, tour: List[Landmark])->LineString :
def create_linestring(self, tour: list[Landmark]) -> LineString :
"""
Create a `LineString` object from a tour.
Args:
tour (List[Landmark]): An ordered sequence of landmarks that represents the visiting order.
tour (list[Landmark]): An ordered sequence of landmarks that represents the visiting order.
Returns:
LineString: A `LineString` object representing the path through the landmarks.
@ -79,7 +77,7 @@ class Refiner :
Args:
area (Polygon): The polygon defining the area.
coordinates (Tuple[float, float]): The coordinates of the point to check.
coordinates (tuple[float, float]): The coordinates of the point to check.
Returns:
bool: True if the point is within the area, otherwise False.
@ -89,13 +87,13 @@ class Refiner :
# Function to determine if two landmarks are close to each other
def is_close_to(self, location1: Tuple[float], location2: Tuple[float]):
def is_close_to(self, location1: tuple[float], location2: tuple[float]):
"""
Determine if two locations are close to each other by rounding their coordinates to 3 decimal places.
Args:
location1 (Tuple[float, float]): The coordinates of the first location.
location2 (Tuple[float, float]): The coordinates of the second location.
location1 (tuple[float, float]): The coordinates of the first location.
location2 (tuple[float, float]): The coordinates of the second location.
Returns:
bool: True if the locations are within 0.001 degrees of each other, otherwise False.
@ -108,7 +106,7 @@ class Refiner :
#return (round(location1[0], 3), round(location1[1], 3)) == (round(location2[0], 3), round(location2[1], 3))
def rearrange(self, tour: List[Landmark]) -> List[Landmark]:
def rearrange(self, tour: list[Landmark]) -> list[Landmark]:
"""
Rearrange landmarks to group nearby visits together.
@ -116,10 +114,10 @@ class Refiner :
while keeping 'start' and 'finish' landmarks in their original positions.
Args:
tour (List[Landmark]): Ordered list of landmarks to be rearranged.
tour (list[Landmark]): Ordered list of landmarks to be rearranged.
Returns:
List[Landmark]: The rearranged list of landmarks with grouped nearby visits.
list[Landmark]: The rearranged list of landmarks with grouped nearby visits.
"""
i = 1
@ -137,7 +135,7 @@ class Refiner :
return tour
def find_shortest_path_through_all_landmarks(self, landmarks: List[Landmark]) -> Tuple[List[Landmark], Polygon]:
def find_shortest_path_through_all_landmarks(self, landmarks: list[Landmark]) -> tuple[list[Landmark], Polygon]:
"""
Find the shortest path through all landmarks using a nearest neighbor heuristic.
@ -146,10 +144,10 @@ class Refiner :
polygon representing the path.
Args:
landmarks (List[Landmark]): List of all landmarks including 'start' and 'finish'.
landmarks (list[Landmark]): list of all landmarks including 'start' and 'finish'.
Returns:
Tuple[List[Landmark], Polygon]: A tuple where the first element is the list of landmarks in the order they
tuple[list[Landmark], Polygon]: A tuple where the first element is the list of landmarks in the order they
should be visited, and the second element is a `Polygon` representing
the path connecting all landmarks.
"""
@ -173,7 +171,7 @@ class Refiner :
# Step 4: Use nearest neighbor heuristic to visit all landmarks
while unvisited_landmarks:
nearest_landmark = min(unvisited_landmarks, key=lambda lm: get_time(current_landmark.location, lm.location))
nearest_landmark = min(unvisited_landmarks, key=lambda lm: get_time_separation.get_time(current_landmark.location, lm.location))
path.append(nearest_landmark)
coordinates.append(nearest_landmark.location)
current_landmark = nearest_landmark
@ -189,7 +187,7 @@ class Refiner :
# Returns a list of minor landmarks around the planned path to enhance experience
def get_minor_landmarks(self, all_landmarks: List[Landmark], visited_landmarks: List[Landmark], width: float) -> List[Landmark] :
def get_minor_landmarks(self, all_landmarks: list[Landmark], visited_landmarks: list[Landmark], width: float) -> list[Landmark] :
"""
Identify landmarks within a specified corridor that have not been visited yet.
@ -197,12 +195,12 @@ class Refiner :
within this corridor. It returns a list of these landmarks, excluding those already visited, sorted by their importance.
Args:
all_landmarks (List[Landmark]): List of all available landmarks.
visited_landmarks (List[Landmark]): List of landmarks that have already been visited.
all_landmarks (list[Landmark]): list of all available landmarks.
visited_landmarks (list[Landmark]): list of landmarks that have already been visited.
width (float): Width of the corridor around the visited landmarks.
Returns:
List[Landmark]: List of important landmarks within the corridor that have not been visited yet.
list[Landmark]: list of important landmarks within the corridor that have not been visited yet.
"""
second_order_landmarks = []
@ -216,11 +214,11 @@ class Refiner :
if self.is_in_area(area, landmark.location) and landmark.name not in visited_names:
second_order_landmarks.append(landmark)
return take_most_important(second_order_landmarks, len(visited_landmarks))
return take_most_important.take_most_important(second_order_landmarks, len(visited_landmarks))
# Try fix the shortest path using shapely
def fix_using_polygon(self, tour: List[Landmark])-> List[Landmark] :
def fix_using_polygon(self, tour: list[Landmark])-> list[Landmark] :
"""
Improve the tour path using geometric methods to ensure it follows a more optimal shape.
@ -229,10 +227,10 @@ class Refiner :
beginning. It also checks if the final polygon is simple and rearranges the tour if necessary.
Args:
tour (List[Landmark]): List of landmarks representing the current tour path.
tour (list[Landmark]): list of landmarks representing the current tour path.
Returns:
List[Landmark]: Refined list of landmarks in the order of visit to produce a better tour path.
list[Landmark]: Refined list of landmarks in the order of visit to produce a better tour path.
"""
coords = []
@ -261,7 +259,7 @@ class Refiner :
xs.reverse()
ys.reverse()
better_tour = [] # List of ordered visit
better_tour = [] # list of ordered visit
name_index = {} # Maps the name of a landmark to its index in the concave polygon
# Loop through the polygon and generate the better (ordered) tour
@ -285,67 +283,58 @@ class Refiner :
return better_tour
# Second stage of the optimization. Use linear programming again to refine the path
def refine_optimization(self, all_landmarks: List[Landmark], base_tour: List[Landmark]) -> List[Landmark] :
def refine_optimization(
self,
all_landmarks: list[Landmark],
base_tour: list[Landmark],
max_time: int,
detour: int
) -> list[Landmark]:
"""
Refine the initial tour path by considering additional minor landmarks and optimizing the path.
This is the second stage of the optimization. It refines the initial tour path by considering additional minor landmarks and optimizes the path.
This method evaluates the need for further optimization based on the initial tour. If a detour is required, it adds
minor landmarks around the initial predicted path and solves a new optimization problem to find a potentially better
This method evaluates the need for further optimization based on the initial tour. If a detour is required
it adds minor landmarks around the initial predicted path and solves a new optimization problem to find a potentially better
tour. It then links the new tour and adjusts it using a nearest neighbor heuristic and polygon-based methods to
ensure a valid path. The final tour is chosen based on the shortest distance.
Args:
all_landmarks (list[Landmark]): The full list of landmarks available for the optimization.
base_tour (list[Landmark]): The initial tour path to be refined.
max_time (int): The maximum time available for the tour in minutes.
detour (int): The maximum detour time allowed for the tour in minutes.
Returns:
List[Landmark]: The refined list of landmarks representing the optimized tour path.
list[Landmark]: The refined list of landmarks representing the optimized tour path.
"""
# No need to refine if no detour is taken
# if detour == 0 :
if False :
if detour == 0:
return base_tour
minor_landmarks = self.get_minor_landmarks(all_landmarks, base_tour, self.detour_corridor_width)
self.logger.info(f"Using {len(minor_landmarks)} minor landmarks around the predicted path")
# full set of visitable landmarks
full_set = base_tour[:-1] + minor_landmarks # create full set of possible landmarks (without finish)
full_set.append(base_tour[-1]) # add finish back
# get a new tour
new_tour = self.optimizer.solve_optimization(
max_time = max_time + detour,
landmarks = full_set
)
if new_tour is None:
self.logger.warning("No solution found for the refined tour. Returning the initial tour.")
new_tour = base_tour
else :
minor_landmarks = self.get_minor_landmarks(all_landmarks, base_tour, 200)
self.logger.info(f"Using {len(minor_landmarks)} minor landmarks around the predicted path")
# full set of visitable landmarks
full_set = base_tour[:-1] + minor_landmarks # create full set of possible landmarks (without finish)
full_set.append(base_tour[-1]) # add finish back
# get a new tour
optimizer = Optimizer(self.max_time + self.detour, full_set)
new_tour = optimizer.solve_optimization(hide_log=True)
if new_tour is None :
new_tour = base_tour
# Link the new tour
new_tour, new_dist = link_list_simple(new_tour)
# If the tour contains only one landmark, return
if len(new_tour) < 4 :
return new_tour
# Find shortest path using the nearest neighbor heuristic
better_tour, better_poly = self.find_shortest_path_through_all_landmarks(new_tour)
# Fix the tour using Polygons if the path looks weird
if base_tour[0].location == base_tour[-1].location and not better_poly.is_valid :
better_tour = self.fix_using_polygon(better_tour)
# Link the tour again
better_tour, better_dist = link_list_simple(better_tour)
# Choose the better tour depending on walked distance
if new_dist < better_dist :
final_tour = new_tour
else :
final_tour = better_tour
self.logger.info("Refined tour (result of second stage optimization): ")
optimizer.print_res(final_tour)
return final_tour
return better_tour

38
backend/src/utils/take_most_important.py Normal file
View File

@ -0,0 +1,38 @@
from structs.landmark import Landmark
def take_most_important(landmarks: list[Landmark], N_important) -> list[Landmark] :
L = len(landmarks)
L_copy = []
L_clean = []
scores = [0]*len(landmarks)
names = []
name_id = {}
for i, elem in enumerate(landmarks) :
if elem.name not in names :
names.append(elem.name)
name_id[elem.name] = [i]
L_copy.append(elem)
else :
name_id[elem.name] += [i]
scores = []
for j in name_id[elem.name] :
scores.append(L[j].attractiveness)
best_id = max(range(len(scores)), key=scores.__getitem__)
t = name_id[elem.name][best_id]
if t == i :
for old in L_copy :
if old.name == elem.name :
old.attractiveness = L[t].attractiveness
scores = [0]*len(L_copy)
for i, elem in enumerate(L_copy) :
scores[i] = elem.attractiveness
res = sorted(range(len(scores)), key = lambda sub: scores[sub])[-(N_important-L):]
for i, elem in enumerate(L_copy) :
if i in res :
L_clean.append(elem)
return L_clean