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

further cleanup

Browse Source
This commit is contained in:
Remy Moll 2024-07-08 11:55:00 +02:00
parent f9c86261cb
commit 8f23a4747d
4 changed files with 182 additions and 277 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
backend/src/constants.py
View File

@ -1,5 +1,6 @@
from pathlib import Path from pathlib import Path
import os import os
import logging
PARAMETERS_DIR = Path('src/parameters') PARAMETERS_DIR = Path('src/parameters')
AMENITY_SELECTORS_PATH = PARAMETERS_DIR / 'amenity_selectors.yaml' AMENITY_SELECTORS_PATH = PARAMETERS_DIR / 'amenity_selectors.yaml'
@ -10,3 +11,9 @@ OPTIMIZER_PARAMETERS_PATH = PARAMETERS_DIR / 'optimizer_parameters.yaml'
cache_dir_string = os.getenv('OSM_CACHE_DIR', './cache') cache_dir_string = os.getenv('OSM_CACHE_DIR', './cache')
OSM_CACHE_DIR = Path(cache_dir_string) OSM_CACHE_DIR = Path(cache_dir_string)
logger = logging.getLogger(__name__)
logging.basicConfig(
level = logging.INFO,
format = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)

107
backend/src/landmarks_manager.py
View File

@ -1,5 +1,5 @@
import yaml import yaml
import os import logging
import osmnx as ox import osmnx as ox
from shapely.geometry import Point, Polygon, LineString, MultiPolygon from shapely.geometry import Point, Polygon, LineString, MultiPolygon
@ -7,57 +7,64 @@ from structs.landmarks import Landmark, LandmarkType
from structs.preferences import Preferences, Preference from structs.preferences import Preferences, Preference
import constants import constants
SIGHTSEEING = LandmarkType(landmark_type='sightseeing') SIGHTSEEING = LandmarkType(landmark_type='sightseeing')
NATURE = LandmarkType(landmark_type='nature') NATURE = LandmarkType(landmark_type='nature')
SHOPPING = LandmarkType(landmark_type='shopping') SHOPPING = LandmarkType(landmark_type='shopping')
class LandmarkManager:
logger = logging.getLogger(__name__)
def __init__(self) -> None:
ox.config(cache_folder=constants.OSM_CACHE_DIR) ox.config(cache_folder=constants.OSM_CACHE_DIR)
# Include the json here
# Create a list of all things to visit given some preferences and a city. Ready for the optimizer
def generate_landmarks(preferences: Preferences, center_coordinates: tuple[float, float]) :
with constants.AMENITY_SELECTORS_PATH.open('r') as f: with constants.AMENITY_SELECTORS_PATH.open('r') as f:
amenity_selectors = yaml.safe_load(f) self.amenity_selectors = yaml.safe_load(f)
with constants.LANDMARK_PARAMETERS_PATH.open('r') as f: with constants.LANDMARK_PARAMETERS_PATH.open('r') as f:
# even though we don't use the parameters here, we already load them to avoid unnecessary io operations self.parameters = yaml.safe_load(f)
parameters = yaml.safe_load(f) # max_distance = parameters['city_bbox_side']
max_distance = parameters['city_bbox_side']
def get_landmark_lists(self, preferences: Preferences, center_coordinates: tuple[float, float]) -> tuple[list[Landmark], list[Landmark]]:
'''
Generate a list of landmarks based on the preferences of the user and the center (ie. start) coordinates.
The list is then used by the pathfinding algorithm to generate a path that goes through the most interesting landmarks.
:param preferences: the preferences specified by the user
:param center_coordinates: the coordinates of the starting point
'''
L = [] L = []
# List for sightseeing # List for sightseeing
if preferences.sightseeing.score != 0: if preferences.sightseeing.score != 0:
score_func = lambda loc, n_tags: int((count_elements_within_radius(loc, parameters['radius_close_to']) + n_tags * parameters['tag_coeff']) * parameters['church_coeff']) score_func = lambda loc, n_tags: int((self.count_elements_within_radius(loc, self.parameters['radius_close_to']) + n_tags * self.parameters['tag_coeff']) * self.parameters['church_coeff'])
L1 = get_landmarks(amenity_selectors['sightseeing'], SIGHTSEEING, center_coordinates, max_distance, score_func) L1 = self.fetch_landmarks(self.amenity_selectors['sightseeing'], SIGHTSEEING, center_coordinates, self.parameters['city_bbox_side'], score_func)
correct_score(L1, preferences.sightseeing) self.correct_score(L1, preferences.sightseeing)
L += L1 L += L1
# List for nature # List for nature
if preferences.nature.score != 0: if preferences.nature.score != 0:
score_func = lambda loc, n_tags: int((count_elements_within_radius(loc, parameters['radius_close_to']) + n_tags * parameters['tag_coeff']) * parameters['park_coeff']) score_func = lambda loc, n_tags: int((self.count_elements_within_radius(loc, self.parameters['radius_close_to']) + n_tags * self.parameters['tag_coeff']) * self.parameters['park_coeff'])
L2 = get_landmarks(amenity_selectors['nature'], NATURE, center_coordinates, max_distance, score_func) L2 = self.fetch_landmarks(self.amenity_selectors['nature'], NATURE, center_coordinates, self.parameters['city_bbox_side'], score_func)
correct_score(L2, preferences.nature) self.correct_score(L2, preferences.nature)
L += L2 L += L2
# List for shopping # List for shopping
if preferences.shopping.score != 0: if preferences.shopping.score != 0:
score_func = lambda loc, n_tags: count_elements_within_radius(loc, parameters['radius_close_to']) + n_tags * parameters['tag_coeff'] score_func = lambda loc, n_tags: self.count_elements_within_radius(loc, self.parameters['radius_close_to']) + n_tags * self.parameters['tag_coeff']
L3 = get_landmarks(amenity_selectors['shopping'], SHOPPING, center_coordinates, max_distance, score_func) L3 = self.fetch_landmarks(self.amenity_selectors['shopping'], SHOPPING, center_coordinates, self.parameters['city_bbox_side'], score_func)
correct_score(L3, preferences.shopping) self.correct_score(L3, preferences.shopping)
L += L3 L += L3
# remove duplicates # remove duplicates
L = list(set(L)) L = list(set(L))
print(len(L)) L_constrained = self.take_most_important(L, self.parameters['N_important'])
L_constrained = take_most_important(L, parameters['N_important']) self.logger.info(f'Generated {len(L)} landmarks around {center_coordinates}, and constrained to {len(L_constrained)} most important ones.')
print(len(L_constrained))
return L, L_constrained return L, L_constrained
# Take the most important landmarks from the list # Take the most important landmarks from the list
def take_most_important(landmarks: list[Landmark], n_max: int) -> list[Landmark]: def take_most_important(self, landmarks: list[Landmark], n_max: int) -> list[Landmark]:
landmarks_sorted = sorted(landmarks, key=lambda x: x.attractiveness, reverse=True) landmarks_sorted = sorted(landmarks, key=lambda x: x.attractiveness, reverse=True)
return landmarks_sorted[:n_max] return landmarks_sorted[:n_max]
@ -65,7 +72,7 @@ def take_most_important(landmarks: list[Landmark], n_max: int) -> list[Landmark]
# Correct the score of a list of landmarks by taking into account preference settings # Correct the score of a list of landmarks by taking into account preference settings
def correct_score(L: list[Landmark], preference: Preference) : def correct_score(self, L: list[Landmark], preference: Preference):
if len(L) == 0 : if len(L) == 0 :
return return
@ -78,7 +85,7 @@ def correct_score(L: list[Landmark], preference: Preference) :
# Function to count elements within a certain radius of a location # Function to count elements within a certain radius of a location
def count_elements_within_radius(point: Point, radius: int) -> int: def count_elements_within_radius(self, point: Point, radius: int) -> int:
center_coordinates = (point.x, point.y) center_coordinates = (point.x, point.y)
try: try:
@ -94,7 +101,8 @@ def count_elements_within_radius(point: Point, radius: int) -> int:
def get_landmarks( def fetch_landmarks(
self,
amenity_selectors: list[dict], amenity_selectors: list[dict],
landmarktype: LandmarkType, landmarktype: LandmarkType,
center_coordinates: tuple[float, float], center_coordinates: tuple[float, float],
@ -120,9 +128,6 @@ def get_landmarks(
location = description['geometry'] location = description['geometry']
n_tags = len(description['nodes']) if type(description['nodes']) == list else 1 n_tags = len(description['nodes']) if type(description['nodes']) == list else 1
# print(description['nodes'])
print(description['name'])
# print(location, type(location))
if type(location) == Point: if type(location) == Point:
location = location location = location
elif type(location) == Polygon or type(location) == MultiPolygon: elif type(location) == Polygon or type(location) == MultiPolygon:
@ -131,7 +136,6 @@ def get_landmarks(
location = location.interpolate(location.length/2) location = location.interpolate(location.length/2)
score = score_function(location, n_tags) score = score_function(location, n_tags)
print(score)
landmark = Landmark( landmark = Landmark(
name = description['name'], name = description['name'],
type = landmarktype, type = landmarktype,
@ -145,44 +149,3 @@ def get_landmarks(
ret_landmarks.append(landmark) ret_landmarks.append(landmark)
return ret_landmarks return ret_landmarks
# for elem in G.iterrows():
# print(elem)
# print(elem.name)
# print(elem.address)
# name = elem.tag('name') # Add name
# location = (elem.centerLat(), elem.centerLon()) # Add coordinates (lat, lon)
# # skip if unprecise location
# if name is None or location[0] is None:
# continue
# # skip if unused
# if 'disused:leisure' in elem.tags().keys():
# continue
# # skip if part of another building
# if 'building:part' in elem.tags().keys() and elem.tag('building:part') == 'yes':
# continue
# else :
# osm_type = elem.type() # Add type : 'way' or 'relation'
# osm_id = elem.id() # Add OSM id
# elem_type = landmarktype # Add the landmark type as 'sightseeing
# n_tags = len(elem.tags().keys()) # Add number of tags
# # Add score of given landmark based on the number of surrounding elements. Penalty for churches as there are A LOT
# if amenity == "'amenity'='place_of_worship'" :
# score = int((count_elements_within_radius(location, parameters['radius_close_to']) + n_tags*parameters['tag_coeff'] )*parameters['church_coeff'])
# elif amenity == "'leisure'='park'" :
# score = int((count_elements_within_radius(location, parameters['radius_close_to']) + n_tags*parameters['tag_coeff'] )*parameters['park_coeff'])
# else :
# score = count_elements_within_radius(location, parameters['radius_close_to']) + n_tags*parameters['tag_coeff']
# if score is not None :
# # Generate the landmark and append it to the list
# landmark = Landmark(name=name, type=elem_type, location=location, osm_type=osm_type, osm_id=osm_id, attractiveness=score, must_do=False, n_tags=n_tags)
# L.append(landmark)
# return L

85
backend/src/main.py
View File

@ -1,51 +1,45 @@
from optimizer import solve_optimization from optimizer import solve_optimization
from refiner import refine_optimization # from refiner import refine_optimization
from landmarks_manager import generate_landmarks from landmarks_manager import LandmarkManager
from structs.landmarks import Landmark from structs.landmarks import Landmark
from structs.landmarktype import LandmarkType from structs.landmarktype import LandmarkType
from structs.preferences import Preferences, Preference from structs.preferences import Preferences
from fastapi import FastAPI, Query, Body from fastapi import FastAPI, Query, Body
from typing import List
app = FastAPI() app = FastAPI()
manager = LandmarkManager()
# TODO: needs a global variable to store the landmarks accross function calls # TODO: needs a global variable to store the landmarks accross function calls
# linked_tour = [] # linked_tour = []
# Assuming frontend is calling like this : @app.post("/route/new")
#"http://127.0.0.1:8000/process?param1={param1}&param2={param2}" def main1(preferences: Preferences, start: tuple[float, float], end: tuple[float, float] = None) -> str:
@app.post("/optimizer_coords/{start_lat}/{start_lon}/{finish_lat}/{finish_lon}") '''
def main1(start_lat: float, start_lon: float, preferences: Preferences = Body(...), finish_lat: float = None, finish_lon: float = None) -> List[Landmark]: Main function to call the optimizer.
:param preferences: the preferences specified by the user as the post body
:param start: the coordinates of the starting point as a tuple of floats (as url query parameters)
: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.") raise ValueError("Please provide preferences in the form of a 'Preference' BaseModel class.")
if bool(start_lat) ^ bool(start_lon) : if start is None:
raise ValueError("Please provide both latitude and longitude for the starting point") raise ValueError("Please provide the starting coordinates as a tuple of floats.")
if bool(finish_lat) ^ bool(finish_lon) : if end is None:
raise ValueError("Please provide both latitude and longitude for the finish point") end = start
start = Landmark(name='start', type=LandmarkType(landmark_type='start'), location=(start_lat, start_lon), osm_type='start', 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)
if bool(finish_lat) and bool(finish_lon) :
finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=(finish_lat, finish_lon), osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
else :
finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=(start_lat, start_lon), osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
start = Landmark(name='start', type=LandmarkType(landmark_type='start'), location=(48.8375946, 2.2949904), osm_type='start', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=(48.8375946, 2.2949904), osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
# Generate the landmarks from the start location # Generate the landmarks from the start location
landmarks, landmarks_short = generate_landmarks(preferences=preferences, coordinates=start.location) landmarks, landmarks_short = LandmarkManager.get_landmark_lists(preferences=preferences, coordinates=start.location)
print([l.name for l in landmarks_short])
# insert start and finish to the landmarks list # insert start and finish to the landmarks list
landmarks_short.insert(0, start) landmarks_short.insert(0, start_landmark)
landmarks_short.append(finish) landmarks_short.append(end_landmark)
# TODO infer these parameters from the preferences
# TODO use these parameters in another way
max_walking_time = 4 # hours max_walking_time = 4 # hours
detour = 30 # minutes detour = 30 # minutes
@ -53,32 +47,11 @@ def main1(start_lat: float, start_lon: float, preferences: Preferences = Body(..
base_tour = solve_optimization(landmarks_short, max_walking_time*60, True) base_tour = solve_optimization(landmarks_short, max_walking_time*60, True)
# Second stage optimization # Second stage optimization
refined_tour = refine_optimization(landmarks, base_tour, max_walking_time*60+detour, True) # refined_tour = refine_optimization(landmarks, base_tour, max_walking_time*60+detour, True)
# linked_tour = ...
# TODO: should look something like this # return linked_tour[0].uuid
# # set time to reach and transform into fully functional linked list return base_tour[0].uuid
# linked_tour += link(refined_tour)
# return {
# 'city_name': 'Paris',
# 'n_stops': len(linked_tour),
# 'first_landmark_uuid': linked_tour[0].uuid,
# }
return refined_tour
# input city, country in the form of 'Paris, France'
@app.post("/test2/{city_country}")
def test2(city_country: str, preferences: Preferences = Body(...)) -> List[Landmark]:
landmarks = generate_landmarks(city_country, preferences)
max_steps = 9000000
visiting_order = solve_optimization(landmarks, max_steps, True)
@ -86,5 +59,3 @@ def test2(city_country: str, preferences: Preferences = Body(...)) -> List[Landm
def get_landmark(landmark_uuid: str) -> Landmark: def get_landmark(landmark_uuid: str) -> Landmark:
#cherche dans linked_tour et retourne le landmark correspondant #cherche dans linked_tour et retourne le landmark correspondant
pass pass

78
backend/src/tester.py
View File

@ -1,11 +1,11 @@
import pandas as pd import pandas as pd
from typing import List from typing import List
from landmarks_manager import generate_landmarks from landmarks_manager import LandmarkManager
from fastapi.encoders import jsonable_encoder from fastapi.encoders import jsonable_encoder
from optimizer import solve_optimization from optimizer import solve_optimization
from refiner import refine_optimization # from refiner import refine_optimization
from structs.landmarks import Landmark from structs.landmarks import Landmark
from structs.landmarktype import LandmarkType from structs.landmarktype import LandmarkType
from structs.preferences import Preferences, Preference from structs.preferences import Preferences, Preference
@ -23,74 +23,37 @@ def write_data(L: List[Landmark], file_name: str):
data.to_json(file_name, indent = 2, force_ascii=False) data.to_json(file_name, indent = 2, force_ascii=False)
def test3(city_country: str) -> List[Landmark]: def main(coordinates: tuple[float, float]) -> List[Landmark]:
manager = LandmarkManager()
preferences = Preferences( preferences = Preferences(
sightseeing=Preference( sightseeing=Preference(
name='sightseeing', name='sightseeing',
type=LandmarkType(landmark_type='sightseeing'), type=LandmarkType(landmark_type='sightseeing'),
score = 5), score = 5
),
nature=Preference( nature=Preference(
name='nature', name='nature',
type=LandmarkType(landmark_type='nature'), type=LandmarkType(landmark_type='nature'),
score = 0), score = 5
),
shopping=Preference( shopping=Preference(
name='shopping', name='shopping',
type=LandmarkType(landmark_type='shopping'), type=LandmarkType(landmark_type='shopping'),
score = 5)) score = 5
)
coordinates = None )
landmarks, landmarks_short = generate_landmarks(preferences=preferences, city_country=city_country, coordinates=coordinates)
#write_data(landmarks)
start = Landmark(name='start', type=LandmarkType(landmark_type='start'), location=(48.2044576, 16.3870242), osm_type='start', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=(48.2044576, 16.3870242), osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
test = landmarks_short
test.insert(0, start)
test.append(finish)
max_walking_time = 2 # hours
visiting_list = solve_optimization(test, max_walking_time*60, True)
def test4(coordinates: tuple[float, float]) -> List[Landmark]:
preferences = Preferences(
sightseeing=Preference(
name='sightseeing',
type=LandmarkType(landmark_type='sightseeing'),
score = 5),
nature=Preference(
name='nature',
type=LandmarkType(landmark_type='nature'),
score = 5),
shopping=Preference(
name='shopping',
type=LandmarkType(landmark_type='shopping'),
score = 5))
# Create start and finish # Create start and finish
start = Landmark(name='start', type=LandmarkType(landmark_type='start'), location=coordinates, osm_type='start', osm_id=0, attractiveness=0, must_do=True, n_tags = 0) start = Landmark(name='start', type=LandmarkType(landmark_type='start'), location=coordinates, osm_type='start', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=coordinates, osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0) finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=coordinates, osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
#finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=(48.8777055, 2.3640967), osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
#start = Landmark(name='start', type=LandmarkType(landmark_type='start'), location=(48.847132, 2.312359), osm_type='start', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
#finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=(48.843185, 2.344533), osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
#finish = Landmark(name='finish', type=LandmarkType(landmark_type='finish'), location=(48.847132, 2.312359), osm_type='finish', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
# Generate the landmarks from the start location # Generate the landmarks from the start location
landmarks, landmarks_short = generate_landmarks(preferences=preferences, center_coordinates=start.location) landmarks, landmarks_short = manager.get_landmark_lists(preferences=preferences, center_coordinates=start.location)
print([l.name for l in landmarks_short])
#write_data(landmarks, "landmarks.txt") #write_data(landmarks, "landmarks.txt")
# Insert start and finish to the landmarks list # Insert start and finish to the landmarks list
@ -105,12 +68,13 @@ def test4(coordinates: tuple[float, float]) -> List[Landmark]:
base_tour = solve_optimization(landmarks_short, max_walking_time*60, True) base_tour = solve_optimization(landmarks_short, max_walking_time*60, True)
# Second stage optimization # Second stage optimization
refined_tour = refine_optimization(landmarks, base_tour, max_walking_time*60+detour, True) # refined_tour = refine_optimization(landmarks, base_tour, max_walking_time*60+detour, True)
return refined_tour return base_tour
test4(tuple((48.8344400, 2.3220540))) # Café Chez César
#test4(tuple((48.8375946, 2.2949904))) # Point random if __name__ == '__main__':
#test4(tuple((47.377859, 8.540585))) # Zurich HB start = (48.847132, 2.312359) # Café Chez César
#test3('Vienna, Austria') # start = (47.377859, 8.540585) # Zurich HB
main(start)