cleaner trip loading indicator

tentatively shrink trip overview, nicer onboarding
some more images
2025-02-05 13:50:38 +01:00 · 2024-12-17 11:17:59 +01:00 · 2024-12-17 10:28:33 +01:00 · 2024-12-15 16:30:17 +01:00 · 2024-12-02 10:43:42 +01:00 · 2024-11-18 17:42:52 +01:00
72 changed files with 3353 additions and 201790 deletions
--- a/.gitea/workflows/backend_run_lint.yaml
+++ b/.gitea/workflows/backend_run_lint.yaml
@@ -1,34 +0,0 @@
-on:
-  pull_request:
-    branches:
-      - main
-    paths:
-      - backend/**
-
-name: Run linting on the backend code
-
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-
-    - uses: https://gitea.com/actions/checkout@v4
-
-    - name: Install dependencies
-      run: |
-        apt-get update && apt-get install -y python3 python3-pip
-        pip install pipenv        
-
-    - name: Install packages
-      run: |
-        ls -la
-        # only install dev-packages
-        pipenv install --categories=dev-packages
-        pipenv run pip freeze        
-
-      working-directory: backend
-
-    - name: Run linter
-      run: pipenv run pylint src --fail-under=9
-      working-directory: backend
--- a/.gitea/workflows/backend_run_test.yaml
+++ b/.gitea/workflows/backend_run_test.yaml
@@ -1,40 +0,0 @@
-on:
-  pull_request:
-    branches:
-      - main
-    paths:
-      - backend/**
-
-name: Run testing on the backend code
-
-jobs:
-  build:
-    name: Build
-    runs-on: ubuntu-latest
-    steps:
-
-    - uses: https://gitea.com/actions/checkout@v4
-
-    - name: Install dependencies
-      run: |
-        apt-get update && apt-get install -y python3 python3-pip
-        pip install pipenv        
-
-    - name: Install packages
-      run: |
-        ls -la
-        # install all packages, including dev-packages
-        pipenv install --dev
-        pipenv run pip freeze        
-      working-directory: backend
-
-    - name: Run Tests
-      run: pipenv run pytest src --html=report.html --self-contained-html
-      working-directory: backend
-
-    - name: Upload HTML report
-      if: always()
-      uses: https://gitea.com/actions/upload-artifact@v3
-      with:
-        name: pytest-html-report
-        path: backend/report.html
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -14,9 +14,9 @@
                "DEBUG": "true"
            },
            "args": [
-                // "--app-dir",
-                // "src",
-                "src.main:app",
+                "--app-dir",
+                "src",
+                "main:app",
                "--reload",
            ],
            "jinja": true,
--- a/backend/.pylintrc
+++ b/backend/.pylintrc
@@ -1,649 +0,0 @@
-[MAIN]
-
-# Analyse import fallback blocks. This can be used to support both Python 2 and
-# 3 compatible code, which means that the block might have code that exists
-# only in one or another interpreter, leading to false positives when analysed.
-analyse-fallback-blocks=no
-
-# Clear in-memory caches upon conclusion of linting. Useful if running pylint
-# in a server-like mode.
-clear-cache-post-run=no
-
-# Load and enable all available extensions. Use --list-extensions to see a list
-# all available extensions.
-#enable-all-extensions=
-
-# In error mode, messages with a category besides ERROR or FATAL are
-# suppressed, and no reports are done by default. Error mode is compatible with
-# disabling specific errors.
-#errors-only=
-
-# Always return a 0 (non-error) status code, even if lint errors are found.
-# This is primarily useful in continuous integration scripts.
-#exit-zero=
-
-# A comma-separated list of package or module names from where C extensions may
-# be loaded. Extensions are loading into the active Python interpreter and may
-# run arbitrary code.
-extension-pkg-allow-list=
-
-# A comma-separated list of package or module names from where C extensions may
-# be loaded. Extensions are loading into the active Python interpreter and may
-# run arbitrary code. (This is an alternative name to extension-pkg-allow-list
-# for backward compatibility.)
-extension-pkg-whitelist=
-
-# Return non-zero exit code if any of these messages/categories are detected,
-# even if score is above --fail-under value. Syntax same as enable. Messages
-# specified are enabled, while categories only check already-enabled messages.
-fail-on=
-
-# Specify a score threshold under which the program will exit with error.
-fail-under=10
-
-# Interpret the stdin as a python script, whose filename needs to be passed as
-# the module_or_package argument.
-#from-stdin=
-
-# Files or directories to be skipped. They should be base names, not paths.
-ignore=CVS
-
-# Add files or directories matching the regular expressions patterns to the
-# ignore-list. The regex matches against paths and can be in Posix or Windows
-# format. Because '\\' represents the directory delimiter on Windows systems,
-# it can't be used as an escape character.
-ignore-paths=
-
-# Files or directories matching the regular expression patterns are skipped.
-# The regex matches against base names, not paths. The default value ignores
-# Emacs file locks
-ignore-patterns=^\.#
-
-# List of module names for which member attributes should not be checked and
-# will not be imported (useful for modules/projects where namespaces are
-# manipulated during runtime and thus existing member attributes cannot be
-# deduced by static analysis). It supports qualified module names, as well as
-# Unix pattern matching.
-ignored-modules=
-
-# Python code to execute, usually for sys.path manipulation such as
-# pygtk.require().
-#init-hook=
-
-# Use multiple processes to speed up Pylint. Specifying 0 will auto-detect the
-# number of processors available to use, and will cap the count on Windows to
-# avoid hangs.
-jobs=1
-
-# Control the amount of potential inferred values when inferring a single
-# object. This can help the performance when dealing with large functions or
-# complex, nested conditions.
-limit-inference-results=100
-
-# List of plugins (as comma separated values of python module names) to load,
-# usually to register additional checkers.
-load-plugins=
-
-# Pickle collected data for later comparisons.
-persistent=yes
-
-# Resolve imports to .pyi stubs if available. May reduce no-member messages and
-# increase not-an-iterable messages.
-prefer-stubs=no
-
-# Minimum Python version to use for version dependent checks. Will default to
-# the version used to run pylint.
-py-version=3.12
-
-# Discover python modules and packages in the file system subtree.
-recursive=no
-
-# Add paths to the list of the source roots. Supports globbing patterns. The
-# source root is an absolute path or a path relative to the current working
-# directory used to determine a package namespace for modules located under the
-# source root.
-source-roots=
-
-# When enabled, pylint would attempt to guess common misconfiguration and emit
-# user-friendly hints instead of false-positive error messages.
-suggestion-mode=yes
-
-# Allow loading of arbitrary C extensions. Extensions are imported into the
-# active Python interpreter and may run arbitrary code.
-unsafe-load-any-extension=no
-
-# In verbose mode, extra non-checker-related info will be displayed.
-#verbose=
-
-
-[BASIC]
-
-# Naming style matching correct argument names.
-argument-naming-style=snake_case
-
-# Regular expression matching correct argument names. Overrides argument-
-# naming-style. If left empty, argument names will be checked with the set
-# naming style.
-#argument-rgx=
-
-# Naming style matching correct attribute names.
-attr-naming-style=snake_case
-
-# Regular expression matching correct attribute names. Overrides attr-naming-
-# style. If left empty, attribute names will be checked with the set naming
-# style.
-#attr-rgx=
-
-# Bad variable names which should always be refused, separated by a comma.
-bad-names=foo,
-          bar,
-          baz,
-          toto,
-          tutu,
-          tata
-
-# Bad variable names regexes, separated by a comma. If names match any regex,
-# they will always be refused
-bad-names-rgxs=
-
-# Naming style matching correct class attribute names.
-class-attribute-naming-style=any
-
-# Regular expression matching correct class attribute names. Overrides class-
-# attribute-naming-style. If left empty, class attribute names will be checked
-# with the set naming style.
-#class-attribute-rgx=
-
-# Naming style matching correct class constant names.
-class-const-naming-style=UPPER_CASE
-
-# Regular expression matching correct class constant names. Overrides class-
-# const-naming-style. If left empty, class constant names will be checked with
-# the set naming style.
-#class-const-rgx=
-
-# Naming style matching correct class names.
-class-naming-style=PascalCase
-
-# Regular expression matching correct class names. Overrides class-naming-
-# style. If left empty, class names will be checked with the set naming style.
-#class-rgx=
-
-# Naming style matching correct constant names.
-const-naming-style=UPPER_CASE
-
-# Regular expression matching correct constant names. Overrides const-naming-
-# style. If left empty, constant names will be checked with the set naming
-# style.
-#const-rgx=
-
-# Minimum line length for functions/classes that require docstrings, shorter
-# ones are exempt.
-docstring-min-length=-1
-
-# Naming style matching correct function names.
-function-naming-style=snake_case
-
-# Regular expression matching correct function names. Overrides function-
-# naming-style. If left empty, function names will be checked with the set
-# naming style.
-#function-rgx=
-
-# Good variable names which should always be accepted, separated by a comma.
-good-names=i,
-           j,
-           k,
-           ex,
-           Run,
-           _
-
-# Good variable names regexes, separated by a comma. If names match any regex,
-# they will always be accepted
-good-names-rgxs=
-
-# Include a hint for the correct naming format with invalid-name.
-include-naming-hint=no
-
-# Naming style matching correct inline iteration names.
-inlinevar-naming-style=any
-
-# Regular expression matching correct inline iteration names. Overrides
-# inlinevar-naming-style. If left empty, inline iteration names will be checked
-# with the set naming style.
-#inlinevar-rgx=
-
-# Naming style matching correct method names.
-method-naming-style=snake_case
-
-# Regular expression matching correct method names. Overrides method-naming-
-# style. If left empty, method names will be checked with the set naming style.
-#method-rgx=
-
-# Naming style matching correct module names.
-module-naming-style=snake_case
-
-# Regular expression matching correct module names. Overrides module-naming-
-# style. If left empty, module names will be checked with the set naming style.
-#module-rgx=
-
-# Colon-delimited sets of names that determine each other's naming style when
-# the name regexes allow several styles.
-name-group=
-
-# Regular expression which should only match function or class names that do
-# not require a docstring.
-no-docstring-rgx=^_
-
-# List of decorators that produce properties, such as abc.abstractproperty. Add
-# to this list to register other decorators that produce valid properties.
-# These decorators are taken in consideration only for invalid-name.
-property-classes=abc.abstractproperty
-
-# Regular expression matching correct type alias names. If left empty, type
-# alias names will be checked with the set naming style.
-#typealias-rgx=
-
-# Regular expression matching correct type variable names. If left empty, type
-# variable names will be checked with the set naming style.
-#typevar-rgx=
-
-# Naming style matching correct variable names.
-variable-naming-style=snake_case
-
-# Regular expression matching correct variable names. Overrides variable-
-# naming-style. If left empty, variable names will be checked with the set
-# naming style.
-#variable-rgx=
-
-
-[CLASSES]
-
-# Warn about protected attribute access inside special methods
-check-protected-access-in-special-methods=no
-
-# List of method names used to declare (i.e. assign) instance attributes.
-defining-attr-methods=__init__,
-                      __new__,
-                      setUp,
-                      asyncSetUp,
-                      __post_init__
-
-# List of member names, which should be excluded from the protected access
-# warning.
-exclude-protected=_asdict,_fields,_replace,_source,_make,os._exit
-
-# List of valid names for the first argument in a class method.
-valid-classmethod-first-arg=cls
-
-# List of valid names for the first argument in a metaclass class method.
-valid-metaclass-classmethod-first-arg=mcs
-
-
-[DESIGN]
-
-# List of regular expressions of class ancestor names to ignore when counting
-# public methods (see R0903)
-exclude-too-few-public-methods=
-
-# List of qualified class names to ignore when counting class parents (see
-# R0901)
-ignored-parents=
-
-# Maximum number of arguments for function / method.
-max-args=5
-
-# Maximum number of attributes for a class (see R0902).
-max-attributes=7
-
-# Maximum number of boolean expressions in an if statement (see R0916).
-max-bool-expr=5
-
-# Maximum number of branch for function / method body.
-max-branches=12
-
-# Maximum number of locals for function / method body.
-max-locals=15
-
-# Maximum number of parents for a class (see R0901).
-max-parents=7
-
-# Maximum number of positional arguments for function / method.
-max-positional-arguments=5
-
-# Maximum number of public methods for a class (see R0904).
-max-public-methods=20
-
-# Maximum number of return / yield for function / method body.
-max-returns=6
-
-# Maximum number of statements in function / method body.
-max-statements=50
-
-# Minimum number of public methods for a class (see R0903).
-min-public-methods=2
-
-
-[EXCEPTIONS]
-
-# Exceptions that will emit a warning when caught.
-overgeneral-exceptions=builtins.BaseException,builtins.Exception
-
-
-[FORMAT]
-
-# Expected format of line ending, e.g. empty (any line ending), LF or CRLF.
-expected-line-ending-format=
-
-# Regexp for a line that is allowed to be longer than the limit.
-ignore-long-lines=^\s*(# )?<?https?://\S+>?$
-
-# Number of spaces of indent required inside a hanging or continued line.
-indent-after-paren=4
-
-# String used as indentation unit. This is usually "    " (4 spaces) or "\t" (1
-# tab).
-indent-string='    '
-
-# Maximum number of characters on a single line.
-max-line-length=105
-
-# Maximum number of lines in a module.
-max-module-lines=1000
-
-# Allow the body of a class to be on the same line as the declaration if body
-# contains single statement.
-single-line-class-stmt=no
-
-# Allow the body of an if to be on the same line as the test if there is no
-# else.
-single-line-if-stmt=no
-
-
-[IMPORTS]
-
-# List of modules that can be imported at any level, not just the top level
-# one.
-allow-any-import-level=
-
-# Allow explicit reexports by alias from a package __init__.
-allow-reexport-from-package=no
-
-# Allow wildcard imports from modules that define __all__.
-allow-wildcard-with-all=no
-
-# Deprecated modules which should not be used, separated by a comma.
-deprecated-modules=
-
-# Output a graph (.gv or any supported image format) of external dependencies
-# to the given file (report RP0402 must not be disabled).
-ext-import-graph=
-
-# Output a graph (.gv or any supported image format) of all (i.e. internal and
-# external) dependencies to the given file (report RP0402 must not be
-# disabled).
-import-graph=
-
-# Output a graph (.gv or any supported image format) of internal dependencies
-# to the given file (report RP0402 must not be disabled).
-int-import-graph=
-
-# Force import order to recognize a module as part of the standard
-# compatibility libraries.
-known-standard-library=
-
-# Force import order to recognize a module as part of a third party library.
-known-third-party=enchant
-
-# Couples of modules and preferred modules, separated by a comma.
-preferred-modules=
-
-
-[LOGGING]
-
-# The type of string formatting that logging methods do. `old` means using %
-# formatting, `new` is for `{}` formatting.
-logging-format-style=old
-
-# Logging modules to check that the string format arguments are in logging
-# function parameter format.
-logging-modules=logging
-
-
-[MESSAGES CONTROL]
-
-# Only show warnings with the listed confidence levels. Leave empty to show
-# all. Valid levels: HIGH, CONTROL_FLOW, INFERENCE, INFERENCE_FAILURE,
-# UNDEFINED.
-confidence=HIGH,
-           CONTROL_FLOW,
-           INFERENCE,
-           INFERENCE_FAILURE,
-           UNDEFINED
-
-# Disable the message, report, category or checker with the given id(s). You
-# can either give multiple identifiers separated by comma (,) or put this
-# option multiple times (only on the command line, not in the configuration
-# file where it should appear only once). You can also use "--disable=all" to
-# disable everything first and then re-enable specific checks. For example, if
-# you want to run only the similarities checker, you can use "--disable=all
-# --enable=similarities". If you want to run only the classes checker, but have
-# no Warning level messages displayed, use "--disable=all --enable=classes
-# --disable=W".
-disable=raw-checker-failed,
-        bad-inline-option,
-        locally-disabled,
-        file-ignored,
-        suppressed-message,
-        useless-suppression,
-        deprecated-pragma,
-        use-symbolic-message-instead,
-        use-implicit-booleaness-not-comparison-to-string,
-        use-implicit-booleaness-not-comparison-to-zero,
-        import-error,
-        line-too-long
-
-# Enable the message, report, category or checker with the given id(s). You can
-# either give multiple identifier separated by comma (,) or put this option
-# multiple time (only on the command line, not in the configuration file where
-# it should appear only once). See also the "--disable" option for examples.
-enable=
-
-
-[METHOD_ARGS]
-
-# List of qualified names (i.e., library.method) which require a timeout
-# parameter e.g. 'requests.api.get,requests.api.post'
-timeout-methods=requests.api.delete,requests.api.get,requests.api.head,requests.api.options,requests.api.patch,requests.api.post,requests.api.put,requests.api.request
-
-
-[MISCELLANEOUS]
-
-# List of note tags to take in consideration, separated by a comma.
-notes=FIXME,
-      XXX,
-      TODO
-
-# Regular expression of note tags to take in consideration.
-notes-rgx=
-
-
-[REFACTORING]
-
-# Maximum number of nested blocks for function / method body
-max-nested-blocks=5
-
-# Complete name of functions that never returns. When checking for
-# inconsistent-return-statements if a never returning function is called then
-# it will be considered as an explicit return statement and no message will be
-# printed.
-never-returning-functions=sys.exit,argparse.parse_error
-
-# Let 'consider-using-join' be raised when the separator to join on would be
-# non-empty (resulting in expected fixes of the type: ``"- " + " -
-# ".join(items)``)
-suggest-join-with-non-empty-separator=yes
-
-
-[REPORTS]
-
-# Python expression which should return a score less than or equal to 10. You
-# have access to the variables 'fatal', 'error', 'warning', 'refactor',
-# 'convention', and 'info' which contain the number of messages in each
-# category, as well as 'statement' which is the total number of statements
-# analyzed. This score is used by the global evaluation report (RP0004).
-evaluation=max(0, 0 if fatal else 10.0 - ((float(5 * error + warning + refactor + convention) / statement) * 10))
-
-# Template used to display messages. This is a python new-style format string
-# used to format the message information. See doc for all details.
-msg-template=
-
-# Set the output format. Available formats are: text, parseable, colorized,
-# json2 (improved json format), json (old json format) and msvs (visual
-# studio). You can also give a reporter class, e.g.
-# mypackage.mymodule.MyReporterClass.
-#output-format=
-
-# Tells whether to display a full report or only the messages.
-reports=no
-
-# Activate the evaluation score.
-score=yes
-
-
-[SIMILARITIES]
-
-# Comments are removed from the similarity computation
-ignore-comments=yes
-
-# Docstrings are removed from the similarity computation
-ignore-docstrings=yes
-
-# Imports are removed from the similarity computation
-ignore-imports=yes
-
-# Signatures are removed from the similarity computation
-ignore-signatures=yes
-
-# Minimum lines number of a similarity.
-min-similarity-lines=4
-
-
-[SPELLING]
-
-# Limits count of emitted suggestions for spelling mistakes.
-max-spelling-suggestions=4
-
-# Spelling dictionary name. No available dictionaries : You need to install
-# both the python package and the system dependency for enchant to work.
-spelling-dict=
-
-# List of comma separated words that should be considered directives if they
-# appear at the beginning of a comment and should not be checked.
-spelling-ignore-comment-directives=fmt: on,fmt: off,noqa:,noqa,nosec,isort:skip,mypy:
-
-# List of comma separated words that should not be checked.
-spelling-ignore-words=
-
-# A path to a file that contains the private dictionary; one word per line.
-spelling-private-dict-file=
-
-# Tells whether to store unknown words to the private dictionary (see the
-# --spelling-private-dict-file option) instead of raising a message.
-spelling-store-unknown-words=no
-
-
-[STRING]
-
-# This flag controls whether inconsistent-quotes generates a warning when the
-# character used as a quote delimiter is used inconsistently within a module.
-check-quote-consistency=no
-
-# This flag controls whether the implicit-str-concat should generate a warning
-# on implicit string concatenation in sequences defined over several lines.
-check-str-concat-over-line-jumps=no
-
-
-[TYPECHECK]
-
-# List of decorators that produce context managers, such as
-# contextlib.contextmanager. Add to this list to register other decorators that
-# produce valid context managers.
-contextmanager-decorators=contextlib.contextmanager
-
-# List of members which are set dynamically and missed by pylint inference
-# system, and so shouldn't trigger E1101 when accessed. Python regular
-# expressions are accepted.
-generated-members=
-
-# Tells whether to warn about missing members when the owner of the attribute
-# is inferred to be None.
-ignore-none=yes
-
-# This flag controls whether pylint should warn about no-member and similar
-# checks whenever an opaque object is returned when inferring. The inference
-# can return multiple potential results while evaluating a Python object, but
-# some branches might not be evaluated, which results in partial inference. In
-# that case, it might be useful to still emit no-member and other checks for
-# the rest of the inferred objects.
-ignore-on-opaque-inference=yes
-
-# List of symbolic message names to ignore for Mixin members.
-ignored-checks-for-mixins=no-member,
-                          not-async-context-manager,
-                          not-context-manager,
-                          attribute-defined-outside-init
-
-# List of class names for which member attributes should not be checked (useful
-# for classes with dynamically set attributes). This supports the use of
-# qualified names.
-ignored-classes=optparse.Values,thread._local,_thread._local,argparse.Namespace
-
-# Show a hint with possible names when a member name was not found. The aspect
-# of finding the hint is based on edit distance.
-missing-member-hint=yes
-
-# The minimum edit distance a name should have in order to be considered a
-# similar match for a missing member name.
-missing-member-hint-distance=1
-
-# The total number of similar names that should be taken in consideration when
-# showing a hint for a missing member.
-missing-member-max-choices=1
-
-# Regex pattern to define which classes are considered mixins.
-mixin-class-rgx=.*[Mm]ixin
-
-# List of decorators that change the signature of a decorated function.
-signature-mutators=
-
-
-[VARIABLES]
-
-# List of additional names supposed to be defined in builtins. Remember that
-# you should avoid defining new builtins when possible.
-additional-builtins=
-
-# Tells whether unused global variables should be treated as a violation.
-allow-global-unused-variables=yes
-
-# List of names allowed to shadow builtins
-allowed-redefined-builtins=
-
-# List of strings which can identify a callback function by name. A callback
-# name must start or end with one of those strings.
-callbacks=cb_,
-          _cb
-
-# A regular expression matching the name of dummy variables (i.e. expected to
-# not be used).
-dummy-variables-rgx=_+$|(_[a-zA-Z0-9_]*[a-zA-Z0-9]+?$)|dummy|^ignored_|^unused_
-
-# Argument names that match this expression will be ignored.
-ignored-argument-names=_.*|^ignored_|^unused_
-
-# Tells whether we should check for unused import in __init__ files.
-init-import=no
-
-# List of qualified module names which can have objects that can redefine
-# builtins.
-redefining-builtins-modules=six.moves,past.builtins,future.builtins,builtins,io
--- a/backend/Pipfile
+++ b/backend/Pipfile
@@ -4,14 +4,6 @@ verify_ssl = true
 name = "pypi"

 [dev-packages]
-pylint = "*"
-pytest = "*"
-tomli = "*"
-httpx = "*"
-exceptiongroup = "*"
-pytest-html = "*"
-typing-extensions = "*"
-dill = "*"

 [packages]
 numpy = "*"
@@ -23,5 +15,3 @@ osmpythontools = "*"
 pywikibot = "*"
 pymemcache = "*"
 fastapi-cli = "*"
-scikit-learn = "*"
-pyqt6 = "*"
--- a/backend/Pipfile.lock
+++ b/backend/Pipfile.lock
--- a/backend/conftest.py
+++ b/backend/conftest.py
@@ -1,47 +0,0 @@
-import pytest
-
-pytest_plugins = ["pytest_html"]
-
-def pytest_html_report_title(report):
-    """modifying the title  of html report"""
-    report.title = "Backend Testing Report"
-
-def pytest_html_results_table_header(cells):
-    cells.insert(2, "<th>Detailed trip</th>")
-    cells.insert(3, "<th>Trip Duration</th>")
-    cells.insert(4, "<th>Target Duration</th>")
-    cells[5] = "<th>Execution time</th>"            # rename the column containing execution times to avoid confusion
-
-
-def pytest_html_results_table_row(report, cells):
-    trip_details = getattr(report, "trip_details", "N/A")  # Default to "N/A" if no trip data
-    trip_duration = getattr(report, "trip_duration", "N/A")  # Default to "N/A" if no trip data
-    target_duration = getattr(report, "target_duration", "N/A")  # Default to "N/A" if no trip data
-    cells.insert(2, f"<td>{trip_details}</td>")
-    cells.insert(3, f"<td>{trip_duration}</td>")
-    cells.insert(4, f"<td>{target_duration}</td>")
-
-
-@pytest.hookimpl(hookwrapper=True)
-def pytest_runtest_makereport(item, call):
-    outcome = yield
-    report = outcome.get_result()
-    report.description = str(item.function.__doc__)
-
-    # Attach trip_details if it exists
-    if hasattr(item, "trip_details"):
-        report.trip_details = " - ".join(item.trip_details)  # Convert list to string
-    else:
-        report.trip_details = "N/A"  # Default if trip_string is not set
-
-    # Attach trip_duration if it exists
-    if hasattr(item, "trip_duration"):
-        report.trip_duration = item.trip_duration + " min"  
-    else:
-        report.trip_duration = "N/A"  # Default if duration is not set
-
-    # Attach target_duration if it exists
-    if hasattr(item, "target_duration"):
-        report.target_duration = item.target_duration + " min"  
-    else:
-        report.target_duration = "N/A"  # Default if duration is not set
--- a/backend/report.html
+++ b/backend/report.html
--- a/backend/src/init.py
+++ b/backend/src/init.py
--- a/backend/src/constants.py
+++ b/backend/src/constants.py
@@ -1,9 +1,6 @@
-"""Module allowing to access the parameters of route generation"""
-
-import logging
-import os
+import logging.config
 from pathlib import Path
-
+import os

 LOCATION_PREFIX = Path('src')
 PARAMETERS_DIR = LOCATION_PREFIX / 'parameters'
@@ -12,10 +9,12 @@ LANDMARK_PARAMETERS_PATH = PARAMETERS_DIR / 'landmark_parameters.yaml'
 OPTIMIZER_PARAMETERS_PATH = PARAMETERS_DIR / 'optimizer_parameters.yaml'


+
 cache_dir_string = os.getenv('OSM_CACHE_DIR', './cache')
 OSM_CACHE_DIR = Path(cache_dir_string)


+import logging
 # if we are in a debug session, set verbose and rich logging
 if os.getenv('DEBUG', "false") == "true":
    from rich.logging import RichHandler
--- a/backend/src/main.py
+++ b/backend/src/main.py
@@ -1,17 +1,14 @@
-"""Main app for backend api"""
-
 import logging
-from fastapi import FastAPI, HTTPException, Query
+from fastapi import FastAPI, Query, Body, HTTPException

-from .structs.landmark import Landmark, Toilets
-from .structs.preferences import Preferences
-from .structs.linked_landmarks import LinkedLandmarks
-from .structs.trip import Trip
-from .utils.landmarks_manager import LandmarkManager
-from .utils.toilets_manager import ToiletsManager
-from .utils.optimizer import Optimizer
-from .utils.refiner import Refiner
-from .persistence import client as cache_client
+from structs.landmark import Landmark
+from structs.preferences import Preferences
+from structs.linked_landmarks import LinkedLandmarks
+from structs.trip import Trip
+from utils.landmarks_manager import LandmarkManager
+from utils.optimizer import Optimizer
+from utils.refiner import Refiner
+from persistence import client as cache_client


 logger = logging.getLogger(__name__)
@@ -23,50 +20,26 @@ refiner = Refiner(optimizer=optimizer)


@app.post("/trip/new")
-def new_trip(preferences: Preferences,
-             start: tuple[float, float],
-             end: tuple[float, float] | None = None) -> Trip:
-    """
+def new_trip(preferences: Preferences, start: tuple[float, float], end: tuple[float, float] | None = None) -> Trip:
+    '''
    Main function to call the optimizer.
-
-    Args:
-        preferences : the preferences specified by the user as the post body
-        start       : the coordinates of the starting point
-        end         : the coordinates of the finishing point
-    Returns: 
-        (uuid) : The uuid of the first landmark in the optimized route
-    """
+    :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:
-        raise HTTPException(status_code=406, detail="Preferences not provided or incomplete.")
-    if (preferences.shopping.score == 0 and
-        preferences.sightseeing.score == 0 and
-        preferences.nature.score == 0) :
+        raise HTTPException(status_code=406, detail="Preferences not provided")
+    if preferences.shopping.score == 0 and preferences.sightseeing.score == 0 and preferences.nature.score == 0:
        raise HTTPException(status_code=406, detail="All preferences are 0.")
    if start is None:
        raise HTTPException(status_code=406, detail="Start coordinates not provided")
-    if not (-90 <= start[0] <= 90 or -180 <= start[1] <= 180):
-        raise HTTPException(status_code=422, detail="Start coordinates not in range")
    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='finish',
-                            type='finish',
-                            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='start', location=(start[0], start[1]), osm_type='start', osm_id=0, attractiveness=0, must_do=True, n_tags = 0)
+    end_landmark = Landmark(name='finish', type='finish', 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 = manager.generate_landmarks_list(
@@ -81,18 +54,16 @@ def new_trip(preferences: Preferences,
    # First stage optimization
    try:
        base_tour = optimizer.solve_optimization(preferences.max_time_minute, landmarks_short)
-    except ArithmeticError as exc:
-        raise HTTPException(status_code=500, detail="No solution found") from exc
-    except TimeoutError as exc:
-        raise HTTPException(status_code=500, detail="Optimzation took too long") from exc
+    except ArithmeticError:
+        raise HTTPException(status_code=500, detail="No solution found")
+    except TimeoutError:
+        raise HTTPException(status_code=500, detail="Optimzation took too long")
    
    # Second stage optimization
-    refined_tour = refiner.refine_optimization(landmarks, base_tour,
-                                               preferences.max_time_minute,
-                                               preferences.detour_tolerance_minute)
+    refined_tour = refiner.refine_optimization(landmarks, base_tour, preferences.max_time_minute, preferences.detour_tolerance_minute)

    linked_tour = LinkedLandmarks(refined_tour)
-    # upon creation of the trip, persistence of both the trip and its landmarks is ensured.
+    # upon creation of the trip, persistence of both the trip and its landmarks is ensured
    trip = Trip.from_linked_landmarks(linked_tour, cache_client)
    return trip

@@ -100,63 +71,17 @@ def new_trip(preferences: Preferences,
 #### For already existing trips/landmarks
@app.get("/trip/{trip_uuid}")
 def get_trip(trip_uuid: str) -> Trip:
-    """
-    Look-up the cache for a trip that has been previously generated using its identifier.
-
-    Args:
-        trip_uuid (str) : unique identifier for a trip.
-
-    Returns:
-        (Trip)          : the corresponding trip.
-    """
    try:
        trip = cache_client.get(f"trip_{trip_uuid}")
        return trip
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail="Trip not found") from exc
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Trip not found")


@app.get("/landmark/{landmark_uuid}")
 def get_landmark(landmark_uuid: str) -> Landmark:
-    """
-    Returns a Landmark from its unique identifier.
-
-    Args:
-        landmark_uuid (str) : unique identifier for a Landmark.
-
-    Returns:
-        (Landmark)          : the corresponding Landmark.
-    """
    try:
        landmark = cache_client.get(f"landmark_{landmark_uuid}")
        return landmark
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail="Landmark not found") from exc
-
-
-@app.post("/toilets/new")
-def get_toilets(location: tuple[float, float] = Query(...), radius: int = 500) -> list[Toilets] :
-    """
-    Endpoint to find toilets within a specified radius from a given location.
-
-    This endpoint expects the `location` and `radius` as **query parameters**, not in the request body.
-
-    Args:
-        location (tuple[float, float]): The latitude and longitude of the location to search from.
-        radius (int, optional): The radius (in meters) within which to search for toilets. Defaults to 500 meters.
-
-    Returns:
-        list[Toilets]: A list of Toilets objects that meet the criteria.
-    """
-    if location is None:
-        raise HTTPException(status_code=406, detail="Coordinates not provided or invalid")
-    if not (-90 <= location[0] <= 90 or -180 <= location[1] <= 180):
-        raise HTTPException(status_code=422, detail="Start coordinates not in range")
-    
-    toilets_manager = ToiletsManager(location, radius)
-
-    try :
-        toilets_list = toilets_manager.generate_toilet_list()
-        return toilets_list
-    except KeyError as exc:
-        raise HTTPException(status_code=404, detail="No toilets found") from exc
+    except KeyError:
+        raise HTTPException(status_code=404, detail="Landmark not found")
--- a/backend/src/parameters/amenity_selectors.yaml
+++ b/backend/src/parameters/amenity_selectors.yaml
@@ -71,10 +71,8 @@ sightseeing:
    - castle
    - museum

-museums:
-  tourism:
-    - museum
-    - aquarium
+
+

 # to be used later on
 restauration:
--- a/backend/src/parameters/landmark_parameters.yaml
+++ b/backend/src/parameters/landmark_parameters.yaml
@@ -1,12 +1,11 @@
 city_bbox_side: 7500 #m
 radius_close_to: 50
-church_coeff: 0.9
+church_coeff: 0.5
 nature_coeff: 1.25
 overall_coeff: 10
 tag_exponent: 1.15
 image_bonus: 10
 viewpoint_bonus: 15
-wikipedia_bonus: 4
-name_bonus: 3
+wikipedia_bonus: 6
 N_important: 40
 pay_bonus: -1
--- a/backend/src/parameters/optimizer_parameters.yaml
+++ b/backend/src/parameters/optimizer_parameters.yaml
@@ -3,4 +3,4 @@ detour_corridor_width: 300
 average_walking_speed: 4.8
 max_landmarks: 10
 max_landmarks_refiner: 30
-overshoot: 1.1
+overshoot: 1.8
--- a/backend/src/persistence.py
+++ b/backend/src/persistence.py
@@ -1,73 +1,26 @@
-"""Module used for handling cache"""
-from pymemcache import serde
 from pymemcache.client.base import Client
+from pymemcache import serde

-from .constants import MEMCACHED_HOST_PATH
+import constants


 class DummyClient:
-    """
-    A dummy in-memory client that mimics the behavior of a memcached client.
-
-    This class is designed to simulate the behavior of the `pymemcache.Client`
-    for testing or development purposes. It stores data in a Python dictionary
-    and provides methods to set, get, and update key-value pairs.
-
-    Attributes:
-        _data (dict): A dictionary that holds the key-value pairs.
-
-    Methods:
-        set(key, value, **kwargs):
-            Stores the given key-value pair in the internal dictionary.
-
-        set_many(data, **kwargs):
-            Updates the internal dictionary with multiple key-value pairs.
-
-        get(key, **kwargs):
-            Retrieves the value associated with the given key from the internal
-            dictionary.
-    """
    _data = {}
-    def set(self, key, value, **kwargs):    # pylint: disable=unused-argument
-        """
-        Store a key-value pair in the internal dictionary.
-
-        Args:
-            key: The key for the item to be stored.
-            value: The value to be stored under the given key.
-            **kwargs: Additional keyword arguments (unused).
-        """
+    def set(self, key, value, **kwargs):
        self._data[key] = value

-    def set_many(self, data, **kwargs): # pylint: disable=unused-argument
-        """
-        Update the internal dictionary with multiple key-value pairs.
-
-        Args:
-            data: A dictionary containing key-value pairs to be added.
-            **kwargs: Additional keyword arguments (unused).
-        """
+    def set_many(self, data, **kwargs):
        self._data.update(data)

-    def get(self, key, **kwargs):   # pylint: disable=unused-argument
-        """
-        Retrieve the value associated with the given key.
-
-        Args:
-            key: The key for the item to be retrieved.
-            **kwargs: Additional keyword arguments (unused).
-
-        Returns:
-            The value associated with the given key if it exists.
-        """
+    def get(self, key, **kwargs):
        return self._data[key]


-if MEMCACHED_HOST_PATH is None:
+if constants.MEMCACHED_HOST_PATH is None:
    client = DummyClient()
 else:
    client = Client(
-        MEMCACHED_HOST_PATH,
+        constants.MEMCACHED_HOST_PATH,
        timeout = 1,
        allow_unicode_keys = True,
        encoding = 'utf-8',
--- a/backend/src/sandbox/bandung_data.json
+++ b/backend/src/sandbox/bandung_data.json
--- a/backend/src/sandbox/colmar_data.json
+++ b/backend/src/sandbox/colmar_data.json
@@ -1,698 +0,0 @@
-{
-    "type": "FeatureCollection",
-    "generator": "overpass-turbo",
-    "copyright": "The data included in this document is from www.openstreetmap.org. The data is made available under ODbL.",
-    "timestamp": "2024-12-02T21:14:59Z",
-    "features": [
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/1345741798",
-          "name": "Cordonnerie Saint-Joseph",
-          "shop": "shoes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3481705,
-            48.0816462
-          ]
-        },
-        "id": "node/1345741798"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/2659184738",
-          "brand": "Armand Thiery",
-          "brand:wikidata": "Q2861975",
-          "brand:wikipedia": "fr:Armand Thiery",
-          "name": "Armand Thiery",
-          "opening_hours": "Mo-Sa 09:30-19:00",
-          "shop": "clothes",
-          "wheelchair": "limited"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3594454,
-            48.0785574
-          ]
-        },
-        "id": "node/2659184738"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/3618136290",
-          "name": "Chez Dominique",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3362362,
-            48.0712174
-          ]
-        },
-        "id": "node/3618136290"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/3618136605",
-          "name": "Divamod",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3304253,
-            48.0782989
-          ]
-        },
-        "id": "node/3618136605"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/3618284507",
-          "name": "Star tendances et voyages",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3474029,
-            48.0830993
-          ]
-        },
-        "id": "node/3618284507"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/3619696125",
-          "brand": "Zeeman",
-          "brand:wikidata": "Q184399",
-          "name": "Zeeman",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3413834,
-            48.0638444
-          ]
-        },
-        "id": "node/3619696125"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/4594398129",
-          "name": "Miss et Mister",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3308309,
-            48.0779118
-          ]
-        },
-        "id": "node/4594398129"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/4907320441",
-          "brand": "Sergent Major",
-          "brand:wikidata": "Q62521738",
-          "clothes": "babies;children",
-          "name": "Sergent Major",
-          "opening_hours": "Mo-Sa 09:30-19:00",
-          "shop": "clothes",
-          "wheelchair": "no"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.359116,
-            48.0787229
-          ]
-        },
-        "id": "node/4907320441"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/4907364791",
-          "brand": "Armand Thiery",
-          "brand:wikidata": "Q2861975",
-          "brand:wikipedia": "fr:Armand Thiery",
-          "clothes": "women",
-          "name": "Armand Thiery",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3601857,
-            48.0783373
-          ]
-        },
-        "id": "node/4907364791"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/4907385675",
-          "check_date": "2024-05-19",
-          "clothes": "children",
-          "name": "Du Pareil...au même",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3604521,
-            48.0779726
-          ]
-        },
-        "id": "node/4907385675"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/4922191645",
-          "name": "Abilos",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3566167,
-            48.0794136
-          ]
-        },
-        "id": "node/4922191645"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/4922191648",
-          "brand": "Esprit",
-          "brand:wikidata": "Q532746",
-          "brand:wikipedia": "en:Esprit Holdings",
-          "name": "Esprit",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3554004,
-            48.0787549
-          ]
-        },
-        "id": "node/4922191648"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/4922191972",
-          "brand": "Guess",
-          "brand:wikidata": "Q2470307",
-          "brand:wikipedia": "en:Guess (clothing)",
-          "name": "Guess",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.355273,
-            48.0788003
-          ]
-        },
-        "id": "node/4922191972"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/4922192001",
-          "name": "Lingerie",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3575453,
-            48.0779317
-          ]
-        },
-        "id": "node/4922192001"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/5359915869",
-          "name": "Al Assil",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3305665,
-            48.0780902
-          ]
-        },
-        "id": "node/5359915869"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/9089360040",
-          "brand": "Grain de Malice",
-          "brand:wikidata": "Q66757157",
-          "clothes": "women",
-          "name": "Grain de Malice",
-          "shop": "clothes",
-          "short_name": "GDM"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3593125,
-            48.0786234
-          ]
-        },
-        "id": "node/9089360040"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/9095193153",
-          "brand": "Undiz",
-          "brand:wikidata": "Q105306275",
-          "clothes": "underwear",
-          "name": "Undiz",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3599579,
-            48.0782846
-          ]
-        },
-        "id": "node/9095193153"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/9095193154",
-          "branch": "Lingerie",
-          "brand": "RougeGorge",
-          "brand:wikidata": "Q104600739",
-          "clothes": "underwear",
-          "name": "RougeGorge",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3604883,
-            48.0781607
-          ]
-        },
-        "id": "node/9095193154"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/9095212690",
-          "alt_name": "North Face",
-          "brand": "The North Face",
-          "brand:wikidata": "Q152784",
-          "brand:wikipedia": "en:The North Face",
-          "check_date": "2024-05-19",
-          "name": "The North Face",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3603923,
-            48.0773727
-          ]
-        },
-        "id": "node/9095212690"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/9095270059",
-          "air_conditioning": "no",
-          "clothes": "men",
-          "level": "0",
-          "name": "Maison Aume",
-          "second_hand": "no",
-          "shop": "clothes",
-          "wheelchair": "no"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.361364,
-            48.0799999
-          ]
-        },
-        "id": "node/9095270059"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/9098624272",
-          "name": "Destock Place",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3575161,
-            48.0793009
-          ]
-        },
-        "id": "node/9098624272"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/9123861652",
-          "name": "Weackers",
-          "shop": "shoes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.361329,
-            48.0785972
-          ]
-        },
-        "id": "node/9123861652"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/9162179887",
-          "brand": "Calzedonia",
-          "brand:wikidata": "Q1027874",
-          "brand:wikipedia": "en:Calzedonia",
-          "name": "Calzedonia",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3606374,
-            48.0780809
-          ]
-        },
-        "id": "node/9162179887"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/9162206449",
-          "clothes": "women",
-          "name": "Cop. Copine",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3600947,
-            48.078399
-          ]
-        },
-        "id": "node/9162206449"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/9162226360",
-          "brand": "Okaïdi",
-          "brand:wikidata": "Q3350027",
-          "brand:wikipedia": "fr:Okaïdi",
-          "name": "Okaïdi",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3596986,
-            48.078428
-          ]
-        },
-        "id": "node/9162226360"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/9162227010",
-          "brand": "Jules",
-          "brand:wikidata": "Q3188386",
-          "brand:wikipedia": "fr:Jules (enseigne)",
-          "clothes": "men",
-          "name": "Jules",
-          "opening_hours": "Mo-Sa 09:30-19:00",
-          "phone": "+33 3 89 41 03 62",
-          "shop": "clothes",
-          "website": "https://www.jules.com/fr-fr/magasins/1600133/"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3600323,
-            48.0782229
-          ]
-        },
-        "id": "node/9162227010"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/10151865029",
-          "name": "Atelier Cinq",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3571756,
-            48.0772657
-          ]
-        },
-        "id": "node/10151865029"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/10862176110",
-          "name": "L'hexagone",
-          "shop": "bag"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3808571,
-            48.0814138
-          ]
-        },
-        "id": "node/10862176110"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/11150877331",
-          "brand": "Punt Roma",
-          "brand:wikidata": "Q101423290",
-          "clothes": "women",
-          "name": "Punt Roma",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3571859,
-            48.0779406
-          ]
-        },
-        "id": "node/11150877331"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/11150959880",
-          "name": "Caroll",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3579354,
-            48.0779291
-          ]
-        },
-        "id": "node/11150959880"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/11302242094",
-          "branch": "Wintzenheim",
-          "name": "Label Fripe",
-          "opening_hours": "Mo-Sa 09:00-18:45",
-          "phone": "+33 3 89 27 39 25",
-          "second_hand": "only",
-          "shop": "clothes",
-          "website": "https://labelfripe.fr/label-fripe-wintzenheim/"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3109899,
-            48.0850362
-          ]
-        },
-        "id": "node/11302242094"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/11392247003",
-          "name": "Lingerie Sipp",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3111507,
-            48.0841835
-          ]
-        },
-        "id": "node/11392247003"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/11778819781",
-          "addr:city": "Colmar",
-          "addr:housenumber": "10",
-          "addr:postcode": "68000",
-          "addr:street": "Rue des Têtes",
-          "clothes": "suits;hats;men",
-          "name": "Phillipe",
-          "phone": "0389411983",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3559389,
-            48.0789064
-          ]
-        },
-        "id": "node/11778819781"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/11799215969",
-          "brand": "Petit Bateau",
-          "brand:wikidata": "Q3377090",
-          "name": "Petit Bateau",
-          "opening_hours": "Mo-Sa 10:00-19:00; Su 10:00-18:00",
-          "phone": "+33 3 89 24 97 85",
-          "shop": "clothes",
-          "website": "https://stores.petit-bateau.com/france/colmar/9-rue-des-boulangers"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.355149,
-            48.0780213
-          ]
-        },
-        "id": "node/11799215969"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/11816704669",
-          "addr:housenumber": "10",
-          "addr:street": "Rue des Boulangers",
-          "name": "des petits hauts",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3555001,
-            48.0780768
-          ]
-        },
-        "id": "node/11816704669"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/12320343534",
-          "addr:city": "Colmar",
-          "addr:housenumber": "44",
-          "addr:postcode": "68000",
-          "addr:street": "Rue des Clefs",
-          "brand": "Un Jour Ailleurs",
-          "brand:wikidata": "Q105106211",
-          "clothes": "women",
-          "name": "Un Jour Ailleurs",
-          "opening_hours": "Mo-Fr 10:00-19:00; Sa 10:00-18:30",
-          "phone": "+33368318572",
-          "shop": "clothes",
-          "website": "https://boutique.unjourailleurs.com/fr/mode-femme/boutique-colmar-76"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.35897,
-            48.0789807
-          ]
-        },
-        "id": "node/12320343534"
-      },
-      {
-        "type": "Feature",
-        "properties": {
-          "@id": "node/12320343536",
-          "addr:city": "Colmar",
-          "addr:housenumber": "38",
-          "addr:postcode": "68000",
-          "addr:street": "Rue des Clefs",
-          "brand": "Timberland",
-          "brand:wikidata": "Q1539185",
-          "name": "Timberland",
-          "opening_hours": "Mo-Sa 10:00-19:00",
-          "phone": "+33389298650",
-          "shop": "clothes"
-        },
-        "geometry": {
-          "type": "Point",
-          "coordinates": [
-            7.3592409,
-            48.0788785
-          ]
-        },
-        "id": "node/12320343536"
-      }
-    ]
-  }
--- a/backend/src/sandbox/get_streets.py
+++ b/backend/src/sandbox/get_streets.py
@@ -1,350 +0,0 @@
-# pylint: skip-file
-
-import numpy as np
-import json
-import os
-from typing import Optional, Literal
-from sklearn.cluster import DBSCAN
-from sklearn.decomposition import PCA
-import matplotlib.pyplot as plt
-from pydantic import BaseModel
-from OSMPythonTools.overpass import Overpass, overpassQueryBuilder
-from OSMPythonTools.cachingStrategy import CachingStrategy, JSON
-from math import sin, cos, sqrt, atan2, radians
-
-
-EARTH_RADIUS_KM = 6373
-
-
-class ShoppingLocation(BaseModel):
-    type: Literal['street', 'area']
-    importance: int
-    centroid: tuple
-    start: Optional[list] = None
-    end: Optional[list] = None
-
-
-# Output to frontend
-class Landmark(BaseModel) :
-    # Properties of the landmark
-    name : str
-    type: Literal['sightseeing', 'nature', 'shopping', 'start', 'finish']
-    location : tuple
-    osm_type : str
-    osm_id : int
-    attractiveness : int
-    n_tags : int
-    image_url : Optional[str] = None
-    website_url : Optional[str] = None
-    description : Optional[str] = None                          # TODO future
-    duration : Optional[int] = 0
-    name_en : Optional[str] = None
-
-    # Additional properties depending on specific tour
-    must_do : Optional[bool] = False
-    must_avoid : Optional[bool] = False
-    is_secondary : Optional[bool] = False
-
-    time_to_reach_next : Optional[int] = 0
-    next_uuid : Optional[str] = None
-
-
-def extract_points(filestr: str) :
-    """
-    Extract points from geojson file.
-
-    Returns :
-        np.array containing the points
-    """
-    points = []
-
-    with open(os.path.dirname(__file__) + '/' + filestr, 'r') as f:
-        geojson = json.load(f)
-
-        for feature in geojson['features']:
-            if feature['geometry']['type'] == 'Point':
-                centroid = feature['geometry']['coordinates']
-                points.append(centroid)
-
-            elif feature['geometry']['type'] == 'Polygon':
-                centroid = np.array(feature['geometry']['coordinates'][0][0])
-                points.append(centroid)
-    
-    # Convert the list of points to a NumPy array
-    return np.array(points)
-
-
-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
-
-def filter_clusters(cluster_points, cluster_labels):
-    """
-    Remove clusters of less importance.
-    """
-    label_counts = np.bincount(cluster_labels)
-
-    # Step 3: Get the indices (labels) of the 5 largest clusters
-    top_5_labels = np.argsort(label_counts)[-5:]  # Get the largest 5 clusters
-
-    # Step 4: Filter points to keep only the points in the top 5 clusters
-    filtered_cluster_points = []
-    filtered_cluster_labels = []
-
-    for label in top_5_labels:
-        filtered_cluster_points.append(cluster_points[cluster_labels == label])
-        filtered_cluster_labels.append(np.full((label_counts[label],), label))  # Replicate the label
-
-    # Concatenate filtered clusters into a single array
-    return np.vstack(filtered_cluster_points), np.concatenate(filtered_cluster_labels)
-
-
-def fit_lines(points, labels):
-    """
-    Fit lines to identified clusters.
-    """
-    all_x = []
-    all_y = []
-    lines = []
-    locations = []
-
-    for label in set(labels):
-        cluster_points = points[labels == label]
-
-        # If there's not enough points, skip
-        if len(cluster_points) < 2:
-            continue
-
-        # Apply PCA to find the principal component (i.e., the line of best fit)
-        pca = PCA(n_components=1)
-        pca.fit(cluster_points)
-
-        direction = pca.components_[0]
-        centroid = pca.mean_
-
-        # Project the cluster points onto the principal direction (line direction)
-        projections = np.dot(cluster_points - centroid, direction)
-
-        # Get the range of the projections to find the approximate length of the cluster
-        cluster_length = projections.max() - projections.min()
-
-        # Now adjust `t` so that it scales with the cluster length
-        t = np.linspace(-cluster_length / 2.75, cluster_length / 2.75, 10)
-
-        # Calculate the start and end of the line based on min/max projections
-        start_point = centroid[0] + t*direction[0]
-        end_point = centroid[1] + t*direction[1]
-        
-        # Store the line
-        lines.append((start_point, end_point))
-
-        # For visualization, store the points
-        all_x.append(min(start_point))
-        all_x.append(max(start_point))
-        all_y.append(min(end_point))
-        all_y.append(max(end_point))
-
-        if np.linalg.norm(t) <= 0.0045 :
-            loc = ShoppingLocation(
-                type='area',
-                centroid=tuple((centroid[1], centroid[0])),
-                importance = len(cluster_points),
-            )
-        else :
-            loc = ShoppingLocation(
-                type='street',
-                centroid=tuple((centroid[1], centroid[0])),
-                importance = len(cluster_points),
-                start=start_point,
-                end=end_point
-            )
-
-        locations.append(loc)
-
-    xmin = min(all_x)
-    xmax = max(all_x)
-    ymin = min(all_y)
-    ymax = max(all_y)
-    corners = (xmin, xmax, ymin, ymax)
-
-    return corners, locations
-
-
-
-def create_landmark(shopping_location: ShoppingLocation):
-
-    # Define the bounding box for a given radius around the coordinates
-    lat, lon = shopping_location.centroid
-    bbox = ("around:1000", str(lat), str(lon))
-    
-    overpass = Overpass()
-    # CachingStrategy.use(JSON, cacheDir=OSM_CACHE_DIR)
-
-    # Query neighborhoods and shopping malls
-    selectors = ['"place"~"^(suburb|neighborhood|neighbourhood|quarter|city_block)$"', '"shop"="mall"']
-
-    min_dist = float('inf')
-    new_name = 'Shopping Area'
-    new_name_en = None
-    osm_id = 0
-    osm_type = 'node'
-
-    for sel in selectors : 
-        query = overpassQueryBuilder(
-            bbox = bbox,
-            elementType = ['node', 'way', 'relation'],
-            selector = sel,
-            includeCenter = True,
-            out = 'center'
-        )
-
-        try:
-            result = overpass.query(query)
-        except Exception as e:
-            raise Exception("query unsuccessful")
-
-        for elem in result.elements():
-
-            location = (elem.centerLat(), elem.centerLon())
-
-            if location[0] is None : 
-                location = (elem.lat(), elem.lon())
-                if location[0] is None : 
-                    # print(f"Fetching coordinates failed with {elem.type()}/{elem.id()}")
-                    continue
-
-            # print(f"Distance : {get_distance(shopping_location.centroid, location)}")
-            d = get_distance(shopping_location.centroid, location)
-            if  d < min_dist :
-                min_dist = d
-                new_name = elem.tag('name')
-                osm_type = elem.type()              # Add type: 'way' or 'relation'
-                osm_id = elem.id()                  # Add OSM id 
-
-                # add english name if it exists
-                try :
-                    new_name_en = elem.tag('name:en')
-                except:
-                    pass 
-    
-    return Landmark(
-        name=new_name,
-        type='shopping',
-        location=shopping_location.centroid,              # TODO: use the fact the we can also recognize streets.
-        attractiveness=shopping_location.importance,
-        n_tags=0,
-        osm_id=osm_id,
-        osm_type=osm_type,
-        name_en=new_name_en
-    )
-
-
-# Extract points
-points = extract_points('vienna_data.json')
-
-# print(len(points))
-
-######## Create a figure with 1 row and 3 columns for side-by-side plots
-fig, axes = plt.subplots(1, 3, figsize=(15, 5))
-# Plot Raw data points
-axes[0].set_title('Raw Data')
-axes[0].scatter(points[:, 0], points[:, 1], color='blue', s=20)
-
-
-# Apply DBSCAN to find clusters. Choose different settings for different cities.
-if len(points) > 400 :
-    dbscan = DBSCAN(eps=0.00118, min_samples=15, algorithm='kd_tree')  # for large cities
-else :
-    dbscan = DBSCAN(eps=0.00075, min_samples=10, algorithm='kd_tree')  # for small cities
-
-labels = dbscan.fit_predict(points)
-
-# Separate clustered points and noise points
-clustered_points = points[labels != -1]
-clustered_labels = labels[labels != -1]
-noise_points = points[labels == -1] 
-
-######## Plot n°1: DBSCAN Clustering Results
-axes[1].set_title('DBSCAN Clusters')
-axes[1].scatter(clustered_points[:, 0], clustered_points[:, 1], c=clustered_labels, cmap='rainbow', s=20)
-axes[1].scatter(noise_points[:, 0], noise_points[:, 1], c='blue', s=7, label='Noise')
-
-# Keep the 5 biggest clusters
-clustered_points, clustered_labels = filter_clusters(clustered_points, clustered_labels)
-
-# Fit lines
-corners, locations = fit_lines(clustered_points, clustered_labels)
-(xmin, xmax, ymin, ymax) = corners
-
-
-######## Plot clustered points in normal size and noise points separately
-axes[2].scatter(clustered_points[:, 0], clustered_points[:, 1], c=clustered_labels, cmap='rainbow', s=30)
-axes[2].set_title('PCA Fitted Lines on Clusters')
-
-# Create a list of Landmarks for the shopping things
-shopping_landmarks = []
-for loc in locations :
-    axes[2].scatter(loc.centroid[1], loc.centroid[0], color='red', marker='x', s=200, linewidth=3)
-    landmark = create_landmark(loc)
-    shopping_landmarks.append(landmark)
-    axes[2].text(loc.centroid[1], loc.centroid[0], landmark.name, 
-             ha='center', va='top', fontsize=6, 
-             bbox=dict(facecolor='white', edgecolor='black', boxstyle='round,pad=0.2'),
-             zorder=3)
-    
-    
-
-####### Plot the detected lines in the final plot #######
-# for loc in locations:
-#     if loc.type == 'street' :
-#         line_x = loc.start
-#         line_y = loc.end
-#         axes[2].plot(line_x, line_y, color='lime', linewidth=3)
-#     else :
-
-
-
-axes[0].set_xlim(xmin-0.01, xmax+0.01)
-axes[0].set_ylim(ymin-0.01, ymax+0.01)
-
-axes[1].set_xlim(xmin-0.01, xmax+0.01)
-axes[1].set_ylim(ymin-0.01, ymax+0.01)
-
-axes[2].set_xlim(xmin-0.01, xmax+0.01)
-axes[2].set_ylim(ymin-0.01, ymax+0.01)
-
-
-print("\n\n\n")
-for landmark in shopping_landmarks :
-    print(f"{landmark.name} is a shopping area with a score of {landmark.attractiveness}")
-
-
-plt.tight_layout()
-plt.show()
--- a/backend/src/sandbox/lyon_data.json
+++ b/backend/src/sandbox/lyon_data.json
--- a/backend/src/sandbox/newyork_data.json
+++ b/backend/src/sandbox/newyork_data.json
--- a/backend/src/sandbox/paris_data.json
+++ b/backend/src/sandbox/paris_data.json
--- a/backend/src/sandbox/strasbourg_data.json
+++ b/backend/src/sandbox/strasbourg_data.json
--- a/backend/src/sandbox/vienna_data.json
+++ b/backend/src/sandbox/vienna_data.json
--- a/backend/src/sandbox/winterthur_data.json
+++ b/backend/src/sandbox/winterthur_data.json
--- a/backend/src/sandbox/zurich_data.json
+++ b/backend/src/sandbox/zurich_data.json
--- a/backend/src/structs/landmark.py
+++ b/backend/src/structs/landmark.py
@@ -1,41 +1,10 @@
-"""Definition of the Landmark class to handle visitable objects across the world."""
-
 from typing import Optional, Literal
-from uuid import uuid4
 from pydantic import BaseModel, Field

+from uuid import uuid4

 # Output to frontend
 class Landmark(BaseModel) :
-    """
-    A class representing a landmark or point of interest (POI) in the context of a trip.
-
-    The Landmark class is used to model visitable locations, such as tourist attractions,
-    natural sites, shopping locations, and start/end points in travel itineraries. It
-    holds information about the landmark's attributes and supports comparisons and
-    calculations, such as distance between landmarks.
-
-    Attributes:
-        name (str): The name of the landmark.
-        type (Literal): The type of the landmark, which can be one of ['sightseeing', 'nature', 
-            'shopping', 'start', 'finish'].
-        location (tuple): A tuple representing the (latitude, longitude) of the landmark.
-        osm_type (str): The OpenStreetMap (OSM) type of the landmark.
-        osm_id (int): The OpenStreetMap (OSM) ID of the landmark.
-        attractiveness (int): A score representing the attractiveness of the landmark.
-        n_tags (int): The number of tags associated with the landmark.
-        image_url (Optional[str]): A URL to an image of the landmark.
-        website_url (Optional[str]): A URL to the landmark's official website.
-        description (Optional[str]): A text description of the landmark.
-        duration (Optional[int]): The estimated time to visit the landmark (in minutes).
-        name_en (Optional[str]): The English name of the landmark.
-        uuid (str): A unique identifier for the landmark, generated by default using uuid4.
-        must_do (Optional[bool]): Whether the landmark is a "must-do" attraction.
-        must_avoid (Optional[bool]): Whether the landmark should be avoided.
-        is_secondary (Optional[bool]): Whether the landmark is secondary or less important.
-        time_to_reach_next (Optional[int]): Estimated time (in minutes) to reach the next landmark.
-        next_uuid (Optional[str]): UUID of the next landmark in sequence (if applicable).
-    """

    # Properties of the landmark
    name : str
@@ -57,86 +26,27 @@ class Landmark(BaseModel) :
    # Additional properties depending on specific tour
    must_do : Optional[bool] = False
    must_avoid : Optional[bool] = False
-    is_secondary : Optional[bool] = False
+    is_secondary : Optional[bool] = False                       # TODO future   

    time_to_reach_next : Optional[int] = 0
    next_uuid : Optional[str] = None

    def __str__(self) -> str:
-        """
-        String representation of the Landmark object.
-
-        Returns:
-            str: A formatted string with the landmark's type, name, location, attractiveness score,
-            time to the next landmark (if available), and whether the landmark is secondary.
-        """
-        t_to_next_str = f", time_to_next={self.time_to_reach_next}" if self.time_to_reach_next else ""
-        is_secondary_str = ", secondary" if self.is_secondary else ""
+        time_to_next_str = f", time_to_next={self.time_to_reach_next}" if self.time_to_reach_next else ""
+        is_secondary_str = f", secondary" if self.is_secondary else ""
        type_str = '(' + self.type + ')'
-
-        return (f'Landmark{type_str}: [{self.name} @{self.location}, '
-                f'score={self.attractiveness}{t_to_next_str}{is_secondary_str}]')
+        if self.type in ["start", "finish", "nature", "shopping"] : type_str += '\t '
+        return f'Landmark{type_str}: [{self.name} @{self.location}, score={self.attractiveness}{time_to_next_str}{is_secondary_str}]'

    def distance(self, value: 'Landmark') -> float:
-        """
-        Calculates the squared distance between this landmark and another.
-
-        Args:
-            value (Landmark): Another Landmark object to calculate the distance to.
-
-        Returns:
-            float: The squared Euclidean distance between the two landmarks.
-        """
        return (self.location[0] - value.location[0])**2 + (self.location[1] - value.location[1])**2

    def __hash__(self) -> int:
-        """
-        Generates a hash for the Landmark based on its name.
-
-        Returns:
-            int: The hash of the landmark.
-        """
        return hash(self.name)

    def __eq__(self, value: 'Landmark') -> bool:
-        """
-        Checks equality between two Landmark objects based on UUID, OSM ID, and name.
-
-        Args:
-            value (Landmark): Another Landmark object to compare.
-
-        Returns:
-            bool: True if the landmarks are equal, False otherwise.
-        """
        # eq and hash must be consistent
        # in particular, if two objects are equal, their hash must be equal
        # uuid and osm_id are just shortcuts to avoid comparing all the properties
        # if they are equal, we know that the name is also equal and in turn the hash is equal
-        return (self.uuid == value.uuid or
-                self.osm_id == value.osm_id or
-                (self.name == value.name and self.distance(value) < 0.001))
-
-
-class Toilets(BaseModel) :
-    """
-    Model for toilets. When false/empty the information is either false either not known.
-    """
-    location : tuple
-    wheelchair : Optional[bool] = False
-    changing_table : Optional[bool] = False
-    fee : Optional[bool] = False
-    opening_hours : Optional[str] = ""
-
-
-    def __str__(self) -> str:
-        """
-        String representation of the Toilets object.
-
-        Returns:
-            str: A formatted string with the toilets location.
-        """
-        return f'Toilets @{self.location}'
-    
-    class Config:
-        # This allows us to easily convert the model to and from dictionaries
-        orm_mode = True
+        return self.uuid == value.uuid or self.osm_id == value.osm_id or (self.name == value.name and self.distance(value) < 0.001)
--- a/backend/src/structs/linked_landmarks.py
+++ b/backend/src/structs/linked_landmarks.py
@@ -1,17 +1,10 @@
-"""Linked and ordered list of Landmarks that represents the visiting order."""
-
 from .landmark import Landmark
-from ..utils.get_time_separation import get_time
+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).
+    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]
@@ -19,12 +12,10 @@ class LinkedLandmarks:

    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.
+        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.
+            data (list[Landmark], optional): The list of landmarks that are linked together. Defaults to None.
        """
        self._landmarks = data if data else []
        self._link_landmarks()
@@ -32,8 +23,7 @@ class LinkedLandmarks:

    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.
+        Create the links between the landmarks in the list by setting their .next_uuid and the .time_to_next attributes.
        """

        # Mark secondary landmarks as such
@@ -45,15 +35,11 @@ class LinkedLandmarks:
            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.total_time += landmark.duration

        self._landmarks[-1].next_uuid = None
        self._landmarks[-1].time_to_reach_next = 0

    def update_secondary_landmarks(self) -> None:
-        """
-        Mark landmarks with lower importance as secondary.
-        """
        # Extract the attractiveness scores and sort them in descending order
        scores = sorted([landmark.attractiveness for landmark in self._landmarks], reverse=True)
        
@@ -61,12 +47,12 @@ class LinkedLandmarks:
        if len(scores) >= 10:
            threshold_score = scores[9]
        else:
-            # If there are fewer than 10 landmarks, use the lowest score as the threshold
+            # If there are fewer than 10 landmarks, use the lowest score in the list as the threshold
            threshold_score = min(scores) if scores else 0
        
        # Update 'is_secondary' for landmarks with attractiveness below the threshold score
        for landmark in self._landmarks:
-            if (landmark.attractiveness < threshold_score and landmark.type not in ["start", "finish"]):
+            if landmark.attractiveness < threshold_score and landmark.type not in ["start", "finish"]:
                landmark.is_secondary = True


--- a/backend/src/structs/preferences.py
+++ b/backend/src/structs/preferences.py
@@ -1,26 +1,12 @@
-"""Defines the Preferences used as input for trip generation."""
-
-from typing import Optional, Literal
 from pydantic import BaseModel
-
+from typing import Optional, Literal

 class Preference(BaseModel) :
-    """
-    Type of preference.
-
-    Attributes:
-        type: what kind of landmark type.
-        score: how important that type is.
-    """
    type: Literal['sightseeing', 'nature', 'shopping', 'start', 'finish']
    score: int          # score could be from 1 to 5

-
 # Input for optimization
 class Preferences(BaseModel) :
-    """"
-    Full collection of preferences needed to generate a personalized trip.
-    """
    # Sightseeing / History & Culture (Musées, bâtiments historiques, opéras, églises)
    sightseeing : Preference

@@ -30,5 +16,5 @@ class Preferences(BaseModel) :
    # Shopping (diriger plutôt vers des zones / rues commerçantes)
    shopping : Preference

-    max_time_minute: Optional[int] = 3*60
+    max_time_minute: Optional[int] = 6*60
    detour_tolerance_minute: Optional[int] = 0
--- a/backend/src/structs/trip.py
+++ b/backend/src/structs/trip.py
@@ -1,31 +1,17 @@
-"""Definition of the Trip class."""
-
-import uuid
 from pydantic import BaseModel, Field
 from pymemcache.client.base import Client

 from .linked_landmarks import LinkedLandmarks
-
+import uuid

 class Trip(BaseModel):
-    """"
-    A Trip represents the final guided tour that can be passed to frontend.
-
-    Attributes:
-        uuid: unique identifier for this particular trip.
-        total_time: duration of the trip (in minutes).
-        first_landmark_uuid: unique identifier of the first Landmark to visit.
-
-    Methods:
-        from_linked_landmarks: create a Trip from LinkedLandmarks object.
-    """
    uuid: str = Field(default_factory=uuid.uuid4)
    total_time: int
    first_landmark_uuid: str


    @classmethod
-    def from_linked_landmarks(cls, landmarks: LinkedLandmarks, cache_client: Client) -> "Trip":
+    def from_linked_landmarks(self, landmarks: LinkedLandmarks, cache_client: Client) -> "Trip":
        """
        Initialize a new Trip object and ensure it is stored in the cache.
        """
@@ -36,11 +22,8 @@ class Trip(BaseModel):

        # Store the trip in the cache
        cache_client.set(f"trip_{trip.uuid}", trip)
-
-        # Make sure to await the result (noreply=False).
-        # Otherwise the cache might not be inplace when the trip is actually requested.
-        cache_client.set_many({f"landmark_{landmark.uuid}": landmark for landmark in landmarks},
-                              expire=3600, noreply=False)
+        # make sure to await the result (noreply=False). Otherwise the cache might not be inplace when the trip is actually requested
+        cache_client.set_many({f"landmark_{landmark.uuid}": landmark for landmark in landmarks}, expire=3600, noreply=False)
        # is equivalent to:
        # for landmark in landmarks:
        #     cache_client.set(f"landmark_{landmark.uuid}", landmark, expire=3600)
--- a/backend/src/tester.py
+++ b/backend/src/tester.py
@@ -0,0 +1,80 @@
+import logging
+import yaml
+
+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__)
+
+
+
+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(
+        sightseeing=Preference(type='sightseeing', score = 5),
+        nature=Preference(type='nature', score = 5),
+        shopping=Preference(type='shopping', score = 5),
+        max_time_minute=15,
+        detour_tolerance_minute=0
+    )
+
+    # Create start and finish 
+    if finish_coords is None :
+        finish_coords = start_coords
+    start = Landmark(name='start', type='start', location=start_coords, osm_type='', osm_id=0, attractiveness=0, n_tags = 0)
+    finish = Landmark(name='finish', type='finish', location=finish_coords, osm_type='', osm_id=0, attractiveness=0, 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
+    landmarks, landmarks_short = manager.generate_landmarks_list(
+        center_coordinates = start_coords,
+        preferences = preferences
+    )
+    
+    # Store data to file for debug purposes
+    # write_data(landmarks, "landmarks_Strasbourg.txt")
+
+    # Insert start and finish to the landmarks list
+    landmarks_short.insert(0, start)
+    landmarks_short.append(finish)
+
+    # First stage optimization
+    base_tour = optimizer.solve_optimization(max_time=preferences.max_time_minute, landmarks=landmarks_short)
+
+    # Second stage using linear optimization
+    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)
+    total_time = 0           
+    logger.info("Optimized route : ")
+    for l in linked_tour :
+        logger.info(f"{l}")
+    logger.info(f"Estimated length of tour : {linked_tour.total_time} mintutes and visiting {len(linked_tour._landmarks)} landmarks.")
+
+    # with open('linked_tour.yaml', 'w') as f:
+    #     yaml.dump(linked_tour.asdict(), f)
+
+    return linked_tour
+
+
+# test(tuple((48.8344400, 2.3220540)))       # Café Chez César 
+# test(tuple((48.8375946, 2.2949904)))       # Point random
+# test(tuple((47.377859, 8.540585)))         # Zurich HB
+# test(tuple((45.758217, 4.831814)))         # Lyon Bellecour
+# test(tuple((48.5848435, 7.7332974)))       # Strasbourg Gare
+# test(tuple((48.2067858, 16.3692340)))      # Vienne
+test(tuple((48.084588, 7.280405)))         # Turckheim 
--- a/backend/src/tests/init.py
+++ b/backend/src/tests/init.py
--- a/backend/src/tests/test_cache.py
+++ b/backend/src/tests/test_cache.py
@@ -1,42 +0,0 @@
-"""Collection of tests to ensure correct handling of invalid input."""
-
-from fastapi.testclient import TestClient
-import pytest
-
-from .test_utils import load_trip_landmarks
-from ..main import app
-
-
-@pytest.fixture(scope="module")
-def client():
-    """Client used to call the app."""
-    return TestClient(app)
-
-
-def test_cache(client, request):    # pylint: disable=redefined-outer-name
-    """
-    Test n°1 : Custom test in Turckheim to ensure small villages are also supported.
-
-    Args:
-        client:
-        request:
-    """
-    duration_minutes = 15
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
-            "nature": {"type": "nature", "score": 5},
-            "shopping": {"type": "shopping", "score": 5},
-            "max_time_minute": duration_minutes,
-            "detour_tolerance_minute": 0},
-            "start": [48.084588, 7.280405]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-    landmarks_cached = load_trip_landmarks(client, result['first_landmark_uuid'], True)
-
-    # checks :
-    assert response.status_code == 200  # check for successful planning
-    assert landmarks_cached == landmarks
--- a/backend/src/tests/test_invalid_input.py
+++ b/backend/src/tests/test_invalid_input.py
@@ -1,62 +0,0 @@
-"""Collection of tests to ensure correct handling of invalid input."""
-
-from fastapi.testclient import TestClient
-import pytest
-
-from ..main import app
-
-
-@pytest.fixture(scope="module")
-def invalid_client():
-    """Client used to call the app."""
-    return TestClient(app)
-
-
-@pytest.mark.parametrize(
-    "start,preferences,status_code",
-    [
-        # Invalid case: no preferences at all.
-        ([48.8566, 2.3522], {}, 422),
-
-        # Invalid cases: incomplete preferences.
-        ([48.084588, 7.280405], {"sightseeing": {"type": "nature", "score": 5}, # no shopping
-                                 "nature": {"type": "nature", "score": 5},
-                                 }, 422),
-        ([48.084588, 7.280405], {"sightseeing": {"type": "nature", "score": 5}, # no nature
-                                 "shopping": {"type": "shopping", "score": 5},
-                                 }, 422),
-        ([48.084588, 7.280405], {"nature": {"type": "nature", "score": 5},      # no sightseeing
-                                 "shopping": {"type": "shopping", "score": 5},
-                                 }, 422),
-
-        # Invalid cases: unexisting coords
-        ([91, 181], {"sightseeing": {"type": "nature", "score": 5},
-                     "nature": {"type": "nature", "score": 5},
-                     "shopping": {"type": "shopping", "score": 5},
-                    }, 422),
-        ([-91, 181], {"sightseeing": {"type": "nature", "score": 5},
-                     "nature": {"type": "nature", "score": 5},
-                     "shopping": {"type": "shopping", "score": 5},
-                    }, 422),
-        ([91, -181], {"sightseeing": {"type": "nature", "score": 5},
-                     "nature": {"type": "nature", "score": 5},
-                     "shopping": {"type": "shopping", "score": 5},
-                    }, 422),
-        ([-91, -181], {"sightseeing": {"type": "nature", "score": 5},
-                     "nature": {"type": "nature", "score": 5},
-                     "shopping": {"type": "shopping", "score": 5},
-                    }, 422),
-    ]
-)
-def test_input(invalid_client, start, preferences, status_code):   # pylint: disable=redefined-outer-name
-    """
-    Test new trip creation with different sets of preferences and locations.
-    """
-    response = invalid_client.post(
-        "/trip/new",
-        json={
-            "preferences": preferences,
-            "start": start
-        }
-    )
-    assert response.status_code == status_code
--- a/backend/src/tests/test_main.py
+++ b/backend/src/tests/test_main.py
@@ -1,128 +0,0 @@
-"""Collection of tests to ensure correct implementation and track progress. """
-
-from fastapi.testclient import TestClient
-import pytest
-
-from .test_utils import landmarks_to_osmid, load_trip_landmarks, log_trip_details
-from ..main import app
-
-@pytest.fixture(scope="module")
-def client():
-    """Client used to call the app."""
-    return TestClient(app)
-
-
-def test_turckheim(client, request):    # pylint: disable=redefined-outer-name
-    """
-    Test n°1 : Custom test in Turckheim to ensure small villages are also supported.
-
-    Args:
-        client:
-        request:
-    """
-    duration_minutes = 15
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
-            "nature": {"type": "nature", "score": 5},
-            "shopping": {"type": "shopping", "score": 5},
-            "max_time_minute": duration_minutes,
-            "detour_tolerance_minute": 0},
-            "start": [48.084588, 7.280405]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-
-    # Add details to report
-    log_trip_details(request, landmarks, result['total_time'], duration_minutes)
-
-    # checks :
-    assert response.status_code == 200  # check for successful planning
-    assert isinstance(landmarks, list)  # check that the return type is a list
-    assert duration_minutes*0.8 < int(result['total_time']) < duration_minutes*1.2
-    assert len(landmarks) > 2           # check that there is something to visit
-
-
-def test_bellecour(client, request) :   # pylint: disable=redefined-outer-name
-    """
-    Test n°2 : Custom test in Lyon centre to ensure proper decision making in crowded area.
-    
-    Args:
-        client:
-        request:
-    """
-    duration_minutes = 30
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 5},
-                            "nature": {"type": "nature", "score": 5},
-                            "shopping": {"type": "shopping", "score": 5},
-                            "max_time_minute": duration_minutes,
-                            "detour_tolerance_minute": 0},
-            "start": [45.7576485, 4.8330241]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-    osm_ids = landmarks_to_osmid(landmarks)
-
-    # Add details to report
-    log_trip_details(request, landmarks, result['total_time'], duration_minutes)
-
-    # checks :
-    assert response.status_code == 200  # check for successful planning
-    assert duration_minutes*0.8 < int(result['total_time']) < duration_minutes*1.2
-    assert 136200148 in osm_ids         # check for Cathédrale St. Jean in trip
-
-
-def test_shopping(client, request) :   # pylint: disable=redefined-outer-name
-    """
-    Test n°3 : Custom test in Lyon centre to ensure shopping clusters are found.
-    
-    Args:
-        client:
-        request:
-    """
-    duration_minutes = 600
-    response = client.post(
-        "/trip/new",
-        json={
-            "preferences": {"sightseeing": {"type": "sightseeing", "score": 0},
-                            "nature": {"type": "nature", "score": 0},
-                            "shopping": {"type": "shopping", "score": 5},
-                            "max_time_minute": duration_minutes,
-                            "detour_tolerance_minute": 0},
-            "start": [45.7576485, 4.8330241]
-            }
-        )
-    result = response.json()
-    landmarks = load_trip_landmarks(client, result['first_landmark_uuid'])
-    # osm_ids = landmarks_to_osmid(landmarks)
-
-    # Add details to report
-    log_trip_details(request, landmarks, result['total_time'], duration_minutes)
-
-    # checks :
-    assert response.status_code == 200  # check for successful planning
-    assert duration_minutes*0.8 < int(result['total_time']) < duration_minutes*1.2
-
-# def test_new_trip_single_prefs(client):
-#     response = client.post(
-#         "/trip/new",
-#         json={
-#             "preferences": {"sightseeing": {"type": "sightseeing", "score": 1},
-#             "nature": {"type": "nature", "score": 1},
-#             "shopping": {"type": "shopping", "score": 1},
-#             "max_time_minute": 360,
-#             "detour_tolerance_minute": 0},
-#             "start": [48.8566, 2.3522]
-#             }
-#         )
-#     assert response.status_code == 200
-
-
-# def test_new_trip_matches_prefs(client):
-#     pass
--- a/backend/src/tests/test_toilets.py
+++ b/backend/src/tests/test_toilets.py
@@ -1,102 +0,0 @@
-"""Collection of tests to ensure correct implementation and track progress. """
-
-from fastapi.testclient import TestClient
-import pytest
-
-from ..structs.landmark import Toilets
-from ..main import app
-
-@pytest.fixture(scope="module")
-def client():
-    """Client used to call the app."""
-    return TestClient(app)
-
-@pytest.mark.parametrize(
-    "location,radius,status_code",
-    [
-        ({}, None, 422),                # Invalid case: no location at all.
-        ([443], None, 422),             # Invalid cases: invalid location.
-        ([443, 433], None, 422),             # Invalid cases: invalid location.
-    ]
-)
-def test_invalid_input(client, location, radius, status_code):    # pylint: disable=redefined-outer-name
-    """
-    Test n°1 : Verify handling of invalid input.
-
-    Args:
-        client:
-        request:
-    """
-    response = client.post(
-        "/toilets/new",
-        params={
-            "location": location,
-            "radius": radius
-        }
-    )
-
-    # checks :
-    assert response.status_code == status_code
-
-
-
-
-@pytest.mark.parametrize(
-    "location,status_code",
-    [
-        ([48.2270, 7.4370], 200), # Orschwiller.
-        ([10.2012, 10.123], 200), # Nigerian desert.
-        ([63.989, -19.677], 200), # Hekla volcano, Iceland
-    ]
-)
-def test_no_toilets(client, location, status_code):    # pylint: disable=redefined-outer-name
-    """
-    Test n°3 : Verify the code finds some toilets in big cities.
-
-    Args:
-        client:
-        request:
-    """
-    response = client.post(
-        "/toilets/new",
-        params={
-            "location": location
-        }
-    )
-    toilets_list = [Toilets.model_validate(toilet) for toilet in response.json()]
-
-    # checks :
-    assert response.status_code == 200  # check for successful planning
-    assert isinstance(toilets_list, list)  # check that the return type is a list
-
-
-
-@pytest.mark.parametrize(
-    "location,status_code",
-    [
-        ([45.7576485, 4.8330241], 200), # Lyon, Bellecour.
-        ([-6.913795,  107.60278], 200), # Bandung, train station
-        ([-22.970140, -43.18181], 200), # Rio de Janeiro, Copacabana
-    ]
-)
-def test_toilets(client, location, status_code):    # pylint: disable=redefined-outer-name
-    """
-    Test n°3 : Verify the code finds some toilets in big cities.
-
-    Args:
-        client:
-        request:
-    """
-    response = client.post(
-        "/toilets/new",
-        params={
-            "location": location,
-            "radius" : 600
-        }
-    )
-    toilets_list = [Toilets.model_validate(toilet) for toilet in response.json()]
-
-    # checks :
-    assert response.status_code == 200  # check for successful planning
-    assert isinstance(toilets_list, list)  # check that the return type is a list
-    assert len(toilets_list) > 0
--- a/backend/src/tests/test_utils.py
+++ b/backend/src/tests/test_utils.py
@@ -1,137 +0,0 @@
-"""Helper methods for testing."""
-import logging
-from fastapi import HTTPException
-from pydantic import ValidationError
-
-from ..structs.landmark import Landmark
-from ..persistence import client as cache_client
-
-
-def landmarks_to_osmid(landmarks: list[Landmark]) -> list[int] :
-    """
-    Convert the list of landmarks into a list containing their osm ids for quick landmark checking.
-    
-    Args :
-        landmarks (list): the list of landmarks
-    
-    Returns :
-        ids (list)      : the list of corresponding OSM ids
-    """
-    ids = []
-    for landmark in landmarks :
-        ids.append(landmark.osm_id)
-
-    return ids
-
-def fetch_landmark(client, landmark_uuid: str):
-    """
-    Fetch landmark data from the API based on the landmark UUID.
-
-    Args:
-        landmark_uuid (str): The UUID of the landmark.
-
-    Returns:
-        dict: Landmark data fetched from the API.
-    """
-    logger = logging.getLogger(__name__)
-    response = client.get(f"/landmark/{landmark_uuid}")
-
-    if response.status_code != 200:
-        raise HTTPException(status_code=500,
-                            detail=f"Failed to fetch landmark with UUID {landmark_uuid}: {response.status_code}")
-
-    try:
-        json_data = response.json()
-        logger.info(f"API Response: {json_data}")
-    except ValueError as e:
-        logger.error(f"Failed to parse response as JSON: {response.text}")
-        raise HTTPException(status_code=500, detail="Invalid response format from API")
-    
-    # Try validating against the Landmark model here to ensure consistency
-    try:
-        landmark = Landmark(**json_data)
-    except ValidationError as ve:
-        logging.error(f"Validation error: {ve}")
-        raise HTTPException(status_code=500, detail="Invalid data format received from API")
-    
-
-    if "detail" in json_data:
-        raise HTTPException(status_code=500, detail=json_data["detail"])
-
-    return Landmark(**json_data)
-
-
-def fetch_landmark_cache(landmark_uuid: str):
-    """
-    Fetch landmark data from the cache based on the landmark UUID.
-
-    Args:
-        landmark_uuid (str): The UUID of the landmark.
-
-    Returns:
-        dict: Landmark data fetched from the cache or raises an HTTP exception.
-    """
-    logger = logging.getLogger(__name__)
-
-    # Try to fetch the landmark data from the cache
-    try:
-        landmark = cache_client.get(f"landmark_{landmark_uuid}")
-        if not landmark :
-            logger.warning(f"Cache miss for landmark UUID: {landmark_uuid}")
-            raise HTTPException(status_code=404, detail=f"Landmark with UUID {landmark_uuid} not found in cache.")
-        
-        # Validate that the fetched data is a dictionary
-        if not isinstance(landmark, Landmark):
-            logger.error(f"Invalid cache data format for landmark UUID: {landmark_uuid}. Expected dict, got {type(landmark).__name__}.")
-            raise HTTPException(status_code=500, detail="Invalid cache data format.")
-
-        return landmark
-    
-    except Exception as exc:
-        logger.error(f"Unexpected error occurred while fetching landmark UUID {landmark_uuid}: {exc}")
-        raise HTTPException(status_code=500, detail="An unexpected error occurred while fetching the landmark from the cache") from exc
-    
-    
-
-
-def load_trip_landmarks(client, first_uuid: str, from_cache=None) -> list[Landmark]:
-    """
-    Load all landmarks for a trip using the response from the API.
-
-    Args:
-        first_uuid (str) : The first UUID of the landmark.
-
-    Returns:
-        landmarks (list) : An list containing all landmarks for the trip.
-    """
-    landmarks = []
-    next_uuid = first_uuid
-
-    while next_uuid is not None:
-        if from_cache :
-            landmark = fetch_landmark_cache(next_uuid)
-        else :
-            landmark = fetch_landmark(client, next_uuid)
-
-        landmarks.append(landmark)
-        next_uuid = landmark.next_uuid  # Prepare for the next iteration
-
-    return landmarks
-
-
-def log_trip_details(request, landmarks: list[Landmark], duration: int, target_duration: int) :
-    """
-    Allows to show the detailed trip in the html test report.
-    
-    Args:
-        request:
-        landmarks (list): the ordered list of visited landmarks 
-        duration (int): the total duration of this trip
-        target_duration(int): the target duration of this trip
-    """
-    trip_string = [f"{landmark.name} ({landmark.attractiveness} | {landmark.duration}) - {landmark.time_to_reach_next}" for landmark in landmarks]
-
-    # Pass additional info to pytest for reporting
-    request.node.trip_details = trip_string
-    request.node.trip_duration = str(duration)              # result['total_time']
-    request.node.target_duration = str(target_duration)
--- a/backend/src/utils/cluster_processing.py
+++ b/backend/src/utils/cluster_processing.py
@@ -1,283 +0,0 @@
-import logging
-from typing import Literal
-
-import numpy as np
-from sklearn.cluster import DBSCAN
-from pydantic import BaseModel
-from OSMPythonTools.overpass import Overpass, overpassQueryBuilder
-from OSMPythonTools.cachingStrategy import CachingStrategy, JSON
-
-from ..structs.landmark import Landmark
-from ..utils.get_time_separation import get_distance
-from ..constants import AMENITY_SELECTORS_PATH, LANDMARK_PARAMETERS_PATH, OPTIMIZER_PARAMETERS_PATH, OSM_CACHE_DIR
-
-
-class ShoppingLocation(BaseModel):
-    """"
-    A classe representing an interesting area for shopping.
-    
-    It can represent either a general area or a specifc route with start and end point.
-    The importance represents the number of shops found in this cluster.
-    
-    Attributes:
-        type :       either a 'street' or 'area' (representing a denser field of shops).
-        importance : size of the cluster (number of points).
-        centroid :   center of the cluster.
-        start :      if the type is a street it goes from here...
-        end :        ...to here
-    """
-    type: Literal['street', 'area']
-    importance: int
-    centroid: tuple
-    # start: Optional[list] = None      # for later use if we want to have streets as well
-    # end: Optional[list] = None
-
-
-class ShoppingManager:
-
-    logger = logging.getLogger(__name__)
-
-    # NOTE: all points are in (lat, lon) format
-    valid: bool             # Ensure the manager is valid (ie there are some clusters to be found) 
-    all_points: list
-    cluster_points: list
-    cluster_labels: list
-    shopping_locations: list[ShoppingLocation]
-
-    def __init__(self, bbox: tuple) -> None:
-        """
-        Upon intialization, generate the point cloud used for cluster detection.
-        The points represent bag/clothes shops and general boutiques.
-
-        Args: 
-            bbox: The bounding box coordinates (around:radius, center_lat, center_lon).
-        """
-
-        # Initialize overpass and cache
-        self.overpass = Overpass()
-        CachingStrategy.use(JSON, cacheDir=OSM_CACHE_DIR)
-
-        # Initialize the points for cluster detection
-        query = overpassQueryBuilder(
-            bbox = bbox,
-            elementType = ['node'],
-            selector = ['"shop"~"^(bag|boutique|clothes)$"'],
-            includeCenter = True,
-            out = 'skel'
-        )
-
-        try:
-            result = self.overpass.query(query)
-        except Exception as e:
-            self.logger.error(f"Error fetching landmarks: {e}")
-
-        if len(result.elements()) == 0 :
-            self.valid = False
-        
-        else :
-            points = []
-            for elem in result.elements() :
-                points.append(tuple((elem.lat(), elem.lon())))
-
-            self.all_points = np.array(points)
-            self.valid = True            
-
-
-    def generate_shopping_landmarks(self) -> list[Landmark]:
-        """
-        Generate shopping landmarks based on clustered locations.
-
-        This method first generates clusters of locations and then  extracts shopping-related 
-        locations from these clusters. It transforms each shopping location into a `Landmark` object.
-
-        Returns:
-            list[Landmark]: A list of `Landmark` objects representing shopping locations.
-                            Returns an empty list if no clusters are found.
-        """
-
-        self.generate_clusters()
-
-        if len(set(self.cluster_labels)) == 0 :
-            return []       # Return empty list if no clusters were found
-
-        # Then generate the shopping locations
-        self.generate_shopping_locations()
-
-        # Transform the locations in landmarks and return the list
-        shopping_landmarks = []
-        for location in self.shopping_locations :
-            shopping_landmarks.append(self.create_landmark(location))
-
-        return shopping_landmarks
-
-
-
-    def generate_clusters(self) :
-        """
-        Generate clusters of points using DBSCAN.
-
-        This method applies the DBSCAN clustering algorithm with different
-        parameters depending on the size of the city (number of points). 
-        It filters out noise points and keeps only the largest clusters.
-
-        The method updates:
-            - `self.cluster_points`: The points belonging to clusters.
-            - `self.cluster_labels`: The labels for the points in clusters.
-        
-        The method also calls `filter_clusters()` to retain only the largest clusters.
-        """
-
-        # Apply DBSCAN to find clusters. Choose different settings for different cities.
-        if len(self.all_points) > 200 :
-            dbscan = DBSCAN(eps=0.00118, min_samples=15, algorithm='kd_tree')  # for large cities
-        else :
-            dbscan = DBSCAN(eps=0.00075, min_samples=10, algorithm='kd_tree')  # for small cities
-
-        labels = dbscan.fit_predict(self.all_points)
-
-        # Separate clustered points and noise points
-        self.cluster_points = self.all_points[labels != -1]
-        self.cluster_labels = labels[labels != -1]
-
-        # filter the clusters to keep only the largest ones
-        self.filter_clusters()
-
-
-    def generate_shopping_locations(self) :
-        """
-        Generate shopping locations based on clustered points.
-
-        This method iterates over the different clusters, calculates the centroid 
-        (as the mean of the points within each cluster), and assigns an importance 
-        based on the size of the cluster.
-
-        The generated shopping locations are stored in `self.shopping_locations` 
-        as a list of `ShoppingLocation` objects, each with:
-            - `type`: Set to 'area'.
-            - `centroid`: The calculated centroid of the cluster.
-            - `importance`: The number of points in the cluster.
-        """
-
-        locations = []
-
-        # loop through the different clusters
-        for label in set(self.cluster_labels):
-
-            # Extract points belonging to the current cluster
-            current_cluster = self.cluster_points[self.cluster_labels == label]
-            
-            # Calculate the centroid as the mean of the points
-            centroid = np.mean(current_cluster, axis=0)
-
-            locations.append(ShoppingLocation(
-                type='area',
-                centroid=centroid,
-                importance = len(current_cluster)
-            ))
-
-        self.shopping_locations = locations
-
-
-    def create_landmark(self, shopping_location: ShoppingLocation) -> Landmark:
-        """
-        Create a Landmark object based on the given shopping location.
-
-        This method queries the Overpass API for nearby neighborhoods and shopping malls 
-        within a 1000m radius around the shopping location centroid. It selects the closest 
-        result and creates a landmark with the associated details such as name, type, and OSM ID.
-
-        Parameters:
-            shopping_location (ShoppingLocation): A ShoppingLocation object containing 
-            the centroid and importance of the area.
-
-        Returns:
-            Landmark: A Landmark object containing details such as the name, type, 
-            location, attractiveness, and OSM details.
-        """
-
-        # Define the bounding box for a given radius around the coordinates
-        lat, lon = shopping_location.centroid
-        bbox = ("around:1000", str(lat), str(lon))
-
-        # Query neighborhoods and shopping malls
-        selectors = ['"place"~"^(suburb|neighborhood|neighbourhood|quarter|city_block)$"', '"shop"="mall"']
-
-        min_dist = float('inf')
-        new_name = 'Shopping Area'
-        new_name_en = None
-        osm_id = 0
-        osm_type = 'node'
-
-        for sel in selectors : 
-            query = overpassQueryBuilder(
-                bbox = bbox,
-                elementType = ['node', 'way', 'relation'],
-                selector = sel,
-                includeCenter = True,
-                out = 'center'
-            )
-
-            try:
-                result = self.overpass.query(query)
-            except Exception as e:
-                self.logger.error(f"Error fetching landmarks: {e}")
-                continue
-
-            for elem in result.elements():
-                location = (elem.centerLat(), elem.centerLon())
-
-                if location[0] is None : 
-                    location = (elem.lat(), elem.lon())
-                    if location[0] is None : 
-                        continue
-
-                d = get_distance(shopping_location.centroid, location)
-                if  d < min_dist :
-                    min_dist = d
-                    new_name = elem.tag('name')
-                    osm_type = elem.type()      # Add type: 'way' or 'relation'
-                    osm_id = elem.id()          # Add OSM id 
-
-                    # Add english name if it exists
-                    try :
-                        new_name_en = elem.tag('name:en')
-                    except:
-                        pass 
-        
-        return Landmark(
-            name=new_name,
-            type='shopping',
-            location=shopping_location.centroid,              # TODO: use the fact the we can also recognize streets.
-            attractiveness=shopping_location.importance,
-            n_tags=0,
-            osm_id=osm_id,
-            osm_type=osm_type,
-            name_en=new_name_en
-        )
-
-
-    def filter_clusters(self):
-        """
-        Filter clusters to retain only the 5 largest clusters by point count.
-
-        This method calculates the size of each cluster and filters out all but the 
-        5 largest clusters. It then updates the cluster points and labels to reflect 
-        only those from the top 5 clusters.
-        """
-        label_counts = np.bincount(self.cluster_labels)
-
-        # Step 3: Get the indices (labels) of the 5 largest clusters
-        top_5_labels = np.argsort(label_counts)[-5:]  # Get the largest 5 clusters
-
-        # Step 4: Filter points to keep only the points in the top 5 clusters
-        filtered_cluster_points = []
-        filtered_cluster_labels = []
-
-        for label in top_5_labels:
-            filtered_cluster_points.append(self.cluster_points[self.cluster_labels == label])
-            filtered_cluster_labels.append(np.full((label_counts[label],), label))  # Replicate the label
-
-        # update the cluster points and labels with the filtered data
-        self.cluster_points = np.vstack(filtered_cluster_points)
-        self.cluster_labels = np.concatenate(filtered_cluster_labels)
-
--- a/backend/src/utils/get_time_separation.py
+++ b/backend/src/utils/get_time_separation.py
@@ -1,9 +1,9 @@
 import yaml
 from math import sin, cos, sqrt, atan2, radians

-from ..constants import OPTIMIZER_PARAMETERS_PATH
+import constants

-with OPTIMIZER_PARAMETERS_PATH.open('r') as f:
+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']
@@ -15,8 +15,8 @@ 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.
+        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.
@@ -48,35 +48,3 @@ 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
--- a/backend/src/utils/landmarks_manager.py
+++ b/backend/src/utils/landmarks_manager.py
@@ -1,13 +1,14 @@
-import math, yaml, logging
+import math
+import yaml
+import logging
+
 from OSMPythonTools.overpass import Overpass, overpassQueryBuilder
 from OSMPythonTools.cachingStrategy import CachingStrategy, JSON

-from ..structs.preferences import Preferences
-from ..structs.landmark import Landmark
+from structs.preferences import Preferences
+from structs.landmark import Landmark
 from .take_most_important import take_most_important
-from .cluster_processing import ShoppingManager
-
-from ..constants import AMENITY_SELECTORS_PATH, LANDMARK_PARAMETERS_PATH, OPTIMIZER_PARAMETERS_PATH, OSM_CACHE_DIR
+import constants

 # silence the overpass logger
 logging.getLogger('OSMPythonTools').setLevel(level=logging.CRITICAL)
@@ -26,10 +27,10 @@ class LandmarkManager:

    def __init__(self) -> None:

-        with AMENITY_SELECTORS_PATH.open('r') as f:
+        with constants.AMENITY_SELECTORS_PATH.open('r') as f:
            self.amenity_selectors = yaml.safe_load(f)

-        with LANDMARK_PARAMETERS_PATH.open('r') as f:
+        with constants.LANDMARK_PARAMETERS_PATH.open('r') as f:
            parameters = yaml.safe_load(f)
            self.max_bbox_side = parameters['city_bbox_side']
            self.radius_close_to = parameters['radius_close_to']
@@ -38,19 +39,18 @@ class LandmarkManager:
            self.overall_coeff = parameters['overall_coeff']
            self.tag_exponent = parameters['tag_exponent']
            self.image_bonus = parameters['image_bonus']
-            self.name_bonus = parameters['name_bonus']
            self.wikipedia_bonus = parameters['wikipedia_bonus']
            self.viewpoint_bonus = parameters['viewpoint_bonus']
            self.pay_bonus = parameters['pay_bonus']
            self.N_important = parameters['N_important']

-        with OPTIMIZER_PARAMETERS_PATH.open('r') as f:
+        with constants.OPTIMIZER_PARAMETERS_PATH.open('r') as f:
            parameters = yaml.safe_load(f)
            self.walking_speed = parameters['average_walking_speed']
            self.detour_factor = parameters['detour_factor']

        self.overpass = Overpass()
-        CachingStrategy.use(JSON, cacheDir=OSM_CACHE_DIR)
+        CachingStrategy.use(JSON, cacheDir=constants.OSM_CACHE_DIR)


    def generate_landmarks_list(self, center_coordinates: tuple[float, float], preferences: Preferences) -> tuple[list[Landmark], list[Landmark]]:
@@ -61,7 +61,7 @@ class LandmarkManager:
        and current location. It scores and corrects these landmarks, removes duplicates, and then selects the most important
        landmarks based on a predefined criterion.

-        Args:
+        Parameters:
        center_coordinates (tuple[float, float]): The latitude and longitude of the center location around which to search.
        preferences (Preferences): The user's preference settings that influence the landmark selection.

@@ -77,9 +77,7 @@ class LandmarkManager:
        # use set to avoid duplicates, this requires some __methods__ to be set in Landmark
        all_landmarks = set()

-        # Create a bbox using the around technique
-        bbox = tuple((f"around:{reachable_bbox_side/2}", str(center_coordinates[0]), str(center_coordinates[1])))
-        
+        bbox = self.create_bbox(center_coordinates, reachable_bbox_side)
        # list for sightseeing
        if preferences.sightseeing.score != 0:
            score_function = lambda score: score * 10 * preferences.sightseeing.score / 5
@@ -96,19 +94,10 @@ class LandmarkManager:
        if preferences.shopping.score != 0:
            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 = 30
+            for landmark in current_landmarks : landmark.duration = 45
            all_landmarks.update(current_landmarks)

-            # special pipeline for shopping malls
-            shopping_manager = ShoppingManager(bbox)
-            if shopping_manager.valid :
-                shopping_clusters = shopping_manager.generate_shopping_landmarks()
-                for landmark in shopping_clusters : landmark.duration = 45
-                all_landmarks.update(shopping_clusters)
-            
-

        landmarks_constrained = take_most_important(all_landmarks, self.N_important)
        self.logger.info(f'Generated {len(all_landmarks)} landmarks around {center_coordinates}, and constrained to {len(landmarks_constrained)} most important ones.')
@@ -160,24 +149,36 @@ 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.
-    #     """
+        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 m (since it's a square bbox)
-    #     half_side_length_m = reachable_bbox_side / 2
+        lat = coordinates[0]
+        lon = coordinates[1]

-    #     return tuple((f"around:{half_side_length_m}", str(coordinates[0]), str(coordinates[1])))
+        # Half the side length in km (since it's a square bbox)
+        half_side_length_km = reachable_bbox_side / 2 / 1000

+        # 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
+
+        # 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]:
@@ -185,7 +186,7 @@ class LandmarkManager:
        Fetches landmarks of a specified type from OpenStreetMap (OSM) within a bounding box centered on given coordinates.

        Args:
-            bbox (tuple[float, float, float, float]): The bounding box coordinates (around:radius, center_lat, center_lon).
+            bbox (tuple[float, float, float, float]): The bounding box coordinates (min_lat, min_lon, max_lat, max_lon).
            amenity_selector (dict): The Overpass API query selector for the desired landmark type. 
            landmarktype (str): The type of the landmark (e.g., 'sightseeing', 'nature', 'shopping').
            score_function (callable): The function to compute the score of the landmark based on its attributes.
@@ -201,33 +202,20 @@ class LandmarkManager:
        """
        return_list = []

-        if landmarktype == 'nature' : query_conditions = []
-        else : query_conditions = ['count_tags()>5']
-
        # caution, when applying a list of selectors, overpass will search for elements that match ALL selectors simultaneously
        # we need to split the selectors into separate queries and merge the results
        for sel in dict_to_selector_list(amenity_selector):
            self.logger.debug(f"Current selector: {sel}")
-
-            # 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 :
-                query_conditions = []
-                element_types.append('node')
-
            query = overpassQueryBuilder(
                bbox = bbox,
-                elementType = element_types,
+                elementType = ['way', 'relation'],
                # selector can in principle be a list already,
                # but it generates the intersection of the queries
                # we want the union
                selector = sel,
-                conditions = query_conditions,        # except for nature....
+                conditions = ['count_tags()>5'],
                includeCenter = True,
-                out = 'center'
+                out = 'body'
                )
            self.logger.debug(f"Query: {query}")

@@ -241,23 +229,18 @@ class LandmarkManager:

                name = elem.tag('name')
                location = (elem.centerLat(), elem.centerLon())
-                osm_type = elem.type()              # Add type: 'way' or 'relation'
-                osm_id = elem.id()                  # Add OSM id 

                # TODO: exclude these from the get go
-                # handle unprecise and no-name locations
+                # skip if unprecise location
                if name is None or location[0] is None:
-                    if osm_type == 'node' and 'viewpoint' in elem.tags().values(): 
-                        name = 'Viewpoint'
-                        name_en = 'Viewpoint'
-                        location = (elem.lat(), elem.lon())
-                    else : 
                    continue

                # skip if part of another building
                if 'building:part' in elem.tags().keys() and elem.tag('building:part') == 'yes':
                    continue
            
+                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
                score = n_tags**self.tag_exponent   # Add score
@@ -265,77 +248,60 @@ class LandmarkManager:
                image_url = None
                name_en = None

-                # Adjust scoring, browse through tag keys
+                # Adjust scoring
                skip = False
-                for tag_key in elem.tags().keys():
-                    if "pay" in tag_key:
+                for tag in elem.tags().keys():
+                    if "pay" in tag:
                        # payment options are misleading and should not count for the scoring.
                        score += self.pay_bonus

-                    if "disused" in tag_key:
+                    if "disused" in tag:
                        # skip disused amenities
                        skip = True
                        break

-                    if "boundary" in tag_key:
-                        # skip "areas" like administrative boundaries and stuff
-                        skip = True
-                        break
-
-                    if "historic" in tag_key and elem.tag('historic') in ['manor', 'optical_telegraph', 'pound', 'shieling', 'wayside_cross']:
-                        # skip useless amenities
-                        skip = True
-                        break
-
-                    if "name" in tag_key :
-                        score += self.name_bonus
-
-                    if "wiki" in tag_key:
+                    if "wiki" in tag:
                        # wikipedia entries count more
                        score += self.wikipedia_bonus

-                    if "image" in tag_key:
+                    if "viewpoint" in tag:
+                        # viewpoints must count more
+                        score += self.viewpoint_bonus
+                        duration = 10
+
+                    if "image" in tag:
                        # images must count more
                        score += self.image_bonus

                    if elem_type != "nature":
-                        if "leisure" in tag_key and elem.tag('leisure') == "park":
+                        if "leisure" in tag and elem.tag('leisure') == "park":
                            elem_type = "nature"

                    if landmarktype != "shopping":
-                        if "shop" in tag_key:
+                        if "shop" in tag:
                            skip = True
                            break

-                        if tag_key == "building" and elem.tag('building') in ['retail', 'supermarket', 'parking']:
+                        if tag == "building" and elem.tag('building') in ['retail', 'supermarket', 'parking']:
                            skip = True
                            break

                    # Extract image, website and english name
-                    if tag_key in ['website', 'contact:website']:
-                        website_url = elem.tag(tag_key)
-                    if tag_key == 'image':
+                    if tag in ['website', 'contact:website']:
+                        website_url = elem.tag(tag)
+                    if tag == 'image':
                        image_url = elem.tag('image')
-                    if tag_key =='name:en':
+                    if tag =='name:en':
                        name_en = elem.tag('name:en')

                if skip:
                    continue

-                # Don't visit random apartments
-                if 'apartments' in elem.tags().values():
-                    continue
-
                score = score_function(score)
                if "place_of_worship" in elem.tags().values():
                    score = score * self.church_coeff
                    duration = 10
                
-                if 'viewpoint' in elem.tags().values() :
-                    # viewpoints must count more
-                    score += self.viewpoint_bonus
-                    duration = 10
-                
                elif "museum" in elem.tags().values() or "aquarium" in elem.tags().values() or "planetarium" in elem.tags().values():
                    duration = 60
                
@@ -364,6 +330,7 @@ class LandmarkManager:
        return return_list


+
 def dict_to_selector_list(d: dict) -> list:
    """
    Convert a dictionary of key-value pairs to a list of Overpass query strings.
--- a/backend/src/utils/optimizer.py
+++ b/backend/src/utils/optimizer.py
@@ -4,9 +4,9 @@ import numpy as np
 from scipy.optimize import linprog
 from collections import defaultdict, deque

-from ..structs.landmark import Landmark
+from structs.landmark import Landmark
 from .get_time_separation import get_time
-from ..constants import OPTIMIZER_PARAMETERS_PATH
+import constants

    

@@ -26,7 +26,7 @@ class Optimizer:
    def __init__(self) :

        # load parameters from file
-        with OPTIMIZER_PARAMETERS_PATH.open('r') as f:
+        with constants.OPTIMIZER_PARAMETERS_PATH.open('r') as f:
            parameters = yaml.safe_load(f)
            self.detour_factor = parameters['detour_factor']
            self.average_walking_speed = parameters['average_walking_speed']
@@ -44,7 +44,7 @@ class Optimizer:
            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):
@@ -79,7 +79,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
@@ -107,7 +107,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
@@ -180,7 +180,7 @@ class Optimizer:
            max_time (int): Maximum time of visit 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 + ...
@@ -212,7 +212,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
@@ -239,7 +239,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)
@@ -270,7 +270,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
@@ -293,7 +293,7 @@ class Optimizer:
            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)
@@ -319,7 +319,7 @@ class Optimizer:
            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)
@@ -346,7 +346,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)
@@ -374,7 +374,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
--- a/backend/src/utils/refiner.py
+++ b/backend/src/utils/refiner.py
@@ -2,11 +2,12 @@ import yaml, logging

 from shapely import buffer, LineString, Point, Polygon, MultiPoint, concave_hull
 from math import pi
+from typing import List

-from ..structs.landmark import Landmark
+from structs.landmark import Landmark
 from . import take_most_important, get_time_separation
 from .optimizer import Optimizer
-from ..constants import OPTIMIZER_PARAMETERS_PATH
+import constants



@@ -24,7 +25,7 @@ class Refiner :
        self.optimizer = optimizer

        # load parameters from file
-        with OPTIMIZER_PARAMETERS_PATH.open('r') as f:
+        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']
@@ -38,10 +39,10 @@ class Refiner :

        Args:
            landmarks (list[Landmark]): the landmark path around which to create the corridor
-            width (float) : width of the corridor in meters.
+            width (float): Width of the corridor in meters.

        Returns:
-            Geometry: a buffered geometry object representing the corridor around the path.
+            Geometry: A buffered geometry object representing the corridor around the path.
        """

        corrected_width = (180*width)/(6371000*pi)
@@ -134,7 +135,7 @@ class Refiner :
    
        return tour
    
-    def integrate_landmarks(self, sub_list: list[Landmark], main_list: list[Landmark]) :
+    def integrate_landmarks(self, sub_list: List[Landmark], main_list: List[Landmark]) :
        """
        Inserts 'sub_list' of Landmarks inside the 'main_list' by leaving the ends untouched.
        
--- a/backend/src/utils/take_most_important.py
+++ b/backend/src/utils/take_most_important.py
@@ -1,9 +1,9 @@
-from ..structs.landmark import Landmark
+from structs.landmark import Landmark

 def take_most_important(landmarks: list[Landmark], n_important) -> list[Landmark]:
    """
    Given a list of landmarks, return the n_important most important landmarks
-    Args:
+    Parameters:
    landmarks: list[Landmark] - list of landmarks
    n_important: int - number of most important landmarks to return
    Returns:
--- a/backend/src/utils/toilets_manager.py
+++ b/backend/src/utils/toilets_manager.py
@@ -1,78 +0,0 @@
-import logging, yaml
-from OSMPythonTools.overpass import Overpass, overpassQueryBuilder
-from OSMPythonTools.cachingStrategy import CachingStrategy, JSON
-
-from ..structs.landmark import Toilets
-from ..constants import LANDMARK_PARAMETERS_PATH, OSM_CACHE_DIR
-
-
-# silence the overpass logger
-logging.getLogger('OSMPythonTools').setLevel(level=logging.CRITICAL)
-
-class ToiletsManager:
-
-    logger = logging.getLogger(__name__)
-
-    location: tuple[float, float]
-    radius: int    # radius in meters
-
-
-    def __init__(self, location: tuple[float, float], radius : int) -> None:
-
-        self.radius = radius
-        self.location = location
-        self.overpass = Overpass()
-        CachingStrategy.use(JSON, cacheDir=OSM_CACHE_DIR)
-
-
-    def generate_toilet_list(self) -> list[Toilets] :
-
-        
-        # Create a bbox using the around technique
-        bbox = tuple((f"around:{self.radius}", str(self.location[0]), str(self.location[1])))
-        toilets_list = []
-
-        query = overpassQueryBuilder(
-                bbox = bbox,
-                elementType = ['node', 'way', 'relation'],
-                # selector can in principle be a list already,
-                # but it generates the intersection of the queries
-                # we want the union
-                selector = ['"amenity"="toilets"'],
-                includeCenter = True,
-                out = 'center'
-                )
-        self.logger.debug(f"Query: {query}")
-
-        try:
-            result = self.overpass.query(query)
-        except Exception as e:
-            self.logger.error(f"Error fetching landmarks: {e}")
-            return None
-
-        for elem in result.elements():
-            location = (elem.centerLat(), elem.centerLon())
-
-            # handle unprecise and no-name locations
-            if location[0] is None:
-                    location = (elem.lat(), elem.lon())
-            else : 
-                continue
-            
-            toilets = Toilets(location=location)
-            
-            if 'wheelchair' in elem.tags().keys() and elem.tag('wheelchair') == 'yes':
-                toilets.wheelchair = True
-
-            if 'changing_table' in elem.tags().keys() and elem.tag('changing_table') == 'yes':
-                toilets.changing_table = True
-
-            if 'fee' in elem.tags().keys() and elem.tag('fee') == 'yes':
-                toilets.fee = True
-
-            if 'opening_hours' in elem.tags().keys() :
-                toilets.opening_hours = elem.tag('opening_hours')
-
-            toilets_list.append(toilets)
-
-        return toilets_list
--- a/backend/test.py
+++ b/backend/test.py
@@ -0,0 +1,111 @@
+import numpy as np
+
+def euclidean_distance(p1, p2):
+    print(p1, p2)
+    return np.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)
+
+
+def maximize_score(places, max_distance, fixed_entry, top_k=3):
+    """
+    Maximizes the total score of visited places while staying below the maximum distance.
+    
+    Parameters:
+    places (list of tuples): Each tuple contains (score, (x, y), location).
+    max_distance (float): The maximum distance that can be traveled.
+    fixed_entry (tuple): The place that needs to be visited independently of its score.
+    top_k (int): Number of top candidates to consider in each iteration.
+    
+    Returns:
+    list of tuples: The visited places.
+    float: The total score of the visited places.
+    """
+    # Initialize total distance and score
+    total_distance = 0
+    total_score = 0
+    visited_places = []
+
+    # Add the fixed entry to the visited list
+    score, (x, y), _ = fixed_entry
+    visited_places.append(fixed_entry)
+    total_score += score
+
+    # Remove the fixed entry from the list of places
+    remaining_places = [place for place in places if place != fixed_entry]
+
+    # Sort remaining places by score-to-distance ratio
+    
+    remaining_places.sort(key=lambda p: p[0] / euclidean_distance((x, y), (p[1][0], p[1][1])), reverse=True)
+
+    # Add places to the visited list if they don't exceed the maximum distance
+    current_location = (x, y)
+    while remaining_places and total_distance < max_distance:
+        # Consider top_k candidates
+        candidates = remaining_places[:top_k]
+        best_candidate = None
+        best_score_increase = -np.inf
+
+        for candidate in candidates:
+            score, (cx, cy), location = candidate
+            distance = euclidean_distance(current_location, (cx, cy))
+            if total_distance + distance <= max_distance:
+                score_increase = score / distance
+                if score_increase > best_score_increase:
+                    best_score_increase = score_increase
+                    best_candidate = candidate
+
+        if best_candidate:
+            visited_places.append(best_candidate)
+            total_distance += euclidean_distance(current_location, best_candidate[1])
+            total_score += best_candidate[0]
+            current_location = best_candidate[1]
+            remaining_places.remove(best_candidate)
+        else:
+            break
+
+    return visited_places, total_score
+
+# Example usage
+places = [
+    (10, (0, 0), 'A'),
+    (8, (4, 2), 'B'),
+    (15, (6, 4), 'C'),
+    (7, (5, 6), 'D'),
+    (12, (1, 8), 'E'),
+    (14, (34, 10), 'F'),
+    (15, (65, 12), 'G'),
+    (12, (3, 14), 'H'),
+    (12, (15, 1), 'I'),
+    (7, (17, 4), 'J'),
+    (12, (3, 3), 'K'),
+    (4, (21, 22), 'L'),
+    (12, (23, 24), 'M'),
+    (4, (25, 26), 'N'),
+    (2, (27, 28), 'O'),
+]
+fixed_entry = (10, (0, 0), 'A')
+max_distance = 50
+
+visited_places, total_score = maximize_score(places, max_distance, fixed_entry)
+print("Visited Places:", visited_places)
+print("Total Score:", total_score)
+
+import matplotlib.pyplot as plt
+
+# Plot the route
+def plot_route(visited_places):
+    x_coords = [place[1][0] for place in visited_places]
+    y_coords = [place[1][1] for place in visited_places]
+    labels = [place[2] for place in visited_places]
+
+    plt.figure(figsize=(10, 6))
+    plt.plot(x_coords, y_coords, marker='o', linestyle='-', color='b')
+    for i, label in enumerate(labels):
+        plt.text(x_coords[i], y_coords[i], label, fontsize=12, ha='right')
+
+    plt.title('Route of Visited Places')
+    plt.xlabel('X Coordinate')
+    plt.ylabel('Y Coordinate')
+    plt.grid(True)
+    plt.savefig('route.png')
+
+plot_route(visited_places)
--- a/frontend/assets/confused.svg
+++ b/frontend/assets/confused.svg
--- a/frontend/lib/main.dart
+++ b/frontend/lib/main.dart
@@ -1,10 +1,12 @@
+import 'package:anyway/utils/get_first_page.dart';
+import 'package:anyway/utils/load_trips.dart';
 import 'package:flutter/material.dart';
 import 'package:anyway/constants.dart';
-import 'package:anyway/layout.dart';

 void main() => runApp(const App());

 final GlobalKey<ScaffoldMessengerState> rootScaffoldMessengerKey = GlobalKey<ScaffoldMessengerState>();
+final SavedTrips savedTrips = SavedTrips();

 class App extends StatelessWidget {
  const App({super.key});
@@ -14,7 +16,7 @@ class App extends StatelessWidget {
  Widget build(BuildContext context) {
    return MaterialApp(
      title: APP_NAME,
-      home: BasePage(mainScreen: "map"),
+      home: getFirstPage(),
      theme: APP_THEME,
      scaffoldMessengerKey: rootScaffoldMessengerKey
    );
--- a/frontend/lib/modules/current_trip_landmarks_list.dart
+++ b/frontend/lib/modules/current_trip_landmarks_list.dart
@@ -5,7 +5,6 @@ import 'package:flutter/material.dart';
 import 'package:anyway/modules/landmark_card.dart';
 import 'package:anyway/structs/landmark.dart';
 import 'package:anyway/structs/trip.dart';
-import 'package:anyway/main.dart';



@@ -25,30 +24,7 @@ List<Widget> landmarksList(Trip trip) {

  for (Landmark landmark in trip.landmarks) {
    children.add(
-      Dismissible(
-        key: ValueKey<int>(landmark.hashCode),
-        child: LandmarkCard(landmark),
-        dismissThresholds: {DismissDirection.endToStart: 0.95, DismissDirection.startToEnd: 0.95},
-        onDismissed: (direction) {
-          log('Removing ${landmark.name}');
-          trip.removeLandmark(landmark);
-
-          rootScaffoldMessengerKey.currentState!.showSnackBar(
-            SnackBar(content: Text("We won't show ${landmark.name} again"))
-          );
-        },
-
-        background: Container(color: Colors.red),
-        secondaryBackground: Container(
-          color: Colors.red,
-          child: Icon(
-            Icons.delete,
-            color: Colors.white,
-          ),
-          padding: EdgeInsets.all(15),
-          alignment: Alignment.centerRight,
-        ),
-      )
+      LandmarkCard(landmark, trip),
    );

    if (landmark.next != null) {
--- a/frontend/lib/modules/current_trip_loading_indicator.dart
+++ b/frontend/lib/modules/current_trip_loading_indicator.dart
@@ -1,9 +1,20 @@
+import 'package:anyway/constants.dart';
 import 'package:flutter/material.dart';
 import 'package:auto_size_text/auto_size_text.dart';

 import 'package:anyway/structs/trip.dart';
 import 'package:anyway/pages/current_trip.dart';

+
+final List<String> statusTexts = [
+  'Parsing your preferences...',
+  'Finding the best places...',
+  'Crunching the numbers...',
+  'Calculating the best route...',
+  'Making sure you have a great time...',
+];
+
+
 class CurrentTripLoadingIndicator extends StatefulWidget {
  final Trip trip;
  const CurrentTripLoadingIndicator({
@@ -15,46 +26,137 @@ class CurrentTripLoadingIndicator extends StatefulWidget {
  State<CurrentTripLoadingIndicator> createState() => _CurrentTripLoadingIndicatorState();
 }

+
 class _CurrentTripLoadingIndicatorState extends State<CurrentTripLoadingIndicator> {
  @override
-  Widget build(BuildContext context) => Center(
-    child: FutureBuilder(
-      future: widget.trip.cityName,
+  Widget build(BuildContext context) => Stack(
+    fit: StackFit.expand,
+    children: [
+      // In the very center of the panel, show the greeter which tells the user that the trip is being generated
+      Center(child: loadingText(widget.trip)),
+      // As a gimmick, and a way to show that the app is still working, show a few loading dots
+      Align(
+        alignment: Alignment.bottomCenter,
+        child: statusText(),
+      )
+    ],
+  );
+}
+
+// automatically cycle through the greeter texts
+class statusText extends StatefulWidget {
+  const statusText({Key? key}) : super(key: key);
+
+  @override
+  _statusTextState createState() => _statusTextState();
+}
+
+class _statusTextState extends State<statusText> {
+  int statusIndex = 0;
+
+  @override
+  void initState() {
+    super.initState();
+    Future.delayed(Duration(seconds: 5), () {
+      setState(() {
+        statusIndex = (statusIndex + 1) % statusTexts.length;
+      });
+    });
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return AutoSizeText(
+      statusTexts[statusIndex],
+      style: Theme.of(context).textTheme.labelSmall,
+    );
+  }
+}
+
+
+
+Widget loadingText(Trip trip) => FutureBuilder(
+  future: trip.cityName,
  builder: (BuildContext context, AsyncSnapshot<String> snapshot) {
    Widget greeter;
-        Widget loadingIndicator = const Padding(
-          padding: EdgeInsets.only(top: 10),
-          child: CircularProgressIndicator()
-        );

    if (snapshot.hasData) {
-          greeter = AutoSizeText(
-            maxLines: 1,
-            'Generating your trip to ${snapshot.data}...',
+      greeter = AnimatedGradientText(
+        text: 'Creating your trip to ${snapshot.data}...',
        style: greeterStyle,
      );
    } else if (snapshot.hasError) {
      // the exact error is shown in the central part of the trip overview. No need to show it here
-          greeter = AutoSizeText(
-            maxLines: 1,
-            'Error while loading trip.',
+      greeter = AnimatedGradientText(
+        text: 'Error while loading trip.',
        style: greeterStyle,
      );
    } else {
-          greeter = AutoSizeText(
-            maxLines: 1,
-            'Generating your trip...',
+      greeter = AnimatedGradientText(
+        text: 'Creating your trip...',
        style: greeterStyle,
      );
    }
-        return Column(
-          mainAxisAlignment: MainAxisAlignment.center,
-          children: [
-            greeter,
-            loadingIndicator,
+    return greeter;
+  }
+);
+
+class AnimatedGradientText extends StatefulWidget {
+  final String text;
+  final TextStyle style;
+
+  const AnimatedGradientText({
+    Key? key,
+    required this.text,
+    required this.style,
+  }) : super(key: key);
+
+  @override
+  _AnimatedGradientTextState createState() => _AnimatedGradientTextState();
+}
+
+class _AnimatedGradientTextState extends State<AnimatedGradientText> with SingleTickerProviderStateMixin {
+  late AnimationController _controller;
+
+  @override
+  void initState() {
+    super.initState();
+    _controller = AnimationController(
+      duration: const Duration(seconds: 1),
+      vsync: this,
+    )..repeat();
+  }
+
+  @override
+  void dispose() {
+    _controller.dispose();
+    super.dispose();
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return AnimatedBuilder(
+      animation: _controller,
+      builder: (context, child) {
+        return ShaderMask(
+          shaderCallback: (bounds) {
+            return LinearGradient(
+              colors: [GRADIENT_START, GRADIENT_END, GRADIENT_START],
+              stops: [
+                _controller.value - 1.0,
+                _controller.value,
+                _controller.value + 1.0,
              ],
+              tileMode: TileMode.mirror,
+            ).createShader(bounds);
+          },
+          child: Text(
+            widget.text,
+            style: widget.style,
+          ),
+        );
+      },
    );
  }
-    )
-  );
 }
+
--- a/frontend/lib/modules/current_trip_panel.dart
+++ b/frontend/lib/modules/current_trip_panel.dart
@@ -36,7 +36,7 @@ class _CurrentTripPanelState extends State<CurrentTripPanel> {
              child: SizedBox(
                // reuse the exact same height as the panel has when collapsed
                // this way the greeter will be centered when the panel is collapsed
-                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT - 20,
+                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT,
                child: CurrentTripErrorMessage(trip: widget.trip)
              ),
            );
@@ -46,19 +46,20 @@ class _CurrentTripPanelState extends State<CurrentTripPanel> {
              child: SizedBox(
                // reuse the exact same height as the panel has when collapsed
                // this way the greeter will be centered when the panel is collapsed
-                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT - 20,
+                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT,
                child: CurrentTripLoadingIndicator(trip: widget.trip),
              ),
            );
        } else {
          return ListView(
            controller: widget.controller,
-            padding: const EdgeInsets.only(bottom: 30),
+            padding: const EdgeInsets.only(top: 10, left: 10, right: 10, bottom: 30),
            children: [
              SizedBox(
                // reuse the exact same height as the panel has when collapsed
                // this way the greeter will be centered when the panel is collapsed
-                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT - 20,
+                // note that we need to account for the padding above
+                height: MediaQuery.of(context).size.height * TRIP_PANEL_MIN_HEIGHT - 10,
                child: CurrentTripGreeter(trip: widget.trip),
              ),

@@ -72,7 +73,7 @@ class _CurrentTripPanelState extends State<CurrentTripPanel> {

              const Padding(padding: EdgeInsets.only(top: 10)),

-              Center(child: saveButton(widget.trip)),
+              Center(child: saveButton(trip: widget.trip)),
            ],
          );
        }
--- a/frontend/lib/modules/current_trip_save_button.dart
+++ b/frontend/lib/modules/current_trip_save_button.dart
@@ -3,12 +3,24 @@ import 'package:anyway/main.dart';
 import 'package:anyway/structs/trip.dart';
 import 'package:auto_size_text/auto_size_text.dart';
 import 'package:flutter/material.dart';
-import 'package:shared_preferences/shared_preferences.dart';

-Widget saveButton(Trip trip) => ElevatedButton(
+
+class saveButton extends StatefulWidget {
+  Trip trip;
+  saveButton({super.key, required this.trip});
+
+  @override
+  State<saveButton> createState() => _saveButtonState();
+}
+
+class _saveButtonState extends State<saveButton> {
+  @override
+  Widget build(BuildContext context) {
+    return ElevatedButton(
      onPressed: () async {
-    SharedPreferences prefs = await SharedPreferences.getInstance();
-    trip.toPrefs(prefs);
+        savedTrips.addTrip(widget.trip);
+        // SharedPreferences prefs = await SharedPreferences.getInstance();
+        // setState(() => widget.trip.toPrefs(prefs));
        rootScaffoldMessengerKey.currentState!.showSnackBar(
          SnackBar(
            content: Text('Trip saved'),
@@ -38,4 +50,6 @@ Widget saveButton(Trip trip) => ElevatedButton(
        ),
      )
    );
+  }
+}

--- a/frontend/lib/modules/help_dialog.dart
+++ b/frontend/lib/modules/help_dialog.dart
@@ -0,0 +1,25 @@
+
+import 'package:flutter/material.dart';
+
+Future<void> helpDialog(BuildContext context, String title, String content) {
+  return showDialog<void>(
+    context: context,
+    builder: (BuildContext context) {
+      return AlertDialog(
+        title: Text(title),
+        content: Text(content),
+        actions: <Widget>[
+          TextButton(
+            style: TextButton.styleFrom(
+              textStyle: Theme.of(context).textTheme.labelLarge,
+            ),
+            child: const Text('Got it!'),
+            onPressed: () {
+              Navigator.of(context).pop();
+            },
+          ),
+        ],
+      );
+    },
+  );
+}
--- a/frontend/lib/modules/landmark_card.dart
+++ b/frontend/lib/modules/landmark_card.dart
@@ -1,3 +1,5 @@
+import 'package:anyway/main.dart';
+import 'package:anyway/structs/trip.dart';
 import 'package:flutter/material.dart';
 import 'package:cached_network_image/cached_network_image.dart';
 import 'package:url_launcher/url_launcher.dart';
@@ -6,8 +8,12 @@ import 'package:anyway/structs/landmark.dart';

 class LandmarkCard extends StatefulWidget {
  final Landmark landmark;
+  final Trip parentTrip;
  
-  LandmarkCard(this.landmark);
+  LandmarkCard(
+    this.landmark,
+    this.parentTrip,
+    );
  
  @override
  _LandmarkCardState createState() => _LandmarkCardState();
@@ -17,34 +23,54 @@ class LandmarkCard extends StatefulWidget {
 class _LandmarkCardState extends State<LandmarkCard> {
  @override
  Widget build(BuildContext context) {
-    ThemeData theme = Theme.of(context);
+    if (widget.landmark.type == typeStart || widget.landmark.type == typeFinish) {
+      return TextButton.icon(
+        onPressed: () {},
+        icon: widget.landmark.type.icon,
+        label: Text(widget.landmark.name),
+      );
+
+    }
+    // else:
    return Container(
-      height: 160,
      child: Card(
        shape: RoundedRectangleBorder(
          borderRadius: BorderRadius.circular(15.0),
        ),
        elevation: 5,
        clipBehavior: Clip.antiAliasWithSaveLayer,
-        child: Row(
+        // if the image is available, display it on the left side of the card, otherwise only display the text
+        child: widget.landmark.imageURL != null ? splitLayout() : textLayout(),
+      ),
+    );
+  }
+
+  Widget splitLayout() {
+    // If an image is available, display it on the left side of the card
+    return Row(
      crossAxisAlignment: CrossAxisAlignment.start,
      children: [
-            Container( // the image on the left
-              // inherit the height of the parent container
-              height: double.infinity,
-              // force a fixed width
+        Container(
+          // the image on the left
          width: 160,
+          height: 160,
+
          child: CachedNetworkImage(
            imageUrl: widget.landmark.imageURL ?? '',
            placeholder: (context, url) => Center(child: CircularProgressIndicator()),
            errorWidget: (context, error, stackTrace) => Icon(Icons.question_mark_outlined),
-                // TODO: make this a switch statement to load a placeholder if null
-                // cover the whole container meaning the image will be cropped
            fit: BoxFit.cover,
          ),
        ),
        Flexible(
-              child: Padding(
+          child: textLayout(),
+        ),
+      ],
+    );
+  }
+
+  Widget textLayout() {
+    return Padding(
      padding: EdgeInsets.all(10),
      child: Column(
        children: [
@@ -76,7 +102,10 @@ class _LandmarkCardState extends State<LandmarkCard> {
                )
              ],
            ),
-                    SingleChildScrollView(
+          Padding(padding: EdgeInsets.only(top: 10)),
+          Align(
+            alignment: Alignment.centerLeft,
+            child: SingleChildScrollView(
              // allows the buttons to be scrolled
              scrollDirection: Axis.horizontal,
              child: Wrap(
@@ -103,25 +132,41 @@ class _LandmarkCardState extends State<LandmarkCard> {
                      icon: Icon(Icons.link),
                      label: Text('Website'),
                    ),
-                          if (widget.landmark.wikipediaURL != null)
-                            TextButton.icon(
-                              onPressed: () async {
-                                // open a browser with the wikipedia link
-                                await launchUrl(Uri.parse(widget.landmark.wikipediaURL!));
+                  PopupMenuButton(
+                    icon: Icon(Icons.settings),
+                    style: TextButtonTheme.of(context).style,
+                    itemBuilder: (context) => [
+                      PopupMenuItem(
+                        child: ListTile(
+                          leading: Icon(Icons.delete),
+                          title: Text('Delete'),
+                          onTap: () async {
+                            widget.parentTrip.removeLandmark(widget.landmark);
+                            rootScaffoldMessengerKey.currentState!.showSnackBar(
+                              SnackBar(content: Text("We won't show ${widget.landmark.name} again"))
+                            );
                          },
-                              icon: Icon(Icons.book),
-                            label: Text('Wikipedia'),
+                        ),
+                      ),
+                      PopupMenuItem(
+                        child: ListTile(
+                          leading: Icon(Icons.star),
+                          title: Text('Favorite'),
+                          onTap: () async {
+                            // delete the landmark
+                            // await deleteLandmark(widget.landmark);
+                          },
+                        ),
                      ),
                    ],
-                      ),
-                    ),
+                  )
+                    
                ],
              ),
            ),
          ),
        ],
      ),
-      ),
    );
  }
 }
--- a/frontend/lib/modules/new_trip_button.dart
+++ b/frontend/lib/modules/new_trip_button.dart
@@ -1,5 +1,5 @@
-import 'package:anyway/layout.dart';
 import 'package:anyway/main.dart';
+import 'package:anyway/pages/current_trip.dart';
 import 'package:anyway/structs/preferences.dart';
 import 'package:anyway/structs/trip.dart';
 import 'package:anyway/utils/fetch_trip.dart';
@@ -57,7 +57,7 @@ class _NewTripButtonState extends State<NewTripButton> {
      fetchTrip(trip, widget.preferences);
      Navigator.of(context).push(
        MaterialPageRoute(
-          builder: (context) => BasePage(mainScreen: "map", trip: trip)
+          builder: (context) => TripPage(trip: trip)
        )
      );
    }
--- a/frontend/lib/modules/new_trip_location_search.dart
+++ b/frontend/lib/modules/new_trip_location_search.dart
@@ -9,6 +9,15 @@ import 'package:flutter/material.dart';
 import 'package:geolocator/geolocator.dart';
 import 'package:shared_preferences/shared_preferences.dart';

+const Map<String, List> debugLocations = {
+  'paris': [48.8575, 2.3514],
+  'london': [51.5074, -0.1278],
+  'new york': [40.7128, -74.0060],
+  'tokyo': [35.6895, 139.6917],
+};
+
+
+
 class NewTripLocationSearch extends StatefulWidget {
  Future<SharedPreferences> prefs = SharedPreferences.getInstance();
  Trip trip;
@@ -27,26 +36,35 @@ class _NewTripLocationSearchState extends State<NewTripLocationSearch> {

  setTripLocation (String query) async {
    List<Location> locations = [];
+    Location startLocation;
    log('Searching for: $query');
-    
-    try{
-      locations = await locationFromAddress(query);
-    } catch (e) {
-      log('No results found for: $query : $e');
+    if (GeocodingPlatform.instance != null) {
+      locations.addAll(await locationFromAddress(query));
    }

    if (locations.isNotEmpty) {
-      Location location = locations.first;
+      startLocation = locations.first;
+    } else {
+      log('No results found for: $query. Is geocoding available?');
+      log('Setting Fallback location');
+      List coordinates = debugLocations[query.toLowerCase()] ?? [48.8575, 2.3514];
+      startLocation = Location(
+        latitude: coordinates[0],
+        longitude: coordinates[1],
+        timestamp: DateTime.now(),
+      );
+    }
+
    widget.trip.landmarks.clear();
    widget.trip.addLandmark(
      Landmark(
        uuid: 'pending',
        name: query,
-          location: [location.latitude, location.longitude],
+        location: [startLocation.latitude, startLocation.longitude],
        type: typeStart
      )
    );
-    }
+
  }

  late Widget locationSearchBar = SearchBar(
--- a/frontend/lib/modules/new_trip_map.dart
+++ b/frontend/lib/modules/new_trip_map.dart
@@ -26,7 +26,7 @@ class _NewTripMapState extends State<NewTripMap> {
    target: LatLng(48.8566, 2.3522),
    zoom: 11.0,
  );
-  late GoogleMapController _mapController;
+  GoogleMapController? _mapController;
  final Set<Marker> _markers = <Marker>{};

  _onLongPress(LatLng location) {
@@ -56,11 +56,15 @@ class _NewTripMapState extends State<NewTripMap> {
          ),
        )
      );
-      _mapController.moveCamera(
+      // check if the controller is ready
+
+      if (_mapController != null) {
+        _mapController!.animateCamera(
          CameraUpdate.newLatLng(
            LatLng(landmark.location[0], landmark.location[1])
          )
        );
+      }
      setState(() {});
    }
  }
--- a/frontend/lib/modules/onboarding_card.dart
+++ b/frontend/lib/modules/onboarding_card.dart
@@ -2,13 +2,11 @@ import 'package:flutter/material.dart';
 import 'package:flutter_svg/flutter_svg.dart';

 class OnboardingCard extends StatelessWidget {
-  int index;
-  String title;
-  String description;
-  String imagePath;
+  final String title;
+  final String description;
+  final String imagePath;

-  OnboardingCard({
-    required this.index,
+  const OnboardingCard({
    required this.title,
    required this.description,
    required this.imagePath,
@@ -16,13 +14,8 @@ class OnboardingCard extends StatelessWidget {

  @override
  Widget build(BuildContext context) {
-    Color baseColor = Theme.of(context).colorScheme.secondary;
-    // have a different color for each card, incrementing the hue
-    Color currentColor = baseColor.withAlpha(baseColor.alpha - index * 30);
-    return Container(
-      color: currentColor,
-      alignment: Alignment.center,
-      child: Padding(
+    
+    return Padding(
      padding: EdgeInsets.all(20),
      child: Column(
        mainAxisAlignment: MainAxisAlignment.center,
@@ -50,7 +43,6 @@ class OnboardingCard extends StatelessWidget {

        ]
      ),
-      )
    );
  }
 }
--- a/frontend/lib/modules/trips_saved_list.dart
+++ b/frontend/lib/modules/trips_saved_list.dart
@@ -1,11 +1,12 @@
+import 'package:anyway/pages/current_trip.dart';
+import 'package:anyway/utils/load_trips.dart';
 import 'package:flutter/material.dart';

-import 'package:anyway/layout.dart';
 import 'package:anyway/structs/trip.dart';


 class TripsOverview extends StatefulWidget {
-  final Future<List<Trip>> trips;
+  final SavedTrips trips;
  const TripsOverview({
    super.key,
    required this.trips,
@@ -16,12 +17,11 @@ class TripsOverview extends StatefulWidget {
 }

 class _TripsOverviewState extends State<TripsOverview> {
-
-  Widget listBuild (BuildContext context, AsyncSnapshot<List<Trip>> snapshot) {
+  Widget listBuild (BuildContext context, SavedTrips trips) {
    List<Widget> children;
-    if (snapshot.hasData) {
-      children = List<Widget>.generate(snapshot.data!.length, (index) {
-        Trip trip = snapshot.data![index];
+    List<Trip> items = trips.trips;
+    children = List<Widget>.generate(items.length, (index) {
+      Trip trip = items[index];
      return ListTile(
        title: FutureBuilder(
          future: trip.cityName,
@@ -39,27 +39,12 @@ class _TripsOverviewState extends State<TripsOverview> {
        onTap: () {
          Navigator.of(context).push(
            MaterialPageRoute(
-                builder: (context) => BasePage(mainScreen: "map", trip: trip)
+              builder: (context) => TripPage(trip: trip)
            )
          );
        },
      );
    });
-    } else if (snapshot.hasError) {
-      children = [
-        const Icon(
-          Icons.error_outline,
-          color: Colors.red,
-          size: 60,
-        ),
-        Padding(
-          padding: const EdgeInsets.only(top: 16),
-          child: Text('Error: ${snapshot.error}'),
-        ),
-      ];
-    } else {
-      children = [Center(child: CircularProgressIndicator())];
-    }

    return ListView(
      children: children,
@@ -69,9 +54,11 @@ class _TripsOverviewState extends State<TripsOverview> {

  @override
  Widget build(BuildContext context) {
-    return FutureBuilder(
-      future: widget.trips,
-      builder: listBuild,
+    return ListenableBuilder(
+      listenable: widget.trips,
+      builder: (BuildContext context, Widget? child) {
+        return listBuild(context, widget.trips);
+      }
    );
  }
 }
--- a/frontend/lib/pages/base_page.dart
+++ b/frontend/lib/pages/base_page.dart
@@ -1,3 +1,6 @@
+import 'package:anyway/main.dart';
+import 'package:anyway/modules/help_dialog.dart';
+import 'package:anyway/pages/current_trip.dart';
 import 'package:anyway/pages/settings.dart';
 import 'package:flutter/material.dart';

@@ -8,22 +11,24 @@ import 'package:anyway/modules/trips_saved_list.dart';
 import 'package:anyway/utils/load_trips.dart';

 import 'package:anyway/pages/new_trip_location.dart';
-import 'package:anyway/pages/current_trip.dart';
 import 'package:anyway/pages/onboarding.dart';




-// BasePage is the scaffold that holds all other pages
-// A side drawer is used to switch between pages
+// BasePage is the scaffold that holds a child page and a side drawer
+// The side drawer is the main way to switch between pages
+
 class BasePage extends StatefulWidget {
-  final String mainScreen;
-  final Trip? trip;
+  final Widget mainScreen;
+  final Widget title;
+  final List<String> helpTexts;

  const BasePage({
    super.key,
    required this.mainScreen,
-    this.trip,
+    this.title = const Text(APP_NAME),
+    this.helpTexts = const [],
  });

  @override
@@ -34,53 +39,25 @@ class _BasePageState extends State<BasePage> {

  @override
  Widget build(BuildContext context) {
-    Widget currentView = const Text("loading...");
-    Future<List<Trip>> trips = loadTrips();
+    savedTrips.loadTrips();


-    if (widget.mainScreen == "map") {
-      if (widget.trip != null) {
-        currentView = TripPage(trip: widget.trip!);
-      } else {
-        currentView = FutureBuilder(
-          future: trips,
-          builder: (context, snapshot) {
-            if (snapshot.hasData) {
-              List<Trip> availableTrips = snapshot.data!;
-              if (availableTrips.isNotEmpty) {
-                return TripPage(trip: availableTrips[0]);
-              } else {
    return Scaffold(
-                  body: Center(
-                    child: Text("Wow, so empty!"),
-                  ),
-                  floatingActionButton: FloatingActionButton.extended(
+      appBar: AppBar(
+        title: widget.title,
+        actions: [
+          IconButton(
+            icon: const Icon(Icons.help),
+            tooltip: 'Help',
            onPressed: () {
-                      Navigator.of(context).push(
-                        MaterialPageRoute(
-                          builder: (context) => const NewTripPage()
-                        )
-                      );
-                    },
-                    label: Text("Plan a trip"),
+              if (widget.helpTexts.isNotEmpty) {
+                helpDialog(context, widget.helpTexts[0], widget.helpTexts[1]);
+              }
+            }
          ),
-                );
-              }
-            } else {
-              return const Text("loading...");
-            }
-          },
-        );
-      }
-    } else if (widget.mainScreen == "tutorial") {
-      currentView = OnboardingPage();
-    } else if (widget.mainScreen == "settings") {
-      currentView = SettingsPage();
-    }
-
-    return Scaffold(
-      appBar: AppBar(title: Text(APP_NAME)),
-      body: Center(child: currentView),
+        ],
+      ),
+      body: Center(child: widget.mainScreen),
      drawer: Drawer(
        child: Column(
          children: [
@@ -104,7 +81,8 @@ class _BasePageState extends State<BasePage> {
            ListTile(
              title: const Text('Your Trips'),
              leading: const Icon(Icons.map),
-              selected: widget.mainScreen == "map",
+              // TODO: this is not working!
+              selected: widget.mainScreen is TripPage,
              onTap: () {},
              trailing: ElevatedButton(
                onPressed: () {
@@ -122,11 +100,11 @@ class _BasePageState extends State<BasePage> {
            // through the options in the drawer if there isn't enough vertical
            // space to fit everything.
            Expanded(
-              child: TripsOverview(trips: trips),
+              child: TripsOverview(trips: savedTrips),
            ),
            ElevatedButton(
              onPressed: () async {
-                removeAllTripsFromPrefs();
+                savedTrips.clearTrips();
              },
              child: const Text('Clear trips'),
            ),
@@ -134,11 +112,12 @@ class _BasePageState extends State<BasePage> {
            ListTile(
              title: const Text('How to use'),
              leading: Icon(Icons.help),
-              selected: widget.mainScreen == "tutorial",
+              // TODO: this is not working!
+              selected: widget.mainScreen is OnboardingPage,
              onTap: () {
                Navigator.of(context).push(
                  MaterialPageRoute(
-                    builder: (context) => BasePage(mainScreen: "tutorial")
+                    builder: (context) => OnboardingPage()
                  )
                );
              },
@@ -148,11 +127,12 @@ class _BasePageState extends State<BasePage> {
            ListTile(
              title: const Text('Settings'),
              leading: const Icon(Icons.settings),
-              selected: widget.mainScreen == "settings",
+              // TODO: this is not working!
+              selected: widget.mainScreen is SettingsPage,
              onTap: () {
                Navigator.of(context).push(
                  MaterialPageRoute(
-                    builder: (context) => BasePage(mainScreen: "settings")
+                    builder: (context) => SettingsPage()
                  )
                );
              },
--- a/frontend/lib/pages/current_trip.dart
+++ b/frontend/lib/pages/current_trip.dart
@@ -1,4 +1,5 @@
 import 'package:anyway/constants.dart';
+import 'package:anyway/pages/base_page.dart';
 import 'package:flutter/material.dart';
 import 'package:sliding_up_panel/sliding_up_panel.dart';

@@ -10,7 +11,7 @@ final Shader textGradient = APP_GRADIENT.createShader(Rect.fromLTWH(0.0, 0.0, 20
 TextStyle greeterStyle = TextStyle(
  foreground: Paint()..shader = textGradient,
  fontWeight: FontWeight.bold,
-  fontSize: 26
+  fontSize: 25
 );


@@ -31,7 +32,8 @@ class _TripPageState extends State<TripPage> {

  @override
  Widget build(BuildContext context) {
-    return SlidingUpPanel(
+    return BasePage(
+      mainScreen: SlidingUpPanel(
        // use panelBuilder instead of panel so that we can reuse the scrollcontroller for the listview
        panelBuilder: (scrollcontroller) => CurrentTripPanel(controller: scrollcontroller, trip: widget.trip),
        // using collapsed and panelBuilder seems to show both at the same time, so we include the greeter in the panelBuilder
@@ -41,7 +43,7 @@ class _TripPageState extends State<TripPage> {
        maxHeight: MediaQuery.of(context).size.height * TRIP_PANEL_MAX_HEIGHT,
        // padding in this context is annoying: it offsets the notion of vertical alignment.
        // children that want to be centered vertically need to have their size adjusted by 2x the padding
-        padding: const EdgeInsets.all(10.0),
+        // padding: const EdgeInsets.all(10.0),
        // Panel snapping should not be disabled because it significantly improves the user experience
        // panelSnapping: false
        borderRadius: const BorderRadius.only(topLeft: Radius.circular(25), topRight: Radius.circular(25)),
@@ -52,6 +54,13 @@ class _TripPageState extends State<TripPage> {
            color: Colors.black,
          )
        ],
+      ),
+      title: FutureBuilder(
+        future: widget.trip.cityName,
+        builder: (context, snapshot) => Text(
+          'Your trip to ${snapshot.hasData ? snapshot.data! : "..."}',
+        )
+      ),
    );
  }
 }
--- a/frontend/lib/pages/new_trip_location.dart
+++ b/frontend/lib/pages/new_trip_location.dart
@@ -1,5 +1,5 @@
-import 'package:anyway/modules/new_trip_button.dart';
 import 'package:anyway/modules/new_trip_options_button.dart';
+import 'package:anyway/pages/base_page.dart';
 import 'package:flutter/material.dart';

 import "package:anyway/structs/trip.dart";
@@ -19,13 +19,12 @@ class _NewTripPageState extends State<NewTripPage> {
  final TextEditingController lonController = TextEditingController();
  Trip trip = Trip();

+
  @override
  Widget build(BuildContext context) {
    // floating search bar and map as a background
-    return Scaffold(
-      appBar: AppBar(
-        title: const Text('New Trip'),
-      ),
+    return BasePage(
+      mainScreen: Scaffold(
        body: Stack(
          children: [
            NewTripMap(trip),
@@ -36,6 +35,12 @@ class _NewTripPageState extends State<NewTripPage> {
          ],
        ),
        floatingActionButton: NewTripOptionsButton(trip: trip),
+      ),
+      title: Text("New Trip"),
+      helpTexts: [
+        "Setting the start location",
+        "To set the starting point, type a city name in the search bar. You can also navigate the map like you're used to and long press anywhere to set a starting point."
+      ],
    );
  }
 }
--- a/frontend/lib/pages/new_trip_preferences.dart
+++ b/frontend/lib/pages/new_trip_preferences.dart
@@ -1,4 +1,5 @@
 import 'package:anyway/modules/new_trip_button.dart';
+import 'package:anyway/pages/base_page.dart';
 import 'package:anyway/structs/preferences.dart';
 import 'package:anyway/structs/trip.dart';
 import 'package:flutter/cupertino.dart';
@@ -19,7 +20,8 @@ class _NewTripPreferencesPageState extends State<NewTripPreferencesPage> {

  @override
  Widget build(BuildContext context) {
-    return Scaffold(
+    return BasePage(
+      mainScreen: Scaffold(
        body: ListView(
          children: [
            // Center(
@@ -28,16 +30,16 @@ class _NewTripPreferencesPageState extends State<NewTripPreferencesPage> {
            //     child: Icon(Icons.person, size: 100),
            //   )
            // ),
-          Padding(padding: EdgeInsets.only(top: 30)),
-          Center(
-            child: FutureBuilder(
-              future: widget.trip.cityName,
-              builder: (context, snapshot) => Text(
-                'Your trip to ${snapshot.hasData ? snapshot.data! : "..."}',
-                style: TextStyle(fontSize: 24, fontWeight: FontWeight.bold)
-              )
-            )
-          ),
+            // Padding(padding: EdgeInsets.only(top: 30)),
+            // Center(
+            //   child: FutureBuilder(
+            //     future: widget.trip.cityName,
+            //     builder: (context, snapshot) => Text(
+            //       'Your trip to ${snapshot.hasData ? snapshot.data! : "..."}',
+            //       style: TextStyle(fontSize: 24, fontWeight: FontWeight.bold)
+            //     )
+            //   )
+            // ),

            Center(
              child: Padding(
@@ -54,6 +56,18 @@ class _NewTripPreferencesPageState extends State<NewTripPreferencesPage> {
          ]
        ),
        floatingActionButton: NewTripButton(trip: widget.trip, preferences: preferences),
+      ),
+      
+      title: FutureBuilder(
+        future: widget.trip.cityName,
+        builder: (context, snapshot) => Text(
+          'Your trip to ${snapshot.hasData ? snapshot.data! : "..."}',
+        )
+      ),
+      helpTexts: [
+        'Trip preferences',
+        'Set your preferences for this trip. These will be used to generate a custom itinerary.'
+      ],
    );
  }

--- a/frontend/lib/pages/onboarding.dart
+++ b/frontend/lib/pages/onboarding.dart
@@ -1,7 +1,33 @@
+import 'dart:ui';
+
+import 'package:anyway/constants.dart';
 import 'package:anyway/modules/onboarding_card.dart';
 import 'package:anyway/pages/new_trip_location.dart';
 import 'package:flutter/material.dart';

+const List<Widget> onboardingCards = [
+  OnboardingCard(
+    title: "Welcome to anyway!",
+    description: "Anyway helps you plan a city trip that suits your wishes.",
+    imagePath: "assets/city.svg"
+  ),
+  OnboardingCard(
+    title: "Find your way",
+    description: "Bored by churches? No problem! Hate shopping? No worries! Instead of suggesting the generic trips that bore you, anyway will try to give you recommendations that really suit you.",
+    imagePath: "assets/plan.svg"
+  ),
+  OnboardingCard(
+    title: "Change your mind",
+    description: "Feet get sore, the weather changes. Anyway understands that! Move or remove destinations, visit hidden gems along your journey, do your own thing. Anyway adapts to your spontaneous decisions.",
+    imagePath: "assets/cat.svg"
+  ),
+  OnboardingCard(
+    title: "Feeling lost?",
+    description: "Whenever you are confused or need help with the app, look out for the question mark in the top right corner. Help is just a tap away!",
+    imagePath: "assets/confused.svg"
+  ),
+];
+
 class OnboardingPage extends StatefulWidget {
  const OnboardingPage({super.key});

@@ -10,27 +36,58 @@ class OnboardingPage extends StatefulWidget {
 }

 class _OnboardingPageState extends State<OnboardingPage> {
+  final PageController _controller = PageController();
+
  @override
  Widget build(BuildContext context) {
-    final PageController _controller = PageController();
    return Scaffold(
      body: Stack(
        children: [
-          PageView(
-            // horizontally scrollable list of pages
-            controller: _controller,
-            
+          AnimatedBuilder(
+            animation: _controller,
+            builder: (context, child) {
+              return Stack(
                children: [
-              OnboardingCard(index: 1, title: "Welcome to anyway!", description: "Anyway helps you plan a city trip that suits your wishes.", imagePath: "assets/city.svg"),
-              OnboardingCard(index: 2, title: "Find your way", description: "Bored by churches? No problem! Hate shopping? No worries! More than showing you the typical 'must-sees' of a city, anyway will try to give you recommendations that really suit you.", imagePath: "assets/plan.svg"),
-              OnboardingCard(index: 3, title: "Change your mind", description: "Life happens when you're busy making plans. Anyway understands that! Move or remove destinations, visit hidden gems along your journey, do your own thing. Anyway adapts to your spontaneous decisions.", imagePath: "assets/cat.svg"),
+                  Container(
+                    decoration: BoxDecoration(
+                      gradient: LinearGradient(
+                        begin: Alignment.topLeft,
+                        end: Alignment.bottomRight,
+                        colors: APP_GRADIENT.colors,
+                        stops: [
+                          (_controller.hasClients ? _controller.page ?? _controller.initialPage : _controller.initialPage) / onboardingCards.length,
+                          (_controller.hasClients ? _controller.page ?? _controller.initialPage + 1 : _controller.initialPage + 1) / onboardingCards.length,
                        ],
                      ),
+                    ),
+                  ),
+                  BackdropFilter(
+                    filter: ImageFilter.blur(sigmaX: 100, sigmaY: 100),
+                    child: Container(
+                      color: Colors.black.withOpacity(0),
+                    ),
+                  ),
+                ],
+              );
+            },
+          ),
+          PageView(
+            controller: _controller,
+            children: List.generate(
+              onboardingCards.length,
+              (index) {
+                return Container(
+                  alignment: Alignment.center,
+                  child: onboardingCards[index],
+                );
+              }
+            ),
+          ),
        ],
      ),
-      floatingActionButton: FloatingActionButton(
+      floatingActionButton: FloatingActionButton.extended(
        onPressed: () {
-            if (_controller.page == 2) {
+          if (_controller.page == onboardingCards.length - 1) {
            Navigator.of(context).push(
              MaterialPageRoute(
                builder: (context) => const NewTripPage()
@@ -40,7 +97,22 @@ class _OnboardingPageState extends State<OnboardingPage> {
            _controller.nextPage(duration: Duration(milliseconds: 500), curve: Curves.ease);
          }
        },
-          child: Icon(Icons.arrow_forward),
+        label: AnimatedBuilder(
+          animation: _controller,
+          builder: (context, child) {
+            if ((_controller.page ?? _controller.initialPage) == onboardingCards.length - 1) {
+              return Row(
+                children: [
+                  const Text("Start planning!"),
+                  Padding(padding: const EdgeInsets.only(right: 8.0)),
+                  const Icon(Icons.map_outlined)
+                ],
+              );
+            } else {
+              return const Icon(Icons.arrow_forward);
+            }
+          }
+        )
      ),
    );
  }
--- a/frontend/lib/pages/settings.dart
+++ b/frontend/lib/pages/settings.dart
@@ -1,5 +1,6 @@
 import 'package:anyway/constants.dart';
 import 'package:anyway/main.dart';
+import 'package:anyway/pages/base_page.dart';
 import 'package:flutter/material.dart';
 import 'package:permission_handler/permission_handler.dart';
 import 'package:shared_preferences/shared_preferences.dart';
@@ -16,7 +17,8 @@ class SettingsPage extends StatefulWidget {
 class _SettingsPageState extends State<SettingsPage> {
  @override
  Widget build(BuildContext context) {
-    return ListView(
+    return BasePage(
+      mainScreen: ListView(
        padding: EdgeInsets.all(15),
        children: [
          // First a round, centered image
@@ -40,6 +42,12 @@ class _SettingsPageState extends State<SettingsPage> {

          privacyInfo(),
        ]
+      ),
+      title: Text('Settings'),
+      helpTexts: [
+        'Settings',
+        'Preferences set in this page are global and will affect the entire application.'
+      ],
    );
  }

@@ -169,7 +177,9 @@ class _SettingsPageState extends State<SettingsPage> {
    return Center(
      child: Column(
        children: [
-          Text('Our privacy policy is available under:'),
+          Text('AnyWay does not collect or store any of the data that is submitted via the app. The location of your trip is not stored. The location feature is only used to show your current location on the map, it is not transmitted to our servers.', textAlign: TextAlign.center),
+          Padding(padding: EdgeInsets.only(top: 3)),
+          Text('Our full privacy policy is available under:', textAlign: TextAlign.center),
          
          TextButton.icon(
            icon: Icon(Icons.info),
--- a/frontend/lib/structs/landmark.dart
+++ b/frontend/lib/structs/landmark.dart
@@ -24,8 +24,7 @@ final class Landmark extends LinkedListEntry<Landmark>{
  // description to be shown in the overview
  final String? nameEN;
  final String? websiteURL;
-  final String? wikipediaURL;
-  final String? imageURL;
+  String? imageURL; // not final because it can be patched
  final String? description;
  final Duration? duration;
  final bool? visited;
@@ -44,7 +43,6 @@ final class Landmark extends LinkedListEntry<Landmark>{

    this.nameEN,
    this.websiteURL,
-    this.wikipediaURL,
    this.imageURL,
    this.description,
    this.duration,
@@ -70,7 +68,6 @@ final class Landmark extends LinkedListEntry<Landmark>{
      final isSecondary = json['is_secondary'] as bool?;
      final nameEN = json['name_en'] as String?;
      final websiteURL = json['website_url'] as String?;
-      final wikipediaURL = json['wikipedia_url'] as String?;
      final imageURL = json['image_url'] as String?;
      final description = json['description'] as String?;
      var duration = Duration(minutes: json['duration'] ?? 0) as Duration?;
@@ -85,7 +82,6 @@ final class Landmark extends LinkedListEntry<Landmark>{
        isSecondary: isSecondary,
        nameEN: nameEN,
        websiteURL: websiteURL,
-        wikipediaURL: wikipediaURL,
        imageURL: imageURL,
        description: description,
        duration: duration,
@@ -112,7 +108,6 @@ final class Landmark extends LinkedListEntry<Landmark>{
    'is_secondary': isSecondary,
    'name_en': nameEN,
    'website_url': websiteURL,
-    'wikipedia_url': wikipediaURL,
    'image_url': imageURL,
    'description': description,
    'duration': duration?.inMinutes,
@@ -130,7 +125,7 @@ class LandmarkType {
  LandmarkType({required this.name, this.icon = const Icon(Icons.location_on)}) {
    switch (name) {
      case 'sightseeing':
-        icon = const Icon(Icons.church);
+        icon = const Icon(Icons.castle);
        break;
      case 'nature':
        icon = const Icon(Icons.eco);
--- a/frontend/lib/structs/trip.dart
+++ b/frontend/lib/structs/trip.dart
@@ -113,10 +113,3 @@ LinkedList<Landmark> readLandmarks(SharedPreferences prefs, String? firstUUID) {
  }
  return landmarks;
 }
-
-
-
-void removeAllTripsFromPrefs () async {
-  SharedPreferences prefs = await SharedPreferences.getInstance();
-  prefs.clear();
-}
--- a/frontend/lib/utils/fetch_trip.dart
+++ b/frontend/lib/utils/fetch_trip.dart
@@ -1,5 +1,6 @@
 import "dart:convert";
 import "dart:developer";
+import "package:anyway/utils/load_landmark_image.dart";
 import 'package:dio/dio.dart';

 import 'package:anyway/constants.dart';
@@ -85,6 +86,20 @@ fetchTrip(
 }


+patchLandmarkImage(Landmark landmark) async {
+  // patch the landmark to include an image from an external source
+  if (landmark.imageURL == null) {
+    String? newUrl = await getImageUrlFromName(landmark.name);
+    if (newUrl != null) {
+      landmark.imageURL = newUrl;
+    }
+  } else if (landmark.imageURL!.contains("photos.app.goo.gl")) {
+    // the image is a google photos link, we should get the image behind the link
+    String? newUrl = await getImageUrlFromGooglePhotos(landmark.imageURL!);
+    // also set the new url if it is null
+    landmark.imageURL = newUrl; 
+  }
+}

 Future<(Landmark, String?)> fetchLandmark(String uuid) async {
  final response = await dio.get(
@@ -101,5 +116,7 @@ Future<(Landmark, String?)> fetchLandmark(String uuid) async {
  log(response.data.toString());
  Map<String, dynamic> json = response.data;
  String? nextUUID = json["next_uuid"];
-  return (Landmark.fromJson(json), nextUUID);
+  Landmark landmark = Landmark.fromJson(json);
+  patchLandmarkImage(landmark);
+  return (landmark, nextUUID);
 }
--- a/frontend/lib/utils/get_first_page.dart
+++ b/frontend/lib/utils/get_first_page.dart
@@ -0,0 +1,41 @@
+import 'package:anyway/pages/current_trip.dart';
+import 'package:anyway/pages/onboarding.dart';
+import 'package:anyway/structs/trip.dart';
+import 'package:anyway/utils/load_trips.dart';
+import 'package:flutter/material.dart';
+
+Widget getFirstPage() {
+  SavedTrips trips = SavedTrips();
+  trips.loadTrips();
+
+  return ListenableBuilder(
+    listenable: trips,
+    builder: (BuildContext context, Widget? child) {
+      List<Trip> items = trips.trips;
+      if (items.isNotEmpty) {
+        return TripPage(trip: items[0]);
+      } else {
+        return OnboardingPage();
+      }
+    }
+  );
+  // Future<List<Trip>> trips = loadTrips();
+  // // test if there are any active trips
+  // // if there are, return the trip list
+  // // if there are not, return the onboarding page
+  // return FutureBuilder(
+  //   future: trips,
+  //   builder: (context, snapshot) {
+  //     if (snapshot.hasData) {
+  //       List<Trip> availableTrips = snapshot.data!;
+  //       if (availableTrips.isNotEmpty) {
+  //         return TripPage(trip: availableTrips[0]);
+  //       } else {
+  //         return OnboardingPage();
+  //       }
+  //     } else {
+  //       return CircularProgressIndicator();
+  //     }
+  //   }
+  // );
+}
--- a/frontend/lib/utils/load_landmark_image.dart
+++ b/frontend/lib/utils/load_landmark_image.dart
@@ -0,0 +1,71 @@
+import 'dart:developer';
+
+import 'package:dio/dio.dart';
+import 'package:fuzzywuzzy/fuzzywuzzy.dart';
+import 'dart:convert';
+
+import 'package:fuzzywuzzy/model/extracted_result.dart';
+
+const String baseUrl = "https://en.wikipedia.org/w/api.php";
+final Dio dio = Dio();
+
+Future<int?> bestPageMatch(String title) async {
+    final response = await dio.get(baseUrl, queryParameters: {
+        "action": "query",
+        "format": "json",
+        "list": "prefixsearch",
+        "pssearch": title,
+    });
+
+    final data = jsonDecode(response.toString());
+    log(data.toString());
+    final List<dynamic> results = data["query"]["prefixsearch"] ?? {};
+    final Map<String, int> titlesAndIds = {
+        for (var d in results) d["title"]: d["pageid"]
+    };
+    if (titlesAndIds.isEmpty) {
+        log("No pages found for $title");
+        return null;
+    }
+
+    // after the empty check, we can safely assume that there is a best match
+    final ExtractedResult<String> bestMatch = extractOne(
+      query: title,
+      choices: titlesAndIds.keys.toList(),
+      cutoff: 70,
+    );
+    return titlesAndIds[bestMatch.choice];
+}
+
+Future<String?> getImageUrl(int pageId) async {
+    final response = await dio.get(baseUrl, queryParameters: {
+        "action": "query",
+        "format": "json",
+        "prop": "pageimages",
+        "pageids": pageId,
+        "pithumbsize": 500,
+    });
+
+    final data = jsonDecode(response.toString());
+    final pageData = data["query"]["pages"][pageId.toString()];
+    return pageData["thumbnail"]?["source"];
+}
+
+Future<String?> getImageUrlFromName(String title) async {
+    int? pageId = await bestPageMatch(title);
+    if (pageId == null) {
+        return null;
+    }
+    return await getImageUrl(pageId);
+}
+
+
+Future<String?> getImageUrlFromGooglePhotos(String url) async {
+    // this is a very simple implementation that just gets the image behind the link
+    // it is not guaranteed to work for all google photos links
+    final response = await dio.get(url);
+    final data = response.toString();
+    final int start = data.indexOf("https://lh3.googleusercontent.com");
+    final int end = data.indexOf('"', start);
+    return data.substring(start, end);
+}
--- a/frontend/lib/utils/load_trips.dart
+++ b/frontend/lib/utils/load_trips.dart
@@ -1,10 +1,14 @@
-import 'dart:collection';
-
 import 'package:anyway/structs/trip.dart';
-import 'package:anyway/structs/landmark.dart';
 import 'package:shared_preferences/shared_preferences.dart';

-Future<List<Trip>> loadTrips() async {
+import 'package:flutter/foundation.dart';
+
+class SavedTrips extends ChangeNotifier {
+  List<Trip> _trips = [];
+
+  List<Trip> get trips => _trips;
+
+  void loadTrips() async {
    SharedPreferences prefs = await SharedPreferences.getInstance();

    List<Trip> trips = [];
@@ -15,5 +19,21 @@ Future<List<Trip>> loadTrips() async {
        trips.add(Trip.fromPrefs(prefs, uuid));
      }
    }
-  return trips;
+    _trips = trips;
+    notifyListeners();
+  }
+
+  void addTrip(Trip trip) async {
+    SharedPreferences prefs = await SharedPreferences.getInstance();
+    trip.toPrefs(prefs);
+    _trips.add(trip);
+    notifyListeners();
+  }
+
+  void clearTrips () async {
+    SharedPreferences prefs = await SharedPreferences.getInstance();
+    prefs.clear();
+    _trips = [];
+    notifyListeners();
+  }
 }
--- a/frontend/pubspec.lock
+++ b/frontend/pubspec.lock
@@ -101,10 +101,10 @@ packages:
    dependency: transitive
    description:
      name: collection
-      sha256: ee67cb0715911d28db6bf4af1026078bd6f0128b07a5f66fb2ed94ec6783c09a
+      sha256: a1ace0a119f20aabc852d165077c036cd864315bd99b7eaa10a60100341941bf
      url: "https://pub.dev"
    source: hosted
-    version: "1.18.0"
+    version: "1.19.0"
  crypto:
    dependency: transitive
    description:
@@ -232,6 +232,14 @@ packages:
    description: flutter
    source: sdk
    version: "0.0.0"
+  fuzzywuzzy:
+    dependency: "direct main"
+    description:
+      name: fuzzywuzzy
+      sha256: "3004379ffd6e7f476a0c2091f38f16588dc45f67de7adf7c41aa85dec06b432c"
+      url: "https://pub.dev"
+    source: hosted
+    version: "1.2.0"
  geocoding:
    dependency: "direct main"
    description:
@@ -404,18 +412,18 @@ packages:
    dependency: transitive
    description:
      name: leak_tracker
-      sha256: "3f87a60e8c63aecc975dda1ceedbc8f24de75f09e4856ea27daf8958f2f0ce05"
+      sha256: "7bb2830ebd849694d1ec25bf1f44582d6ac531a57a365a803a6034ff751d2d06"
      url: "https://pub.dev"
    source: hosted
-    version: "10.0.5"
+    version: "10.0.7"
  leak_tracker_flutter_testing:
    dependency: transitive
    description:
      name: leak_tracker_flutter_testing
-      sha256: "932549fb305594d82d7183ecd9fa93463e9914e1b67cacc34bc40906594a1806"
+      sha256: "9491a714cca3667b60b5c420da8217e6de0d1ba7a5ec322fab01758f6998f379"
      url: "https://pub.dev"
    source: hosted
-    version: "3.0.5"
+    version: "3.0.8"
  leak_tracker_testing:
    dependency: transitive
    description:
@@ -700,7 +708,7 @@ packages:
    dependency: transitive
    description: flutter
    source: sdk
-    version: "0.0.99"
+    version: "0.0.0"
  sliding_up_panel:
    dependency: "direct main"
    description:
@@ -745,10 +753,10 @@ packages:
    dependency: transitive
    description:
      name: stack_trace
-      sha256: "73713990125a6d93122541237550ee3352a2d84baad52d375a4cad2eb9b7ce0b"
+      sha256: "9f47fd3630d76be3ab26f0ee06d213679aa425996925ff3feffdec504931c377"
      url: "https://pub.dev"
    source: hosted
-    version: "1.11.1"
+    version: "1.12.0"
  stream_channel:
    dependency: transitive
    description:
@@ -769,10 +777,10 @@ packages:
    dependency: transitive
    description:
      name: string_scanner
-      sha256: "556692adab6cfa87322a115640c11f13cb77b3f076ddcc5d6ae3c20242bedcde"
+      sha256: "688af5ed3402a4bde5b3a6c15fd768dbf2621a614950b17f04626c431ab3c4c3"
      url: "https://pub.dev"
    source: hosted
-    version: "1.2.0"
+    version: "1.3.0"
  synchronized:
    dependency: transitive
    description:
@@ -793,10 +801,10 @@ packages:
    dependency: transitive
    description:
      name: test_api
-      sha256: "5b8a98dafc4d5c4c9c72d8b31ab2b23fc13422348d2997120294d3bac86b4ddb"
+      sha256: "664d3a9a64782fcdeb83ce9c6b39e78fd2971d4e37827b9b06c3aa1edc5e760c"
      url: "https://pub.dev"
    source: hosted
-    version: "0.7.2"
+    version: "0.7.3"
  typed_data:
    dependency: transitive
    description:
@@ -913,10 +921,10 @@ packages:
    dependency: transitive
    description:
      name: vm_service
-      sha256: "5c5f338a667b4c644744b661f309fb8080bb94b18a7e91ef1dbd343bed00ed6d"
+      sha256: f6be3ed8bd01289b34d679c2b62226f63c0e69f9fd2e50a6b3c1c729a961041b
      url: "https://pub.dev"
    source: hosted
-    version: "14.2.5"
+    version: "14.3.0"
  web:
    dependency: transitive
    description:
--- a/frontend/pubspec.yaml
+++ b/frontend/pubspec.yaml
@@ -51,6 +51,7 @@ dependencies:
  flutter_launcher_icons: ^0.13.1
  permission_handler: ^11.3.1
  geolocator: ^13.0.1
+  fuzzywuzzy: ^1.2.0

 dev_dependencies:
  flutter_test:
--- a/frontend/test/widget_test.dart
+++ b/frontend/test/widget_test.dart
@@ -1,30 +0,0 @@
-// This is a basic Flutter widget test.
-//
-// To perform an interaction with a widget in your test, use the WidgetTester
-// utility in the flutter_test package. For example, you can send tap and scroll
-// gestures. You can also use WidgetTester to find child widgets in the widget
-// tree, read text, and verify that the values of widget properties are correct.
-
-import 'package:flutter/material.dart';
-import 'package:flutter_test/flutter_test.dart';
-
-// import 'package:anyway/main.dart';
-import 'package:anyway/layout.dart';
-
-void main() {
-  testWidgets('Counter increments smoke test', (WidgetTester tester) async {
-    // Build our app and trigger a frame.
-    await tester.pumpWidget(BasePage(mainScreen: "map",));
-
-    // Verfiy that the title is displayed
-    expect(find.text('City Nav'), findsOneWidget);
-
-    // Tap the '+' icon and trigger a frame.
-    await tester.tap(find.byIcon(Icons.add));
-    await tester.pump();
-
-    // Verify that our counter has incremented.
-    expect(find.text('0'), findsNothing);
-    expect(find.text('1'), findsOneWidget);
-  });
-}
Author	SHA1	Message	Date
Remy Moll	d4de945df8	cleaner trip loading indicator Some checks failed Build and deploy the backend to staging / Build and push image (pull_request) Successful in 1m57s Details Build and deploy the backend to staging / Deploy to staging (pull_request) Successful in 26s Details Build and release debug APK / Build APK (pull_request) Has been cancelled Details	2025-02-05 13:50:38 +01:00
Remy Moll	d992b62533	tentatively shrink trip overview, nicer onboarding	2024-12-17 11:17:59 +01:00
Remy Moll	e78bee4597	some more images	2024-12-17 10:28:33 +01:00
Remy Moll	d186a51a87	WIP: ladnmark card adjustments	2024-12-15 16:30:17 +01:00
Remy Moll	4baf045c8c	better onboarding All checks were successful Build and deploy the backend to staging / Build and push image (pull_request) Successful in 2m1s Details Build and release debug APK / Build APK (pull_request) Successful in 10m54s Details Build and deploy the backend to staging / Deploy to staging (pull_request) Successful in 14s Details	2024-12-02 10:43:42 +01:00
Remy Moll	3f1fe463bf	better help and onboarding All checks were successful Build and deploy the backend to staging / Build and push image (pull_request) Successful in 1m40s Details Build and release debug APK / Build APK (pull_request) Successful in 7m23s Details Build and deploy the backend to staging / Deploy to staging (pull_request) Successful in 14s Details	2024-11-18 17:42:52 +01:00
Remy Moll	d58ef2562d	image querying from within the frontend All checks were successful Build and release debug APK / Build APK (pull_request) Successful in 7m40s Details	2024-11-06 14:45:43 +01:00