first commit

.gitignore

@@ -0,0 +1,131 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# IDEs
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Project specific
+data/tour_results.json
+*.log

Dockerfile

@@ -0,0 +1,18 @@
+FROM python:3.10-slim
+
+RUN useradd -m -u 1000 user
+USER user
+
+ENV PATH="/home/user/.local/bin:$PATH" \
+    PYTHONUNBUFFERED=1
+
+WORKDIR /home/user/app
+
+COPY --chown=user:user requirements.txt /home/user/app/
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY --chown=user:user . /home/user/app/
+
+EXPOSE 7860
+
+CMD bash -c "python app.py & sleep 3 && streamlit run streamlit_ui.py --server.port 7860 --server.address 0.0.0.0"

README.md

@@ -8,4 +8,547 @@ pinned: false
 license: apache-2.0
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# tour_ga — Generatore di tour turistici con NSGA-II e TOP-TW
+
+Progetto Python per la generazione automatica di tour personalizzati in città (Roma come caso di studio) tramite un algoritmo genetico multi-obiettivo. Il problema è modellato come **Team Orienteering Problem with Time Windows (TOP-TW)** e risolto con una variante di **NSGA-II** (Non-dominated Sorting Genetic Algorithm II, Deb et al., 2002).
+
+---
+
+## Indice
+
+1. [Il problema: TOP-TW](#1-il-problema-top-tw)
+2. [Fondamenti teorici: NSGA-II](#2-fondamenti-teorici-nsga-ii)
+3. [Struttura del progetto](#3-struttura-del-progetto)
+4. [Modello dati](#4-modello-dati)
+5. [Profilo turista (TouristProfile)](#5-profilo-turista-touristprofile)
+6. [Funzione fitness multi-obiettivo](#6-funzione-fitness-multi-obiettivo)
+7. [Operatori genetici](#7-operatori-genetici)
+8. [Riparazione genetica (Repair Engine)](#8-riparazione-genetica-repair-engine)
+9. [Greedy Seeding](#9-greedy-seeding)
+10. [Modello di trasporto realistico](#10-modello-di-trasporto-realistico)
+11. [Configurazione e avvio](#11-configurazione-e-avvio)
+12. [Risultati di esempio](#12-risultati-di-esempio)
+13. [Riferimenti](#13-riferimenti)
+
+---
+
+## 1. Il problema: TOP-TW
+
+Il **Team Orienteering Problem with Time Windows** è una generalizzazione del Travelling Salesman Problem in cui:
+
+- Esiste un insieme di **Punti di Interesse (PoI)** con uno score di attrattività, una durata di visita stimata e una finestra temporale di apertura `[open, close]`.
+- Non tutti i PoI possono essere visitati entro il **budget di tempo** giornaliero.
+- L'obiettivo è selezionare e ordinare un sottoinsieme di PoI in modo da **massimizzare lo score totale** rispettando i vincoli temporali.
+
+In questo progetto il problema viene esteso con tre obiettivi competitivi simultanei:
+
+| Obiettivo | Direzione | Significato |
+|-----------|-----------|-------------|
+| `total_score` | Massimizza | Interesse culturale/gastronomico del tour |
+| `total_distance` | Minimizza | Fatica e costi di spostamento |
+| `time_penalty` | Minimizza | Sforamento del budget giornaliero |
+
+La natura multi-obiettivo rende la ricerca di un'unica soluzione ottima impossibile: esistono molteplici soluzioni di compromesso (fronte di Pareto) tra le quali il turista sceglie in base alle proprie preferenze.
+
+---
+
+## 2. Fondamenti teorici: NSGA-II
+
+L'algoritmo NSGA-II (Deb, Pratap, Agarwal, Meyarivan — *IEEE Transactions on Evolutionary Computation*, Vol. 6, No. 2, 2002) risolve i tre limiti principali del suo predecessore NSGA:
+
+1. **Complessità computazionale** — Il sorting non-dominato originale era O(MN³). NSGA-II lo riduce a **O(MN²)** con un algoritmo di conteggio della dominanza.
+2. **Mancanza di elitismo** — NSGA-II combina popolazione corrente e figli in un pool di 2N individui e seleziona i migliori N: le soluzioni eccellenti non vengono mai perse.
+3. **Parametro di sharing** — Sostituito dalla **crowding distance**, una metrica parameter-free che misura la densità delle soluzioni nell'intorno di un individuo nello spazio degli obiettivi.
+
+### 2.1 Fast Non-Dominated Sorting
+
+Per ogni individuo `i` si calcolano:
+- `dom_count[i]`: numero di individui che dominano `i`
+- `dom_set[i]`: insieme degli individui dominati da `i`
+
+Un individuo `A` **domina** `B` se è migliore o uguale su tutti gli obiettivi e strettamente migliore su almeno uno. Gli individui con `dom_count = 0` formano il **Fronte 1** (Pareto front). Rimuovendo il fronte 1 e ripetendo si ottengono i fronti successivi. La complessità totale è **O(MN²)**.
+
+### 2.2 Crowding Distance
+
+Per ogni fronte, la crowding distance di un individuo `i` è la somma delle distanze normalizzate tra i vicini immediati lungo ciascun obiettivo:
+
+```
+CD(i) = Σ_m  |f_m(i+1) - f_m(i-1)| / (f_m_max - f_m_min)
+```
+
+Gli individui agli estremi del fronte ricevono distanza infinita. La crowding distance alta indica un individuo in una regione poco affollata — preferito nella selezione per mantenere diversità.
+
+### 2.3 Crowded-Comparison Operator
+
+Nella selezione a torneo, un individuo `A` è preferito a `B` se:
+- `rank(A) < rank(B)` (rango Pareto migliore), oppure
+- `rank(A) == rank(B)` e `crowd(A) > crowd(B)` (regione meno affollata)
+
+### 2.4 Ciclo evolutivo principale
+
+```
+Inizializzazione popolazione P (greedy seeding + casuale riparato)
+        ↓
+Valutazione fitness (3 obiettivi)
+        ↓
+Fast non-dominated sort → assegna rank e crowding distance
+        ↓
+┌─────────────────────────────────────────────────────────┐
+│  Selezione torneo (crowded-comparison)                  │
+│  Crossover (OX | PoI-aware, prob cx_prob)               │
+│  Mutazione (swap | insert | reverse | add-remove)       │
+│  Riparazione (categoria → TW → budget → cap → pasto)   │
+│  → popolazione figli Q (size N)                         │
+└─────────────────────────────────────────────────────────┘
+        ↓
+Unione R = P ∪ Q  (size 2N)
+        ↓
+Non-dominated sort su R → seleziona migliori N → nuova P
+        ↓
+Criterio di stop? (max generazioni | stagnazione)
+        ↓ NO                              ↓ SÌ
+     (loop)                     Restituisce Fronte 1
+```
+
+### 2.5 Adattamenti al TOP-TW
+
+L'NSGA-II standard opera su cromosomi di lunghezza fissa con variabili continue. Per il TOP-TW sono stati introdotti:
+
+- **Cromosomi a lunghezza variabile** — lista ordinata di PoI (sottoinsieme del pool, non permutazione completa)
+- **Repair-before-evaluation** — ogni individuo viene riparato dopo ogni operatore genetico, prima della valutazione fitness
+- **Gene Jolly** (via `add_remove_mutation`) — placeholder che viene sostituito con il PoI più conveniente disponibile
+- **Penalità dinamica sulle attese** — scoraggia tour con buchi temporali lunghi
+
+---
+
+## 3. Struttura del progetto
+
+```
+tour_generator_ga/
+├── core/
+│   ├── models.py       # PoI, Individual, TourSchedule, FitnessScore
+│   ├── distance.py     # DistanceMatrix (Haversine × 1.3)
+│   ├── fitness.py      # FitnessEvaluator multi-obiettivo
+│   └── profile.py      # TouristProfile + modello trasporto realistico
+├── ga/
+│   ├── operators.py    # crossover (OX, PoI-aware), mutation, selection
+│   ├── repair.py       # RepairEngine: 7 step di riparazione
+│   └── seeding.py      # GreedySeeder: costruzione iniziale α-greedy
+├── data/               # (placeholder per loader OSM/CSV)
+├── solver.py           # NSGA2Solver: ciclo evolutivo completo
+├── demo_rome.py        # Demo con dataset Roma e confronto profili
+└── README.md
+```
+
+---
+
+## 4. Modello dati
+
+### `PoI`
+
+```python
+@dataclass
+class PoI:
+    id:             str
+    name:           str
+    lat, lon:       float
+    score:          float           # attrattività [0, 1]
+    visit_duration: int             # minuti di visita
+    time_window:    TimeWindow      # (open, close) in minuti dalla mezzanotte
+    category:       PoICategory     # MUSEUM | MONUMENT | RESTAURANT | BAR | GELATERIA | PARK | VIEWPOINT
+    tags:           list[str]       # es. ["arte", "antico", "fotogenico"]
+```
+
+### `Individual` (cromosoma)
+
+```python
+class Individual:
+    genes:    list[PoI]       # sequenza ordinata del tour
+    fitness:  FitnessScore    # calcolata dopo evaluate()
+    _schedule: TourSchedule   # cache dello schedule decodificato
+```
+
+La rappresentazione come lista ordinata permette di codificare naturalmente sia l'insieme dei PoI visitati sia l'ordine di visita, senza vincoli di lunghezza fissa.
+
+### `TourSchedule`
+
+Output della decodifica del cromosoma: per ogni PoI vengono calcolati orario di arrivo, attesa all'apertura e orario di partenza. Il campo `total_wait` traccia i minuti di attesa cumulati e contribuisce alla penalità fitness.
+
+### `PoICategory`
+
+```
+MUSEUM | MONUMENT | RESTAURANT | BAR | GELATERIA | PARK | VIEWPOINT
+```
+
+La distinzione tra `RESTAURANT` (pasto formale) e `BAR`/`GELATERIA` (sosta breve) permette al `RepairEngine` di applicare vincoli differenziati per tipo di sosta alimentare.
+
+---
+
+## 5. Profilo turista (TouristProfile)
+
+Il `TouristProfile` è l'oggetto centrale che attraversa l'intero pipeline e determina il comportamento di ogni componente.
+
+```python
+@dataclass
+class TouristProfile:
+    transport_mode:      TransportMode     # WALK | CAR | TRANSIT | MIXED
+    mobility:            MobilityLevel     # NORMAL | LIMITED
+    allowed_categories:  list[str]         # categorie PoI ammesse
+    want_lunch:          bool              # richiede sosta pranzo
+    want_dinner:         bool              # richiede sosta cena
+    lunch_time:          int               # orario preferito pranzo (minuti)
+    dinner_time:         int               # orario preferito cena (minuti)
+    meal_window:         int               # flessibilità ±minuti attorno all'orario
+    max_bar_stops:       int = 1           # max soste bar nel tour
+    max_gelateria_stops: int = 1           # max soste gelateria nel tour
+    tag_weights:         dict[str, float]  # boost per tag di interesse
+    max_entry_fee:       float | None      # budget biglietti per PoI
+    group_size:          int = 1           # persone (influenza durata visite)
+```
+
+**Profili predefiniti disponibili:**
+
+| Factory | Modalità | Categorie | Pasti |
+|---------|----------|-----------|-------|
+| `profile_cultural_walker()` | WALK | museum, monument, viewpoint, restaurant | pranzo |
+| `profile_foodie_transit()` | TRANSIT | restaurant, bar, gelateria, monument, viewpoint | pranzo + cena |
+| `profile_family_mixed()` | MIXED / LIMITED | monument, park, viewpoint, restaurant | pranzo |
+| `profile_art_lover_car()` | CAR | museum, monument | pranzo |
+
+**Effetti sul pipeline:**
+
+- `DistanceMatrix` — usa `profile.travel_time_min(km)` per i tempi di percorrenza
+- `GreedySeeder` — filtra `allowed_pois` per categoria; usa `effective_score()` (con boost tag)
+- `RepairEngine` — filtra categorie, applica cap ristoranti/snack, garantisce slot pasto
+- `FitnessEvaluator` — calcola score con boost da `tag_weights`; penalizza pasti mancanti
+
+---
+
+## 6. Funzione fitness multi-obiettivo
+
+La fitness è calcolata in `FitnessEvaluator.evaluate()` e comprende tre componenti separate per NSGA-II e uno scalare aggregato per confronti rapidi (tournament selection):
+
+### Score effettivo con boost
+
+```python
+effective_score(poi) = min(poi.score × Π(1 + tag_weight - 1), 1.5)
+```
+
+I `tag_weights` del profilo amplificano i PoI tematicamente rilevanti (es. `arte × 1.4` per un turista culturale). Il cap a 1.5 evita distorsioni eccessive.
+
+### Scalare aggregato
+
+```
+scalar = w_score × norm(total_score)
+       - w_dist  × norm(total_distance)
+       - time_over_penalty     # solo sullo sforamento, non sull'uso del budget
+       - wait_penalty          # penalizza attese cumulate > 5 min
+       - meal_penalty          # penalizza slot pasto non coperti
+```
+
+La scelta deliberata di **non penalizzare l'uso del budget** (solo lo sforamento) evita che il GA produca tour brevissimi per minimizzare il tempo. Un tour di 10 ore che rispetta il budget di 11 ore non è peggio di uno da 3 ore.
+
+### I tre obiettivi Pareto
+
+| Obiettivo | Misura | Direzione |
+|-----------|--------|-----------|
+| `total_score` | score effettivo cumulato | Massimizza |
+| `total_distance` | km percorsi (Haversine × 1.3) | Minimizza |
+| `total_time` | minuti totali del tour | Minimizza |
+
+La dominanza Pareto è implementata in `FitnessScore.dominates()`:
+
+```python
+def dominates(self, other) -> bool:
+    better_or_equal = (score ≥ and dist ≤ and time ≤)
+    strictly_better = (score > or dist < or time <)
+    return better_or_equal and strictly_better
+```
+
+---
+
+## 7. Operatori genetici
+
+### Selezione
+
+**Tournament selection** con `k=3` candidati casuali. Con `use_pareto=True` (default) preferisce rango Pareto basso e crowding distance alta, implementando l'operatore crowded-comparison di NSGA-II.
+
+### Crossover
+
+**Order Crossover (OX) adattato** — Preserva l'ordine relativo dei PoI condivisi tra i genitori senza duplicati. Adattato al TOP-TW per gestire cromosomi a lunghezza variabile (sottoinsiemi, non permutazioni complete).
+
+```
+Genitore A: [Trevi, Navona, Pantheon, Pranzo, Colosseo]
+Genitore B: [Colosseo, Pranzo, Borghese, Trevi, Castel]
+
+Segmento da A (pos 1-2): [Navona, Pantheon]
+Riempimento da B (escl. duplicati): [Colosseo, Pranzo, Trevi, Castel]
+Figlio: [Colosseo, Navona, Pantheon, Pranzo, Trevi, Castel]
+```
+
+**PoI-aware Crossover** — Scambia interi blocchi per categoria (es. tutti i musei da A, tutti i ristoranti da B). Preserva la "nicchia tematica" del genitore e mantiene la coerenza del profilo turista.
+
+### Mutazione
+
+Quattro operatori applicati con probabilità adattiva:
+
+| Operatore | Effetto | Caso d'uso |
+|-----------|---------|------------|
+| `swap_mutation` | Scambia 2 PoI nella sequenza | Esplorazione locale |
+| `insert_mutation` | Rimuove e reinserisce un PoI | Fix ordinamento temporale |
+| `reverse_segment_mutation` | Inverte un sottosegmento | Elimina crossing geografici |
+| `add_remove_mutation` | Aggiunge/rimuove un PoI dal pool ammesso | Modifica lunghezza tour |
+
+La `add_remove_mutation` opera **solo sul pool filtrato** per le categorie del profilo — non può mai inserire un ristorante nel tour di un turista che li ha esclusi.
+
+---
+
+## 8. Riparazione genetica (Repair Engine)
+
+Ogni individuo viene riparato dopo ogni operatore genetico, prima della valutazione fitness. La pipeline di riparazione ha **7 step in sequenza**:
+
+```
+1. _filter_allowed_categories   → rimuove PoI di categorie non ammesse
+2. _sort_by_earliest_deadline   → riordina per orario di apertura (EDF)
+3. repair_time_windows          → rimuove PoI con TW violata o attesa > max_wait_min
+4. repair_budget                → rimuove PoI a minor score/durata finché budget rispettato
+5. _cap_restaurants             → limita ristoranti formali al numero di slot pasto
+6. _cap_snacks                  → limita bar e gelaterie ai massimi del profilo
+7. _ensure_meal_slots           → garantisce un ristorante per ogni slot pasto richiesto
+```
+
+### Step 3: max_wait_min
+
+Il parametro `max_wait_min` (default 30) definisce la massima attesa tollerata per qualsiasi PoI. Un ristorante che apre alle 12:00 e a cui si arriva alle 9:30 viene **rimosso** — non ha senso aspettare 2 ore e mezza. L'eccezione è `_ensure_meal_slots`, che tolera fino a 45 minuti di attesa per garantire la sosta pranzo/cena.
+
+### Step 7: strategia di inserimento/sostituzione
+
+Quando deve garantire un pasto, `_ensure_meal_slots` prova due strategie:
+
+1. **Inserimento diretto** — aggiunge il ristorante nella posizione temporalmente corretta senza sforare il budget.
+2. **Sostituzione** — se non c'è spazio, rimuove il PoI con il peggior rapporto score/durata e lo sostituisce con il ristorante. Questo evita che tour a budget pieno perdano la garanzia del pasto.
+
+---
+
+## 9. Greedy Seeding
+
+La popolazione iniziale è costruita con una strategia mista 20/20/60:
+
+| Quota | Strategia | Scopo |
+|-------|-----------|-------|
+| 20% | Greedy puro (`alpha=0`) | Massima qualità iniziale, convergenza rapida |
+| 20% | α-greedy perturbato (`alpha` da 0.15 a 0.50) | Varietà controllata vicino all'ottimo |
+| 60% | Casuale riparato | Massima diversità genetica |
+
+### Criterio greedy: ratio score/overhead
+
+```python
+ratio = effective_score(poi) / (travel_min + wait_min + visit_duration)
+```
+
+Dove `effective_score` include già i boost da `tag_weights` del profilo. Il criterio seleziona il PoI che massimizza il valore per minuto di tempo investito (spostamento + attesa + visita).
+
+### Restricted Candidate List (GRASP-like)
+
+Con `alpha > 0`, invece di scegliere sempre il candidato migliore, si sceglie **casualmente tra il top 20%** per ratio. Questo produce soluzioni diverse ma ancora di buona qualità, avvicinandosi alla strategia GRASP (Greedy Randomized Adaptive Search Procedure).
+
+Tutti gli individui iniziali (greedy inclusi) passano per `repair.repair()` per garantire la coerenza con i vincoli del profilo fin dalla prima generazione.
+
+---
+
+## 10. Modello di trasporto realistico
+
+Il calcolo dei tempi di percorrenza in `profile.travel_time_min(km)` usa un modello che riflette la realtà urbana:
+
+### WALK
+
+```
+t = km / v_walk
+```
+- `v_walk_normal = 4.5 km/h`, `v_walk_limited = 3.0 km/h`
+
+### TRANSIT (bus + metro)
+
+```
+if km < 0.40:          # soglia: prendere il mezzo non conviene
+    t = km / v_walk
+else:
+    t = km / 20.0 + 10 min   # 10 min overhead (attesa + fermata)
+```
+
+L'overhead fisso di 10 minuti per tratta modella la realtà di Roma: frequenza media bus 8-12 minuti, metro 4-5 minuti, più il cammino alle fermate.
+
+### CAR / TAXI
+
+```
+t = km / 25.0 + 5 min   # 5 min overhead parcheggio
+```
+
+### MIXED
+
+Per distanze sotto `600 m` si usa `v_walk`; oltre si usa la velocità transit con overhead.
+
+---
+
+## 11. Configurazione e avvio
+
+### Requisiti
+
+```
+Python ≥ 3.10   (per syntax X | None nei type hint)
+Nessuna dipendenza esterna (stdlib only)
+```
+
+### SolverConfig
+
+```python
+from tour_ga.solver import SolverConfig
+
+config = SolverConfig(
+    pop_size         = 80,      # dimensione popolazione
+    max_generations  = 300,     # generazioni massime
+    cx_prob          = 0.85,    # probabilità crossover
+    mut_prob         = 0.20,    # probabilità mutazione
+    tournament_k     = 3,       # candidati per torneo
+    stagnation_limit = 50,      # early stop per stagnazione
+    start_time       = 540,     # 09:00 (minuti dalla mezzanotte)
+    budget           = 480,     # 8 ore di tour
+    start_lat        = 41.896,  # coordinate punto di partenza
+    start_lon        = 12.484,
+    max_wait_min     = 30,      # attesa massima tollerata per PoI
+    w_score          = 0.50,    # peso obiettivo score
+    w_dist           = 0.20,    # peso obiettivo distanza
+    w_time           = 0.30,    # peso penalità tempo
+)
+```
+
+### Avvio base
+
+```python
+from tour_ga.core.models import PoI, PoICategory, TimeWindow
+from tour_ga.core.distance import DistanceMatrix
+from tour_ga.core.profile import profile_cultural_walker
+from tour_ga.solver import NSGA2Solver, SolverConfig
+
+pois = [...]   # lista di PoI
+profile = profile_cultural_walker()
+
+dm = DistanceMatrix(pois, profile=profile)
+dm.build()     # calcola matrice distanze (una volta sola)
+
+solver = NSGA2Solver(pois, dm, config, profile=profile)
+pareto_front = solver.solve()  # restituisce lista di Individual
+
+# Selezione della soluzione consigliata dal fronte
+best = max(pareto_front, key=lambda x: x.fitness.scalar)
+schedule = solver.evaluator.decode(best)
+print(schedule.summary())
+```
+
+### Profilo custom
+
+```python
+from tour_ga.core.profile import TouristProfile, TransportMode
+
+profile = TouristProfile(
+    transport_mode     = TransportMode.TRANSIT,
+    allowed_categories = ["monument", "viewpoint", "bar"],
+    want_lunch         = False,
+    want_dinner        = False,
+    max_bar_stops      = 2,
+    tag_weights        = {"fotogenico": 1.5, "panorama": 1.3},
+)
+```
+
+### Callback di monitoraggio
+
+```python
+def progress(gen, pareto_front, stats):
+    print(f"Gen {gen}: pareto={stats['pareto_size']}, "
+          f"best={stats['best_scalar']:.4f}, "
+          f"feasible={stats['feasible_pct']:.0f}%")
+
+front = solver.solve(callback=progress)
+```
+
+### Demo completa
+
+```bash
+python tour_ga/demo_rome.py
+```
+
+---
+
+## 12. Risultati di esempio
+
+Configurazione: `budget=660 min` (11h), `start_time=570` (09:30), `pop_size=60`, `max_generations=200`, Roma.
+
+### Profilo gastronomico con mezzi (TRANSIT, pranzo + cena)
+
+```
+09:42–10:12  Fontana di Trevi
+10:24–10:54  Piazza di Spagna
+11:08–11:53  Piazza Navona
+11:56–12:16  Sant'Eustachio il Caffè         ← bar pomeridiano
+12:27–13:27  Osteria del Rione               ← pranzo garantito
+13:41–15:11  Castel Sant'Angelo
+15:24–16:24  Pantheon
+16:37–18:07  Foro Romano
+18:21–18:41  Fatamorgana                     ← gelateria pomeridiana
+19:00–20:20  Ristorante San Pietro           ← cena garantita (attesa 4 min)
+Totale: 650 min, 10.9 km, attese 4 min
+Composizione: 1×bar, 1×gelateria, 4×monument, 2×restaurant, 2×viewpoint
+```
+
+### Profilo culturale a piedi (WALK, solo pranzo)
+
+```
+09:39–10:09  Fontana di Trevi
+10:18–10:48  Piazza di Spagna
+11:06–11:51  Piazza Navona
+12:00–13:00  Osteria del Rione               ← pranzo (attesa 3 min)
+13:05–14:05  Pantheon
+14:21–15:51  Foro Romano
+16:01–18:01  Colosseo
+18:32–20:02  Trastevere
+Totale: 632 min, 8.1 km, attese 3 min
+```
+
+### Profilo custom: solo viste, nessun pasto
+
+```
+09:39–10:09  Fontana di Trevi
+10:18–10:48  Piazza di Spagna
+11:06–11:51  Piazza Navona
+11:54–12:14  Sant'Eustachio il Caffè
+12:16–13:16  Pantheon
+13:33–15:03  Castel Sant'Angelo
+15:14–15:34  Fatamorgana
+Totale: 364 min, 5.5 km
+```
+
+---
+
+## 13. Riferimenti
+
+### Articolo scientifico principale
+
+Deb, K., Pratap, A., Agarwal, S., & Meyarivan, T. (2002). **A Fast and Elitist Multiobjective Genetic Algorithm: NSGA-II**. *IEEE Transactions on Evolutionary Computation*, 6(2), 182–197.
+[https://www.cse.unr.edu/~sushil/class/gas/papers/nsga2.pdf](https://www.cse.unr.edu/~sushil/class/gas/papers/nsga2.pdf)
+
+Il paper introduce tre contributi fondamentali qui implementati: il fast non-dominated sorting O(MN²) tramite conteggio della dominanza (implementato in `solver.py::_fast_non_dominated_sort`), la crowding distance come meccanismo di diversità parameter-free (implementato in `_assign_crowding_distance`), e il crowded-comparison operator per selezione a torneo (in `operators.py::tournament_select`).
+
+### Riferimento divulgativo
+
+Non-Dominated Sorting Genetic Algorithm 2 (NSGA-II) — GeeksforGeeks.
+[https://www.geeksforgeeks.org/deep-learning/non-dominated-sorting-genetic-algorithm-2-nsga-ii/](https://www.geeksforgeeks.org/deep-learning/non-dominated-sorting-genetic-algorithm-2-nsga-ii/)
+
+### Problema di riferimento
+
+Vansteenwegen, P., Souffriau, W., & Van Oudheusden, D. (2011). **The Orienteering Problem: A Survey**. *European Journal of Operational Research*, 209(1), 1–10.
+
+Chao, I. M., Golden, B. L., & Wasil, E. A. (1996). **The Team Orienteering Problem**. *European Journal of Operational Research*, 88(3), 464–474.
+
+### Calcolo distanze
+
+Formula di Haversine per la distanza geodetica tra due coordinate GPS, con fattore correttivo 1.3 per approssimare il percorso urbano reale rispetto alla linea d'aria.

app.py

@@ -0,0 +1,225 @@
+"""
+app.py — FastAPI backend for Tour Generator.
+Exposes API endpoints for generating tours.
+"""
+from fastapi import FastAPI, UploadFile, File, Form, HTTPException
+from pydantic import BaseModel
+import json
+from typing import List, Optional
+from core.models import PoI, PoICategory, TimeWindow
+from core.profile import (
+    TouristProfile, MobilityLevel, TransportMode,
+    profile_cultural_walker, profile_foodie_transit,
+    profile_family_mixed, profile_art_lover_car
+)
+from core.distance import DistanceMatrix, haversine_km
+from solver import NSGA2Solver, SolverConfig
+import pandas as pd
+
+app = FastAPI(title="Tour Generator API", description="API for generating optimized tours using genetic algorithms")
+
+# Predefined profiles
+PREDEFINED_PROFILES = {
+    "cultural_walker": profile_cultural_walker(),
+    "foodie_transit": profile_foodie_transit(),
+    "family_mixed": profile_family_mixed(),
+    "art_lover_car": profile_art_lover_car(),
+}
+
+class PoIModel(BaseModel):
+    id: str
+    name: str
+    lat: float
+    lon: float
+    score: float
+    visit_duration: int
+    time_window_open: int
+    time_window_close: int
+    category: str
+    tags: List[str] = []
+
+class ProfileModel(BaseModel):
+    transport_mode: TransportMode = TransportMode.WALK
+    mobility: MobilityLevel = MobilityLevel.NORMAL
+    allowed_categories: List[str] = ["museum", "monument", "restaurant", "park", "viewpoint"]
+    want_lunch: bool = True
+    want_dinner: bool = True
+    lunch_time: int = 720
+    dinner_time: int = 1140
+    meal_window: int = 120
+    max_bar_stops: int = 2
+    max_gelateria_stops: int = 1
+    tag_weights: dict = {}
+    max_entry_fee: Optional[float] = None
+    group_size: int = 1
+
+@app.post("/generate_tour")
+async def generate_tour(
+    pois_file: Optional[UploadFile] = File(None),
+    pois_json: Optional[str] = Form(None),
+    profile_name: Optional[str] = Form(None),
+    profile_json: Optional[str] = Form(None),
+    budget: int = Form(480),
+    start_time: int = Form(540),
+    start_lat: float = Form(41.9028),
+    start_lon: float = Form(12.4964),
+):
+    """
+    Generate an optimized tour based on POIs and user profile.
+    
+    - pois_file: Upload CSV or JSON file with POIs
+    - pois_json: JSON string with list of POIs
+    - profile_name: Name of predefined profile
+    - profile_json: JSON string with custom profile
+    - budget: Time budget in minutes
+    - start_time: Start time in minutes from midnight
+    - start_lat/lon: Starting coordinates
+    """
+    # Load POIs
+    pois = []
+    if pois_file:
+        content = await pois_file.read()
+        if pois_file.filename.endswith('.csv'):
+            df = pd.read_csv(pd.io.common.BytesIO(content))
+            for _, row in df.iterrows():
+                pois.append(PoI(
+                    id=str(row['id']),
+                    name=str(row['name']),
+                    lat=float(row['lat']),
+                    lon=float(row['lon']),
+                    score=float(row['score']),
+                    visit_duration=int(row['visit_duration']),
+                    time_window=TimeWindow(int(row['time_window_open']), int(row['time_window_close'])),
+                    category=PoICategory(row['category']),
+                    tags=str(row.get('tags', '')).split(',') if pd.notna(row.get('tags')) else []
+                ))
+        elif pois_file.filename.endswith('.json'):
+            data = json.loads(content.decode('utf-8'))
+            for p in data:
+                pois.append(PoI(
+                    id=p['id'],
+                    name=p['name'],
+                    lat=p['lat'],
+                    lon=p['lon'],
+                    score=p['score'],
+                    visit_duration=p['visit_duration'],
+                    time_window=TimeWindow(p['time_window']['open'], p['time_window']['close']),
+                    category=PoICategory(p['category']),
+                    tags=p.get('tags', [])
+                ))
+        else:
+            raise HTTPException(status_code=400, detail="Unsupported file type for POIs. Use CSV or JSON.")
+    elif pois_json:
+        pois_data = json.loads(pois_json)
+        for p in pois_data:
+            pois.append(PoI(
+                id=p['id'],
+                name=p['name'],
+                lat=p['lat'],
+                lon=p['lon'],
+                score=p['score'],
+                visit_duration=p['visit_duration'],
+                time_window=TimeWindow(p['time_window']['open'], p['time_window']['close']),
+                category=PoICategory(p['category']),
+                tags=p.get('tags', [])
+            ))
+    else:
+        raise HTTPException(status_code=400, detail="POIs not provided. Upload a file or provide JSON.")
+
+    # Load profile
+    if profile_name:
+        if profile_name in PREDEFINED_PROFILES:
+            profile = PREDEFINED_PROFILES[profile_name]
+        else:
+            raise HTTPException(status_code=400, detail=f"Invalid profile name. Available: {list(PREDEFINED_PROFILES.keys())}")
+    elif profile_json:
+        profile_data = json.loads(profile_json)
+        profile = TouristProfile(**profile_data)
+    else:
+        profile = TouristProfile()  # default
+
+    # Create distance matrix
+    dm = DistanceMatrix(pois, profile)
+
+    # Config
+    config = SolverConfig(budget=budget, start_time=start_time, start_lat=start_lat, start_lon=start_lon)
+
+    # Solve
+    def cb(gen, pareto, stats):
+        if gen % 30 == 0 or gen == 1:
+            print(f"  gen {gen:3d} | pareto={stats['pareto_size']:2d} | "
+                  f"best={stats['best_scalar']:.4f} | feasible={stats['feasible_pct']:.0f}%")
+
+    solver = NSGA2Solver(pois, dm, config, profile)
+    population = solver.solve(callback=cb)
+
+    feasible = [x for x in population if x.fitness.is_feasible] or population
+    if not feasible:
+        raise HTTPException(status_code=500, detail="No solutions found")
+
+    # Get best tour (highest scalar fitness)
+    best = max(feasible, key=lambda individual: individual.fitness.scalar)
+    tour = solver.evaluator.decode(best)
+
+    if tour is None:
+        raise HTTPException(status_code=500, detail="Failed to generate schedule")
+
+    # Return as dict
+    stops_list = []
+    for i, s in enumerate(tour.stops):
+        if i == 0:
+            dist = haversine_km(start_lat, start_lon, s.poi.lat, s.poi.lon)
+        else:
+            dist = haversine_km(tour.stops[i-1].poi.lat, tour.stops[i-1].poi.lon, s.poi.lat, s.poi.lon)
+        time_min = profile.travel_time_min(dist)
+        
+        stop_dict = {
+            "poi_id": s.poi.id,
+            "poi_name": s.poi.name,
+            "arrival": s.arrival,
+            "departure": s.departure,
+            "wait": s.wait,
+            "travel_distance_km": round(dist, 2),
+            "travel_time_min": time_min
+        }
+        stops_list.append(stop_dict)
+    
+    return {
+        "total_score": best.fitness.total_score,
+        "total_distance": tour.total_distance,
+        "total_time": tour.total_time,
+        "is_feasible": tour.is_feasible,
+        "stops": stops_list
+    }
+
+@app.get("/profiles")
+def get_profiles():
+    """Get list of available predefined profiles."""
+    return {"profiles": list(PREDEFINED_PROFILES.keys())}
+
+@app.get("/profiles/{name}")
+def get_profile(name: str):
+    """Get details of a specific predefined profile."""
+    if name in PREDEFINED_PROFILES:
+        profile = PREDEFINED_PROFILES[name]
+        return {
+            "transport_mode": profile.transport_mode.value,
+            "mobility": profile.mobility.value,
+            "allowed_categories": profile.allowed_categories,
+            "want_lunch": profile.want_lunch,
+            "want_dinner": profile.want_dinner,
+            "lunch_time": profile.lunch_time,
+            "dinner_time": profile.dinner_time,
+            "meal_window": profile.meal_window,
+            "max_bar_stops": profile.max_bar_stops,
+            "max_gelateria_stops": profile.max_gelateria_stops,
+            "tag_weights": profile.tag_weights,
+            "max_entry_fee": profile.max_entry_fee,
+            "group_size": profile.group_size
+        }
+    else:
+        raise HTTPException(status_code=404, detail="Profile not found")
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

config.py

@@ -0,0 +1,216 @@
+"""
+config.py — Configurazione centralizzata del progetto tour_ga.
+
+Tutte le costanti "magiche" del progetto sono raccolte qui.
+I moduli importano da questo file invece di avere valori hardcoded.
+
+Struttura:
+  TRANSPORT  — velocità, overhead, soglie di modalità
+  FITNESS    — pesi obiettivi, penalità, normalizzazione
+  REPAIR     — vincoli di riparazione genetica
+  SEEDING    — parametri costruzione popolazione iniziale
+  GA         — default algoritmo evolutivo
+  VISUALIZER — colori e stili per la mappa HTML
+"""
+from __future__ import annotations
+
+# ============================================================
+# TRANSPORT — Modello di percorrenza realistico
+# ============================================================
+
+# Fattore correttivo Haversine → percorso stradale reale
+# 1.0 = linea d'aria, 1.3 = stima tipica percorso urbano
+ROUTE_DETOUR_FACTOR: float = 1.3
+
+# Soglia sotto la quale, anche in modalità MIXED, si usa v_walk
+# (600 m → preferisce a piedi rispetto al mezzo)
+MIXED_THRESHOLD_M: int = 600
+
+# Soglia sotto la quale non conviene prendere il mezzo in TRANSIT
+# (prendere bus/metro per <400m è più lento del cammino)
+TRANSIT_WALK_THRESHOLD_KM: float = 0.40
+
+# Overhead fisso per ogni tratta in mezzo pubblico (minuti)
+# Comprende: cammino alla fermata + attesa mezzo + cammino dalla fermata
+# Roma: bus ~8-12 min freq., metro ~4-5 min freq. → media 10 min
+TRANSIT_OVERHEAD_MIN: int = 10
+
+# Overhead fisso per ogni tratta in auto/taxi (minuti)
+# Comprende: ricerca parcheggio + cammino dal parcheggio
+CAR_OVERHEAD_MIN: int = 5
+
+# Velocità medie di percorrenza in km/h (escluso overhead)
+# Chiave: (TransportMode.value, MobilityLevel.value)
+SPEED_KMH: dict[tuple[str, str], float] = {
+    ("walk",    "normal"):  4.5,
+    ("walk",    "limited"): 3.0,
+    ("car",     "normal"):  25.0,
+    ("car",     "limited"): 25.0,
+    ("transit", "normal"):  20.0,   # metro Roma in media ~20 km/h
+    ("transit", "limited"): 16.0,
+    ("mixed",   "normal"):  4.5,    # segmenti brevi → v_walk
+    ("mixed",   "limited"): 3.0,
+}
+
+# Velocità per segmenti lunghi in modalità MIXED (oltre MIXED_THRESHOLD_M)
+MIXED_LONG_SPEED_KMH: dict[str, float] = {
+    "normal":  20.0,
+    "limited": 16.0,
+}
+
+# ============================================================
+# FITNESS — Funzione di valutazione multi-obiettivo
+# ============================================================
+
+# Pesi default per la funzione scalare aggregata
+W_SCORE: float = 0.50   # peso obiettivo score (da massimizzare)
+W_DIST:  float = 0.20   # peso obiettivo distanza (da minimizzare)
+W_TIME:  float = 0.30   # peso penalità tempo (non usato nello scalare diretto)
+
+# Penalità per sforamento budget (per ora di sforamento)
+PENALTY_BUDGET_OVERRUN: float = 50.0
+
+# Penalità scalare per slot pasto non coperto
+# Applicata solo se "restaurant" è nelle categorie ammesse dal profilo
+PENALTY_MEAL_MISSING: float = 0.25
+
+# Soglia di attesa cumulata (minuti) sotto cui non si penalizza
+# Attese brevi (es. 3 min prima dell'apertura) sono accettabili
+WAIT_PENALTY_THRESHOLD_MIN: int = 5
+
+# Fattore di penalità per i minuti di attesa eccedenti la soglia
+# (per ora di attesa cumulata oltre la soglia)
+WAIT_PENALTY_FACTOR: float = 10.0
+
+# Cap moltiplicativo per effective_score con boost da tag_weights
+# Evita che tag boost portino lo score molto sopra 1.0
+SCORE_BOOST_CAP: float = 1.5
+
+# Distanza massima di normalizzazione per la fitness (km)
+# Dipende dalla modalità di trasporto
+MAX_DIST_WALK_KM:    float = 15.0
+MAX_DIST_TRANSIT_KM: float = 50.0
+MAX_DIST_CAR_KM:     float = 80.0
+
+# Minuti di visita extra per ogni membro del gruppo oltre il primo
+GROUP_VISIT_OVERHEAD_PER_PERSON: int = 5
+
+# Fitness utilization bonus
+FITNESS_UTILIZATION_BONUS_FACTOR : float = 0.3
+
+# ============================================================
+# REPAIR — Vincoli del motore di riparazione genetica
+# ============================================================
+
+# Attesa massima tollerata per qualsiasi PoI (minuti)
+# PoI che richiederebbero un'attesa maggiore vengono rimossi dal tour
+MAX_WAIT_MIN: int = 30
+
+# Tolleranza di attesa speciale per l'inserimento di ristoranti
+# nei slot pasto: arrivare poco prima dell'apertura è comportamento normale
+MEAL_SLOT_WAIT_OVERRIDE_MIN: int = 45
+
+# Fraction della lunghezza del tour usata nell'ordinamento per
+# spostare i ristoranti nella posizione temporalmente corretta
+# (non una costante numerica, ma un commento di design)
+
+# ============================================================
+# SEEDING — Costruzione della popolazione iniziale
+# ============================================================
+
+# Frazione di individui costruiti con greedy deterministico
+SEED_GREEDY_FRACTION: float = 0.20
+
+# Frazione di individui costruiti con α-greedy perturbato
+SEED_PERTURBED_FRACTION: float = 0.20
+
+# Il restante (1 - greedy - perturbed) viene costruito casualmente e riparato
+
+# Range del parametro alpha per l'α-greedy perturbato
+# alpha=0 → greedy puro; alpha=0.5 → semi-casuale (GRASP-like)
+SEED_ALPHA_MIN: float = 0.15
+SEED_ALPHA_MAX: float = 0.50   # alpha_min + 0.35
+
+# Dimensione della Restricted Candidate List come frazione dei candidati
+# (top RCL_FRACTION vengono estratti casualmente invece del migliore assoluto)
+RCL_FRACTION: float = 0.20
+
+# ============================================================
+# PASTI - Valori di default
+# ============================================================
+
+# --- Preferenze pasti ---
+WANT_LUNCH:             bool = True
+WANT_DINNER:            bool = False
+LUNCH_TIME:             int  = 720
+DINNER_TIME:            int  = 1140
+MEAL_WINDOW:            int  = 60
+MAX_BAR_STOPS:          int = 1
+MAX_GELATERIA_STOPS:    int = 1
+MEAL_RESERVE_MIN:       int  = 90
+EVENING_THRESHOLD:      int  = 1140   # 19:00
+
+# ============================================================
+# GA — Default dell'algoritmo evolutivo (usati da SolverConfig)
+# ============================================================
+
+GA_POP_SIZE:         int   = 80
+GA_MAX_GENERATIONS:  int   = 300
+GA_CX_PROB:          float = 0.85    # probabilità di crossover
+GA_MUT_PROB:         float = 0.20    # probabilità di mutazione
+GA_TOURNAMENT_K:     int   = 3       # candidati per torneo
+GA_STAGNATION_LIMIT: int   = 50      # generazioni senza miglioramento → stop
+GA_MAX_WAIT_MIN:     int   = MAX_WAIT_MIN   # propagato al RepairEngine
+GA_OX_CROSSOVER_PROB: float = 0.60
+# Probabilità di usare Order Crossover (OX) vs PoI-aware crossover,
+# condizionata all'aver già deciso di fare crossover (cx_prob).
+# OX è più conservativo (preserva ordine globale),
+# PoI-aware è più espolorativo (scambia blocchi per categoria).
+# Un mix 60/40 bilancia convergenza ed esplorazione tematica.
+# Orario di partenza e budget default (minuti dalla mezzanotte)
+
+DEFAULT_START_TIME: int = 540    # 09:00
+DEFAULT_BUDGET:     int = 480    # 8 ore
+
+# Coordinate default (Roma, centro storico)
+DEFAULT_START_LAT: float = 41.8960
+DEFAULT_START_LON: float = 12.4840
+
+# ============================================================
+# VISUALIZER — Stili per la mappa HTML interattiva
+# ============================================================
+
+# Colori hex per categoria PoI sulla mappa
+# Basati sui ramp del design system del progetto
+CATEGORY_COLORS: dict[str, str] = {
+    "museum":     "#7F77DD",   # purple-400
+    "monument":   "#378ADD",   # blue-400
+    "restaurant": "#D85A30",   # coral-400
+    "bar":        "#BA7517",   # amber-400
+    "gelateria":  "#D4537E",   # pink-400
+    "park":       "#639922",   # green-400
+    "viewpoint":  "#1D9E75",   # teal-400
+}
+
+# Colori speciali per elementi della mappa
+MAP_ROUTE_COLOR:     str = "#378ADD"   # polyline del percorso
+MAP_START_COLOR:     str = "#1D9E75"   # marker punto di partenza
+MAP_ARROW_COLOR:     str = "#5F5E5A"   # frecce di direzione
+
+# Opacità della polyline del percorso (0.0–1.0)
+MAP_ROUTE_OPACITY: float = 0.75
+
+# Spessore della polyline in pixel
+MAP_ROUTE_WEIGHT: int = 4
+
+# Raggio dei cerchi marker in pixel
+MAP_MARKER_RADIUS: int = 10
+
+# Zoom default sulla mappa al caricamento
+MAP_ZOOM_DEFAULT: int = 14
+
+# URL tiles OpenStreetMap (nessuna API key richiesta)
+MAP_TILE_URL: str = "https://{s}.tile.openstreetmap.org/{z}/{x}/{y}.png"
+MAP_TILE_ATTRIBUTION: str = (
+    '&copy; <a href="https://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors'
+)

core/__init__.py

@@ -0,0 +1,30 @@
+"""
+tour_generator_GA.core — Strutture dati e logica di valutazione del problema TOP-TW.
+
+Esporta le classi principali per comodità di importazione:
+    from tour_generator_GA.core import PoI, Individual, FitnessEvaluator, DistanceMatrix
+"""
+from .models import (
+    PoI,
+    PoICategory,
+    TimeWindow,
+    FitnessScore,
+    Individual,
+    TourSchedule,
+    ScheduledStop,
+)
+from .distance import DistanceMatrix, haversine_km
+from .fitness import FitnessEvaluator
+
+__all__ = [
+    "PoI",
+    "PoICategory",
+    "TimeWindow",
+    "FitnessScore",
+    "Individual",
+    "TourSchedule",
+    "ScheduledStop",
+    "DistanceMatrix",
+    "haversine_km",
+    "FitnessEvaluator",
+]

core/distance.py

@@ -0,0 +1,68 @@
+"""
+core/distance.py — Matrice delle distanze e tempi di percorrenza.
+Supporta Haversine (offline) e profilo turista per la velocità.
+"""
+from __future__ import annotations
+import math
+from typing import Union, Optional, TYPE_CHECKING
+from .models import PoI
+from config import ROUTE_DETOUR_FACTOR
+
+if TYPE_CHECKING:
+    from .profile import TouristProfile
+
+
+def haversine_km(lat1: float, lon1: float, lat2: float, lon2: float) -> float:
+    """Distanza geodetica tra due coordinate in chilometri."""
+    R = 6371.0
+    phi1, phi2 = math.radians(lat1), math.radians(lat2)
+    dphi       = math.radians(lat2 - lat1)
+    dlambda    = math.radians(lon2 - lon1)
+    a = math.sin(dphi/2)**2 + math.cos(phi1)*math.cos(phi2)*math.sin(dlambda/2)**2
+    return R * 2 * math.asin(math.sqrt(a))
+
+
+class DistanceMatrix:
+    """
+    Precalcola tutte le distanze tra i PoI (km).
+    I TEMPI vengono calcolati on-the-fly tramite il TouristProfile,
+    così un cambio di modalità non richiede di ricostruire la matrice.
+    """
+
+    def __init__(self, pois: list[PoI], profile: Optional["TouristProfile"] = None):
+        self.pois    = pois
+        self.profile = profile
+        self.idx     = {poi.id: i for i, poi in enumerate(pois)}
+        n            = len(pois)
+        self._dist   = [[0.0] * n for _ in range(n)]  # km (invariante)
+
+    def build(self):
+        """Popola la matrice delle distanze. Chiama una volta sola."""
+        for i, a in enumerate(self.pois):
+            for j, b in enumerate(self.pois):
+                if i == j:
+                    continue
+                km = haversine_km(a.lat, a.lon, b.lat, b.lon) * ROUTE_DETOUR_FACTOR
+                self._dist[i][j] = km
+
+    def dist(self, a: Union[PoI, str], b: Union[PoI, str]) -> float:
+        """Distanza in km tra due PoI."""
+        ia = self.idx[a.id if isinstance(a, PoI) else a]
+        ib = self.idx[b.id if isinstance(b, PoI) else b]
+        return self._dist[ia][ib]
+
+    def time(self, a: Union[PoI, str], b: Union[PoI, str]) -> int:
+        """Tempo di percorrenza in minuti, rispettando la modalità del profilo."""
+        km = self.dist(a, b)
+        return self._km_to_min(km)
+
+    def time_from_coord(self, lat: float, lon: float, poi: PoI) -> int:
+        """Tempo in minuti da coordinate arbitrarie (es. hotel) a un PoI."""
+        km = haversine_km(lat, lon, poi.lat, poi.lon) * ROUTE_DETOUR_FACTOR
+        return self._km_to_min(km)
+
+    def _km_to_min(self, km: float) -> int:
+        if self.profile is not None:
+            return self.profile.travel_time_min(km)
+        # Fallback sicuro: a piedi 4.5 km/h
+        return max(1, int((km / 4.5) * 60))

core/fitness.py

@@ -0,0 +1,165 @@
+"""
+core/fitness.py — Valutazione fitness multi-obiettivo con profilo turista.
+I tre obiettivi (score, distanza, tempo) vengono calcolati tenendo conto di:
+  - tag_weights del profilo → boost/malus per score effettivo
+  - transport_mode → velocità di spostamento corretta
+  - want_lunch / want_dinner → penalità se manca il ristorante atteso
+"""
+from __future__ import annotations
+from core.models import Individual, FitnessScore, TourSchedule, ScheduledStop, PoICategory
+from core.distance import DistanceMatrix
+from core.profile import TouristProfile
+from config import (W_SCORE, W_DIST, W_TIME, PENALTY_BUDGET_OVERRUN, PENALTY_MEAL_MISSING,
+                    GROUP_VISIT_OVERHEAD_PER_PERSON, ROUTE_DETOUR_FACTOR, MAX_DIST_TRANSIT_KM,
+                    FITNESS_UTILIZATION_BONUS_FACTOR,
+                    WAIT_PENALTY_FACTOR, SCORE_BOOST_CAP, MAX_DIST_WALK_KM)
+
+
+class FitnessEvaluator:
+
+    def __init__(
+        self,
+        dist_matrix:  DistanceMatrix,
+        profile:      TouristProfile,
+        start_time:   int,
+        budget:       int,
+        start_lat:    float,
+        start_lon:    float,
+        w_score:      float = W_SCORE,
+        w_dist:       float = W_DIST,
+        w_time:       float = W_TIME,
+        penalty:      float = PENALTY_BUDGET_OVERRUN,
+        meal_penalty: float = PENALTY_MEAL_MISSING,
+    ):
+        self.dm           = dist_matrix
+        self.profile      = profile
+        self.start_time   = start_time
+        self.budget       = budget
+        self.start_lat    = start_lat
+        self.start_lon    = start_lon
+        self.w_score      = w_score
+        self.w_dist       = w_dist
+        self.w_time       = w_time
+        self.penalty      = penalty
+        self.meal_penalty = meal_penalty
+
+    def decode(self, individual: Individual) -> TourSchedule:
+        if individual._schedule is not None:
+            return individual._schedule
+
+        schedule      = TourSchedule()
+        time_now      = self.start_time
+        prev_lat      = self.start_lat
+        prev_lon      = self.start_lon
+        total_dist_km = 0.0
+        total_wait_min = 0
+        feasible      = True
+
+        for poi in individual.genes:
+            km         = self._km(prev_lat, prev_lon, poi)
+            travel_min = self.profile.travel_time_min(km)
+            total_dist_km += km
+
+            arrival = time_now + travel_min
+
+            if arrival > poi.time_window.close:
+                feasible = False
+                wait = 0
+            else:
+                wait    = max(0, poi.time_window.open - arrival)
+                arrival = max(arrival, poi.time_window.open)
+
+            # Visita più lunga in gruppo: +5 min per persona extra
+            duration  = poi.visit_duration + max(0, self.profile.group_size - 1) * GROUP_VISIT_OVERHEAD_PER_PERSON
+            departure = arrival + duration
+            time_now  = departure
+            prev_lat  = poi.lat
+            prev_lon  = poi.lon
+            total_wait_min += wait   # accumula attese per penalità
+
+            schedule.stops.append(ScheduledStop(
+                poi=poi, arrival=arrival, departure=departure, wait=wait
+            ))
+
+        end_time = self.start_time + self.budget
+        schedule.total_time     = time_now - self.start_time
+        schedule.total_distance = round(total_dist_km, 2)
+        schedule.total_wait     = total_wait_min
+        schedule.is_feasible    = feasible and (time_now <= end_time)
+        individual._schedule    = schedule
+        return schedule
+
+    def evaluate(self, individual: Individual) -> FitnessScore:
+        schedule = self.decode(individual)
+        end_time = self.start_time + self.budget
+
+        # Score effettivo con boost da tag_weights del profilo
+        total_score = sum(
+            self.profile.effective_score(stop.poi)
+            for stop in schedule.stops
+        )
+
+        time_over         = max(0, (self.start_time + schedule.total_time) - end_time)
+        missing_meal_pen  = self._meal_coverage_penalty(schedule)
+
+        # Normalizzazione basata sui PoI AMMESSI dal profilo (non sul totale)
+        allowed_pois = [
+            p for p in self.dm.pois
+            if self.profile.allows_category(p.category.value)
+        ]
+        max_score = max(len(allowed_pois) * SCORE_BOOST_CAP, 1.0)
+        max_dist  = MAX_DIST_TRANSIT_KM if self.profile.transport_mode.value in ("car", "transit") else MAX_DIST_WALK_KM
+
+        norm_score  = total_score / max_score
+        norm_dist   = min(schedule.total_distance / max_dist, 1.0)
+        time_over_h = (time_over / 60) * self.penalty
+        # Penalizza attese eccessive (oltre 5 min totali)
+        total_wait   = getattr(schedule, 'total_wait', 0)
+        wait_penalty = max(0, (total_wait - 5) / 60) * WAIT_PENALTY_FACTOR
+        # Bonus per utilizzo del budget: incentiva tour più ricchi.
+        # Senza questo termine, il GA converge a tour corti (meno distanza).
+        # Il bonus cresce linearmente con i minuti usati, cappato al budget.
+        utilization_bonus = min(schedule.total_time, self.budget) / self.budget * self.w_score * FITNESS_UTILIZATION_BONUS_FACTOR
+
+        scalar = (
+            self.w_score * norm_score
+            + utilization_bonus         # premia l'uso del budget disponibile
+            - self.w_dist * norm_dist
+            - time_over_h
+            - wait_penalty
+            - missing_meal_pen
+        )
+
+        fitness = FitnessScore(
+            total_score    = round(total_score, 4),
+            total_distance = schedule.total_distance,
+            total_time     = schedule.total_time,
+            is_feasible    = schedule.is_feasible,
+            scalar         = round(scalar, 6),
+        )
+        individual.fitness = fitness
+        return fitness
+
+    def _meal_coverage_penalty(self, schedule: TourSchedule) -> float:
+        """
+        Penalità per ogni slot pasto richiesto dal profilo ma non coperto.
+        NON si applica se il profilo non include la categoria ristorante:
+        non ha senso penalizzare chi ha esplicitamente escluso i ristoranti.
+        """
+        if "restaurant" not in self.profile.allowed_categories:
+            return 0.0
+
+        penalty = 0.0
+        for (slot_open, slot_close) in self.profile.needs_meal_slot():
+            covered = any(
+                stop.poi.category == PoICategory.RESTAURANT
+                and slot_open <= stop.arrival <= slot_close
+                for stop in schedule.stops
+            )
+            if not covered:
+                penalty += self.meal_penalty
+        return penalty
+
+    def _km(self, lat: float, lon: float, poi) -> float:
+        from .distance import haversine_km
+        return haversine_km(lat, lon, poi.lat, poi.lon) * ROUTE_DETOUR_FACTOR

core/models.py

@@ -0,0 +1,135 @@
+"""
+core/models.py — Strutture dati fondamentali per il TOP-TW turistico.
+"""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+import math
+
+
+class PoICategory(Enum):
+    MUSEUM     = "museum"
+    MONUMENT   = "monument"
+    RESTAURANT = "restaurant"   # pranzo / cena formale
+    BAR        = "bar"          # caffè, aperitivo, sosta breve
+    GELATERIA  = "gelateria"    # sosta dolce pomeridiana
+    PARK       = "park"
+    VIEWPOINT  = "viewpoint"
+
+
+@dataclass
+class TimeWindow:
+    open:  int   # minuti dalla mezzanotte (es. 540 = 09:00)
+    close: int   # minuti dalla mezzanotte (es. 1080 = 18:00)
+
+    def __repr__(self) -> str:
+        return f"{self.open//60:02d}:{self.open%60:02d}–{self.close//60:02d}:{self.close%60:02d}"
+
+
+@dataclass
+class PoI:
+    id:             str
+    name:           str
+    lat:            float
+    lon:            float
+    score:          float          # interesse normalizzato [0, 1]
+    visit_duration: int            # minuti di visita stimati
+    time_window:    TimeWindow
+    category:       PoICategory
+    tags:           list[str]      = field(default_factory=list)
+
+    def __hash__(self):
+        return hash(self.id)
+
+    def __eq__(self, other):
+        return isinstance(other, PoI) and self.id == other.id
+
+    def __repr__(self):
+        return f"PoI({self.name!r}, score={self.score:.2f}, {self.time_window})"
+
+
+@dataclass
+class FitnessScore:
+    total_score:    float = 0.0   # somma score PoI visitati
+    total_distance: float = 0.0   # km totali percorsi
+    total_time:     int   = 0     # minuti totali (spostamenti + visite)
+    is_feasible:    bool  = False  # rispetta TW e budget?
+    scalar:         float = 0.0   # valore aggregato per confronti rapidi
+    rank:           int   = 0     # rango Pareto (NSGA-II)
+    crowd:          float = 0.0   # crowding distance (NSGA-II)
+
+    def dominates(self, other: FitnessScore) -> bool:
+        """
+        self domina other se è ≥ su tutti gli obiettivi e > su almeno uno.
+        Obiettivi: massimizza score, minimizza distance, minimizza time.
+        """
+        better_or_equal = (
+            self.total_score    >= other.total_score and
+            self.total_distance <= other.total_distance and
+            self.total_time     <= other.total_time
+        )
+        strictly_better = (
+            self.total_score    > other.total_score or
+            self.total_distance < other.total_distance or
+            self.total_time     < other.total_time
+        )
+        return better_or_equal and strictly_better
+
+
+@dataclass
+class ScheduledStop:
+    poi:         PoI
+    arrival:     int   # minuti dalla mezzanotte
+    departure:   int   # minuti dalla mezzanotte
+    wait:        int   # minuti di attesa prima dell'apertura
+
+
+@dataclass
+class TourSchedule:
+    stops:          list[ScheduledStop] = field(default_factory=list)
+    total_time:     int   = 0
+    total_distance: float = 0.0
+    total_wait:     int   = 0    # minuti di attesa cumulati (attese a TW)
+    is_feasible:    bool  = False
+
+    def summary(self) -> str:
+        lines = []
+        for s in self.stops:
+            a = f"{s.arrival//60:02d}:{s.arrival%60:02d}"
+            d = f"{s.departure//60:02d}:{s.departure%60:02d}"
+            w = f" (attesa {s.wait} min)" if s.wait > 0 else ""
+            lines.append(f"  {a}–{d}  {s.poi.name}{w}")
+        wait_note = f", attese {self.total_wait} min" if self.total_wait > 0 else ""
+        lines.append(
+            f"  Totale: {self.total_time} min, "
+            f"{self.total_distance:.1f} km{wait_note}"
+        )
+        return "\n".join(lines)
+
+
+class Individual:
+    """
+    Cromosoma = lista ordinata di PoI che compongono il tour.
+    Il gene jolly (WildcardGene) è un placeholder che viene
+    materializzato al momento della decodifica.
+    """
+
+    def __init__(self, genes: list[PoI]):
+        self.genes:    list[PoI]        = genes
+        self.fitness:  FitnessScore     = FitnessScore()
+        self._schedule: Optional[TourSchedule] = None  # cache
+
+    def clone(self) -> Individual:
+        return Individual(genes=list(self.genes))
+
+    def invalidate_cache(self):
+        self._schedule = None
+        self.fitness   = FitnessScore()
+
+    def __len__(self):
+        return len(self.genes)
+
+    def __repr__(self):
+        names = [p.name for p in self.genes]
+        return f"Individual([{', '.join(names)}], scalar={self.fitness.scalar:.3f})"

core/profile.py

@@ -0,0 +1,275 @@
+"""
+core/profile.py — Profilo del turista con tutte le preferenze personali.
+È l'oggetto centrale che attraversa TUTTO il pipeline GA:
+  DistanceMatrix → velocità di spostamento per modalità
+  GreedySeeder   → whitelist categorie + slot pasto garantito
+  RepairEngine   → blacklist categorie + rimozione violazioni profilo
+  FitnessEvaluator → boost/malus score per tag di interesse
+  GeneticOperators → add/remove usa solo PoI ammessi dal profilo
+"""
+from __future__ import annotations
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Optional
+from config import (MIXED_THRESHOLD_M, TRANSIT_WALK_THRESHOLD_KM, SCORE_BOOST_CAP,
+                    TRANSIT_OVERHEAD_MIN, CAR_OVERHEAD_MIN, SPEED_KMH,
+                    MIXED_LONG_SPEED_KMH, WANT_LUNCH, WANT_DINNER, LUNCH_TIME,
+                    DINNER_TIME, MEAL_WINDOW, MAX_BAR_STOPS, MAX_GELATERIA_STOPS)
+
+
+class TransportMode(Enum):
+    WALK    = "walk"      # tutto a piedi (centro storico)
+    CAR     = "car"       # auto / taxi
+    TRANSIT = "transit"   # bus + metro
+    MIXED   = "mixed"     # a piedi <MIXED_THRESHOLD_M, transit/auto oltre
+
+
+class MobilityLevel(Enum):
+    NORMAL  = "normal"    # nessuna limitazione
+    LIMITED = "limited"   # difficoltà con scale, distanze lunghe → penalizza PoI lontani
+
+
+# Soglia in metri sotto la quale si va a piedi anche in modalità MIXED
+#MIXED_THRESHOLD_M = 600
+
+# Soglia al di sotto della quale, anche in modalità TRANSIT, si cammina:
+# prendere un mezzo per 300m è spesso più lento che andare a piedi.
+#TRANSIT_WALK_THRESHOLD_KM = 0.40
+
+# Overhead fisso per ogni tratta in mezzo pubblico (minuti):
+# comprende cammino alla fermata + attesa + cammino dalla fermata.
+# Roma: metro ha frequenza ~5 min, bus ~8-12 min → media ~10 min overhead.
+#TRANSIT_OVERHEAD_MIN = 10
+
+# Overhead per auto/taxi: parcheggio + spostamento a piedi dal parcheggio.
+#CAR_OVERHEAD_MIN = 5
+
+# Velocità medie di percorrenza (escluso overhead)
+# SPEED_TABLE: dict[tuple[TransportMode, MobilityLevel], float] = {
+#     (TransportMode.WALK,    MobilityLevel.NORMAL):  4.5,
+#     (TransportMode.WALK,    MobilityLevel.LIMITED): 3.0,
+#     (TransportMode.CAR,     MobilityLevel.NORMAL):  25.0,
+#     (TransportMode.CAR,     MobilityLevel.LIMITED): 25.0,
+#     (TransportMode.TRANSIT, MobilityLevel.NORMAL):  20.0,  # velocità effettiva metro/bus Roma
+#     (TransportMode.TRANSIT, MobilityLevel.LIMITED): 16.0,
+#     (TransportMode.MIXED,   MobilityLevel.NORMAL):  4.5,   # usata per segmenti brevi
+#     (TransportMode.MIXED,   MobilityLevel.LIMITED): 3.0,
+# }
+
+# MIXED_LONG_SPEED: dict[MobilityLevel, float] = {
+#     MobilityLevel.NORMAL:  20.0,
+#     MobilityLevel.LIMITED: 16.0,
+# }
+
+
+@dataclass
+class TouristProfile:
+    """
+    Preferenze complete del turista.
+    Tutti i campi hanno un default sensato per un turista generico.
+    """
+
+    # --- Trasporto ---
+    transport_mode: TransportMode = TransportMode.WALK
+    mobility:       MobilityLevel = MobilityLevel.NORMAL
+
+    # --- Categorie ammesse ---
+    # Se una categoria non è in questa lista, i suoi PoI vengono
+    # completamente ignorati in seeding, repair e mutation.
+    allowed_categories: list[str] = field(default_factory=lambda: [
+        "museum", "monument", "restaurant", "park", "viewpoint"
+    ])
+
+    # --- Preferenze pasti ---
+    want_lunch:  bool = WANT_LUNCH
+    want_dinner: bool = WANT_DINNER
+    lunch_time:  int  = LUNCH_TIME
+    dinner_time: int  = DINNER_TIME
+    meal_window: int  = MEAL_WINDOW
+
+    # --- Soste snack (bar, gelateria) ---
+    # Numero massimo di soste snack per tipo nel tour.
+    # None = nessun limite (utile per profili food-focused).
+    max_bar_stops:       int = MAX_BAR_STOPS
+    max_gelateria_stops: int = MAX_GELATERIA_STOPS
+
+    # --- Interessi tematici (tag) ---
+    # Ogni tag elencato riceve un boost moltiplicativo allo score del PoI.
+    # Es. {"arte": 1.5, "antico": 1.3} → i musei d'arte valgono 50% di più.
+    tag_weights: dict[str, float] = field(default_factory=dict)
+
+    # --- Budget economico ---
+    max_entry_fee: Optional[float] = None   # euro; None = nessun limite
+
+    # --- Gruppo ---
+    group_size: int = 1   # utile per entry fee totale e ritmo di visita
+
+    def __post_init__(self):
+        # Normalizza le categorie in minuscolo
+        self.allowed_categories = [c.lower() for c in self.allowed_categories]
+            # Coerci transport_mode da stringa a enum se necessario
+        if isinstance(self.transport_mode, str):
+            self.transport_mode = TransportMode(self.transport_mode.lower())
+
+        # Coerci mobility da stringa a enum se necessario
+        if isinstance(self.mobility, str):
+            self.mobility = MobilityLevel(self.mobility.lower())
+
+    def allows_category(self, category_value: str) -> bool:
+        """Restituisce True se la categoria è ammessa dal profilo."""
+        return category_value.lower() in self.allowed_categories
+
+    def effective_score(self, poi) -> float:
+        """
+        Score del PoI moltiplicato per i boost dei tag di interesse.
+        Un PoI senza tag corrispondenti mantiene lo score base.
+        """
+        boost = 1.0
+        for tag in poi.tags:
+            if tag in self.tag_weights:
+                boost += self.tag_weights[tag] - 1.0  # additive boost
+        return min(poi.score * boost, SCORE_BOOST_CAP)  
+    
+    def travel_speed_kmh(self, dist_km: float) -> float:
+        """Velocità di percorrenza pura (senza overhead fisso)."""
+        if self.transport_mode == TransportMode.MIXED:
+            dist_m = dist_km * 1000
+            if dist_m <= MIXED_THRESHOLD_M:
+                return SPEED_KMH[(TransportMode.WALK.value, self.mobility.value)]
+            else:
+                return MIXED_LONG_SPEED_KMH[self.mobility]
+        return SPEED_KMH.get((self.transport_mode.value, self.mobility.value))
+
+    def travel_time_min(self, dist_km: float) -> int:
+        """
+        Tempo di percorrenza realistico in minuti.
+
+        Modello per modalità:
+          WALK    → dist / v_walk
+          CAR     → dist / v_car  + CAR_OVERHEAD (parcheggio)
+          TRANSIT → se dist < soglia: a piedi (prendere il mezzo non conviene)
+                    altrimenti: dist / v_transit + TRANSIT_OVERHEAD (attesa + fermata)
+          MIXED   → a piedi se dist < MIXED_THRESHOLD, altrimenti come TRANSIT
+        """
+        mode = self.transport_mode
+        walk_speed = SPEED_KMH[(TransportMode.WALK.value, self.mobility.value)]
+
+        if mode == TransportMode.WALK:
+            return max(1, int((dist_km / walk_speed) * 60))
+
+        if mode == TransportMode.CAR:
+            speed = SPEED_KMH.get((TransportMode.CAR.value, self.mobility.value))
+            return max(3, int((dist_km / speed) * 60) + CAR_OVERHEAD_MIN)
+
+        if mode == TransportMode.TRANSIT:
+            if dist_km < TRANSIT_WALK_THRESHOLD_KM:
+                # Distanza troppo corta: a piedi è più veloce del mezzo
+                return max(1, int((dist_km / walk_speed) * 60))
+            speed = SPEED_KMH[(TransportMode.TRANSIT.value, self.mobility.value)]
+            ride  = int((dist_km / speed) * 60)
+            return ride + TRANSIT_OVERHEAD_MIN
+
+        if mode == TransportMode.MIXED:
+            dist_m = dist_km * 1000
+            if dist_m <= MIXED_THRESHOLD_M:
+                return max(1, int((dist_km / walk_speed) * 60))
+            long_speed = MIXED_LONG_SPEED_KMH[self.mobility.value]
+            ride = int((dist_km / long_speed) * 60)
+            return ride + TRANSIT_OVERHEAD_MIN
+
+        # Fallback
+        return max(1, int((dist_km / walk_speed) * 60))
+
+    def needs_meal_slot(self) -> list[tuple[int, int]]:
+        """
+        Restituisce la lista di finestre temporali in cui il profilo
+        richiede un ristorante nel tour.
+        Es. [(660, 780), (1080, 1200)] per pranzo+cena.
+        """
+        slots = []
+        if self.want_lunch:
+            slots.append((
+                self.lunch_time - self.meal_window,
+                self.lunch_time + self.meal_window
+            ))
+        if self.want_dinner:
+            slots.append((
+                self.dinner_time - self.meal_window,
+                self.dinner_time + self.meal_window
+            ))
+        return slots
+
+    def summary(self) -> str:
+        lines = [
+            f"Trasporto : {self.transport_mode.value}  |  Mobilità: {self.mobility.value}",
+            f"Categorie : {', '.join(self.allowed_categories)}",
+            f"Pranzo    : {'sì (' + str(self.lunch_time//60) + ':00)' if self.want_lunch else 'no'}  |  "
+            f"Cena: {'sì (' + str(self.dinner_time//60) + ':00)' if self.want_dinner else 'no'}",
+        ]
+        if self.tag_weights:
+            tw = ", ".join(f"{k}×{v}" for k, v in self.tag_weights.items())
+            lines.append(f"Interessi : {tw}")
+        if self.max_entry_fee is not None:
+            lines.append(f"Budget biglietti: €{self.max_entry_fee:.0f} max a PoI")
+        return "\n".join(lines)
+
+
+# ---------------------------------------------------------------------------
+# Factory: profili predefiniti pronti all'uso
+# ---------------------------------------------------------------------------
+#TODO: rivedere la definizione di tutti i profili e i pesi, facendo attenzione alle allowed_categories e alle tag_weights per coerenza interna.
+def profile_cultural_walker() -> TouristProfile:
+    """Turista culturale a piedi, interessato ad arte e storia. Include una sosta pranzo."""
+    return TouristProfile(
+        transport_mode     = TransportMode.WALK,
+        allowed_categories = ["museum", "monument", "viewpoint", "restaurant", "bar", "gelateria"],
+        want_lunch         = True,
+        want_dinner        = False,
+        tag_weights        = {"arte": 1.4, "antico": 1.3, "rinascimento": 1.5, "unesco": 1.2},
+        max_bar_stops      = 1,
+        max_gelateria_stops= 1
+    )
+
+
+def profile_foodie_transit() -> TouristProfile:
+    """Turista gastronomico con mezzi pubblici, ristoranti inclusi."""
+    return TouristProfile(
+        transport_mode     = TransportMode.TRANSIT,
+        allowed_categories = ["restaurant", "monument", "bar", "gelateria", "viewpoint", "park"],
+        want_lunch         = True,
+        want_dinner        = True,
+        tag_weights        = {"cucina_romana": 1.6, "offal": 0.5, "vivace": 1.2},
+        max_bar_stops      = 2,
+        max_gelateria_stops= 2
+    )
+
+
+def profile_family_mixed() -> TouristProfile:
+    """Famiglia con bambini: percorso misto, evita musei pesanti."""
+    return TouristProfile(
+        transport_mode     = TransportMode.MIXED,
+        mobility           = MobilityLevel.LIMITED,
+        allowed_categories = ["monument", "park", "viewpoint", "restaurant", "bar", "gelateria"],
+        want_lunch         = True,
+        want_dinner        = False,
+        group_size         = 4,
+        tag_weights        = {"fotogenico": 1.3, "vivace": 1.2},
+        max_entry_fee      = 15.0,
+        max_bar_stops      = 1,
+        max_gelateria_stops= 1
+    )
+
+
+def profile_art_lover_car() -> TouristProfile:
+    """Appassionato d'arte con auto: vuole visitare musei anche lontani."""
+    return TouristProfile(
+        transport_mode     = TransportMode.CAR,
+        allowed_categories = ["museum", "monument", "bar", "gelateria"],
+        want_lunch         = True,
+        want_dinner        = False,
+        tag_weights        = {"arte": 1.6, "scultura": 1.5, "rinascimento": 1.4, "antico": 1.1},
+        max_entry_fee      = 30.0,
+        max_bar_stops      = 1,
+        max_gelateria_stops= 1
+        
+    )

data/custom_profile.json

@@ -0,0 +1,25 @@
+{
+"transport_mode":"MIXED",
+"mobility":"NORMAL",
+"allowed_categories":[
+"monument",
+"park",
+"viewpoint",
+"restaurant",
+"bar",
+"gelateria"
+],
+"want_lunch":true,
+"want_dinner":true,
+"lunch_time":720,
+"dinner_time":1230,
+"meal_window":90,
+"max_bar_stops":2,
+"max_gelateria_stops":1,
+"tag_weights":{
+"fotogenico":1.3,
+"vivace":1.2
+},
+"max_entry_fee":15,
+"group_size":4
+}

data/pois.json

@@ -0,0 +1,475 @@
+[
+  {
+    "id": "colosseo",
+    "name": "Colosseo",
+    "lat": 41.8902,
+    "lon": 12.4922,
+    "score": 0.98,
+    "visit_duration": 120,
+    "time_window": { "open": 540, "close": 1110 },
+    "category": "monument",
+    "tags": ["antico", "unesco"]
+  },
+  {
+    "id": "foro",
+    "name": "Foro Romano",
+    "lat": 41.8925,
+    "lon": 12.4853,
+    "score": 0.9,
+    "visit_duration": 90,
+    "time_window": { "open": 540, "close": 1110 },
+    "category": "monument",
+    "tags": ["antico"]
+  },
+  {
+    "id": "vaticano",
+    "name": "Musei Vaticani",
+    "lat": 41.9065,
+    "lon": 12.4534,
+    "score": 0.97,
+    "visit_duration": 180,
+    "time_window": { "open": 540, "close": 1080 },
+    "category": "museum",
+    "tags": ["arte", "unesco"]
+  },
+  {
+    "id": "sistina",
+    "name": "Cappella Sistina",
+    "lat": 41.9029,
+    "lon": 12.4545,
+    "score": 0.96,
+    "visit_duration": 60,
+    "time_window": { "open": 540, "close": 1080 },
+    "category": "museum",
+    "tags": ["arte", "rinascimento"]
+  },
+  {
+    "id": "pantheon",
+    "name": "Pantheon",
+    "lat": 41.8986,
+    "lon": 12.4769,
+    "score": 0.93,
+    "visit_duration": 60,
+    "time_window": { "open": 540, "close": 1140 },
+    "category": "monument",
+    "tags": ["antico", "architettura"]
+  },
+  {
+    "id": "trevi",
+    "name": "Fontana di Trevi",
+    "lat": 41.9009,
+    "lon": 12.4833,
+    "score": 0.88,
+    "visit_duration": 30,
+    "time_window": { "open": 0, "close": 1440 },
+    "category": "monument",
+    "tags": ["barocco", "fotogenico"]
+  },
+  {
+    "id": "spagna",
+    "name": "Piazza di Spagna",
+    "lat": 41.9059,
+    "lon": 12.4823,
+    "score": 0.8,
+    "visit_duration": 30,
+    "time_window": { "open": 0, "close": 1440 },
+    "category": "viewpoint",
+    "tags": ["shopping", "fotogenico"]
+  },
+  {
+    "id": "borghese",
+    "name": "Galleria Borghese",
+    "lat": 41.9143,
+    "lon": 12.4923,
+    "score": 0.92,
+    "visit_duration": 120,
+    "time_window": { "open": 540, "close": 1140 },
+    "category": "museum",
+    "tags": ["arte", "scultura"]
+  },
+  {
+    "id": "navona",
+    "name": "Piazza Navona",
+    "lat": 41.8992,
+    "lon": 12.4731,
+    "score": 0.85,
+    "visit_duration": 45,
+    "time_window": { "open": 0, "close": 1440 },
+    "category": "viewpoint",
+    "tags": ["barocco", "fotogenico"]
+  },
+  {
+    "id": "trastevere",
+    "name": "Trastevere",
+    "lat": 41.8897,
+    "lon": 12.4703,
+    "score": 0.82,
+    "visit_duration": 90,
+    "time_window": { "open": 600, "close": 1380 },
+    "category": "viewpoint",
+    "tags": ["quartiere", "fotogenico"]
+  },
+  {
+    "id": "castel",
+    "name": "Castel Sant'Angelo",
+    "lat": 41.9031,
+    "lon": 12.4663,
+    "score": 0.83,
+    "visit_duration": 90,
+    "time_window": { "open": 540, "close": 1080 },
+    "category": "monument",
+    "tags": ["medievale", "panorama"]
+  },
+  {
+    "id": "aventino",
+    "name": "Giardino degli Aranci",
+    "lat": 41.8837,
+    "lon": 12.4793,
+    "score": 0.75,
+    "visit_duration": 40,
+    "time_window": { "open": 480, "close": 1200 },
+    "category": "park",
+    "tags": ["panorama", "fotogenico"]
+  },
+  {
+    "id": "terme",
+    "name": "Terme di Caracalla",
+    "lat": 41.8788,
+    "lon": 12.4924,
+    "score": 0.78,
+    "visit_duration": 75,
+    "time_window": { "open": 540, "close": 1080 },
+    "category": "monument",
+    "tags": ["antico"]
+  },
+  {
+    "id": "rist_rione",
+    "name": "Osteria del Rione",
+    "lat": 41.8962,
+    "lon": 12.4751,
+    "score": 0.74,
+    "visit_duration": 60,
+    "time_window": { "open": 720, "close": 900 },
+    "category": "restaurant",
+    "tags": ["cucina_romana"]
+  },
+  {
+    "id": "rist_prati",
+    "name": "Trattoria Prati",
+    "lat": 41.9042,
+    "lon": 12.4601,
+    "score": 0.7,
+    "visit_duration": 75,
+    "time_window": { "open": 720, "close": 900 },
+    "category": "restaurant",
+    "tags": ["cucina_romana"]
+  },
+  {
+    "id": "rist_testac",
+    "name": "Testaccio da Mario",
+    "lat": 41.8792,
+    "lon": 12.477,
+    "score": 0.76,
+    "visit_duration": 70,
+    "time_window": { "open": 720, "close": 900 },
+    "category": "restaurant",
+    "tags": ["offal", "cucina_romana"]
+  },
+  {
+    "id": "rist_cena1",
+    "name": "Ristorante San Pietro",
+    "lat": 41.905,
+    "lon": 12.458,
+    "score": 0.72,
+    "visit_duration": 80,
+    "time_window": { "open": 1140, "close": 1320 },
+    "category": "restaurant",
+    "tags": ["cucina_romana"]
+  },
+  {
+    "id": "rist_cena2",
+    "name": "Da Enzo al 29",
+    "lat": 41.8891,
+    "lon": 12.4697,
+    "score": 0.78,
+    "visit_duration": 90,
+    "time_window": { "open": 1140, "close": 1320 },
+    "category": "restaurant",
+    "tags": ["cucina_romana", "trastevere"]
+  },
+  {
+    "id": "bar_greco",
+    "name": "Caffè Greco",
+    "lat": 41.9057,
+    "lon": 12.4818,
+    "score": 0.72,
+    "visit_duration": 20,
+    "time_window": { "open": 480, "close": 1320 },
+    "category": "bar",
+    "tags": ["storico", "caffe"]
+  },
+  {
+    "id": "bar_sant",
+    "name": "Sant'Eustachio il Caffè",
+    "lat": 41.899,
+    "lon": 12.4752,
+    "score": 0.75,
+    "visit_duration": 20,
+    "time_window": { "open": 480, "close": 1380 },
+    "category": "bar",
+    "tags": ["caffe", "storico"]
+  },
+  {
+    "id": "bar_campo",
+    "name": "Bar del Fico",
+    "lat": 41.8968,
+    "lon": 12.472,
+    "score": 0.65,
+    "visit_duration": 25,
+    "time_window": { "open": 600, "close": 1380 },
+    "category": "bar",
+    "tags": ["aperitivo", "vivace"]
+  },
+  {
+    "id": "gel_fatamorgana",
+    "name": "Fatamorgana",
+    "lat": 41.8993,
+    "lon": 12.4729,
+    "score": 0.7,
+    "visit_duration": 20,
+    "time_window": { "open": 660, "close": 1200 },
+    "category": "gelateria",
+    "tags": ["artigianale", "insolito"]
+  },
+  {
+    "id": "gel_giolitti",
+    "name": "Giolitti",
+    "lat": 41.9003,
+    "lon": 12.4765,
+    "score": 0.68,
+    "visit_duration": 20,
+    "time_window": { "open": 660, "close": 1260 },
+    "category": "gelateria",
+    "tags": ["storico", "classico"]
+  },
+  {
+    "id": "capitolini",
+    "name": "Musei Capitolini",
+    "lat": 41.8933,
+    "lon": 12.4839,
+    "score": 0.94,
+    "visit_duration": 120,
+    "time_window": { "open": 570, "close": 1170 },
+    "category": "museum",
+    "tags": ["arte", "storia_romana", "panorama"]
+  },
+  {
+    "id": "ara_pacis",
+    "name": "Ara Pacis",
+    "lat": 41.9061,
+    "lon": 12.4748,
+    "score": 0.85,
+    "visit_duration": 60,
+    "time_window": { "open": 540, "close": 1140 },
+    "category": "museum",
+    "tags": ["antico", "architettura"]
+  },
+  {
+    "id": "laterano",
+    "name": "San Giovanni in Laterano",
+    "lat": 41.8859,
+    "lon": 12.5057,
+    "score": 0.88,
+    "visit_duration": 60,
+    "time_window": { "open": 420, "close": 1110 },
+    "category": "monument",
+    "tags": ["chiesa", "barocco"]
+  },
+  {
+    "id": "maggiore",
+    "name": "Santa Maria Maggiore",
+    "lat": 41.8975,
+    "lon": 12.4985,
+    "score": 0.89,
+    "visit_duration": 60,
+    "time_window": { "open": 420, "close": 1140 },
+    "category": "monument",
+    "tags": ["chiesa", "mosaici"]
+  },
+  {
+    "id": "catacombe",
+    "name": "Catacombe di San Callisto",
+    "lat": 41.8587,
+    "lon": 12.5108,
+    "score": 0.82,
+    "visit_duration": 75,
+    "time_window": { "open": 540, "close": 1020 },
+    "category": "monument",
+    "tags": ["antico", "sotterraneo"]
+  },
+  {
+    "id": "coppede",
+    "name": "Quartiere Coppedè",
+    "lat": 41.9189,
+    "lon": 12.5011,
+    "score": 0.78,
+    "visit_duration": 45,
+    "time_window": { "open": 0, "close": 1440 },
+    "category": "viewpoint",
+    "tags": ["liberty", "architettura"]
+  },
+  {
+    "id": "garbatella",
+    "name": "Garbatella",
+    "lat": 41.8615,
+    "lon": 12.4891,
+    "score": 0.76,
+    "visit_duration": 90,
+    "time_window": { "open": 0, "close": 1440 },
+    "category": "viewpoint",
+    "tags": ["quartiere", "popolare"]
+  },
+  {
+    "id": "monti",
+    "name": "Rione Monti",
+    "lat": 41.8947,
+    "lon": 12.4901,
+    "score": 0.82,
+    "visit_duration": 90,
+    "time_window": { "open": 600, "close": 1440 },
+    "category": "viewpoint",
+    "tags": ["quartiere", "artigianato"]
+  },
+  {
+    "id": "piramide",
+    "name": "Piramide Cestia",
+    "lat": 41.8765,
+    "lon": 12.4808,
+    "score": 0.74,
+    "visit_duration": 30,
+    "time_window": { "open": 540, "close": 1140 },
+    "category": "monument",
+    "tags": ["antico", "egizio"]
+  },
+  {
+    "id": "san_paolo",
+    "name": "San Paolo fuori le Mura",
+    "lat": 41.8587,
+    "lon": 12.4768,
+    "score": 0.86,
+    "visit_duration": 70,
+    "time_window": { "open": 420, "close": 1140 },
+    "category": "monument",
+    "tags": ["unesco", "chiesa"]
+  },
+  {
+    "id": "doria_pamphilj",
+    "name": "Palazzo Doria Pamphilj",
+    "lat": 41.8978,
+    "lon": 12.4815,
+    "score": 0.87,
+    "visit_duration": 100,
+    "time_window": { "open": 540, "close": 1140 },
+    "category": "museum",
+    "tags": ["arte", "palazzo"]
+  },
+  {
+    "id": "luigi_francesi",
+    "name": "San Luigi dei Francesi",
+    "lat": 41.8996,
+    "lon": 12.4747,
+    "score": 0.84,
+    "visit_duration": 30,
+    "time_window": { "open": 570, "close": 1140 },
+    "category": "monument",
+    "tags": ["caravaggio", "barocco"]
+  },
+  {
+    "id": "orto_botanico",
+    "name": "Orto Botanico",
+    "lat": 41.8929,
+    "lon": 12.4633,
+    "score": 0.79,
+    "visit_duration": 90,
+    "time_window": { "open": 540, "close": 1110 },
+    "category": "park",
+    "tags": ["natura", "trastevere"]
+  },
+  {
+    "id": "villa_torlonia",
+    "name": "Villa Torlonia",
+    "lat": 41.9138,
+    "lon": 12.5117,
+    "score": 0.77,
+    "visit_duration": 100,
+    "time_window": { "open": 540, "close": 1140 },
+    "category": "park",
+    "tags": ["storia", "giardino"]
+  },
+  {
+    "id": "rist_felice",
+    "name": "Felice a Testaccio",
+    "lat": 41.8795,
+    "lon": 12.4783,
+    "score": 0.9,
+    "visit_duration": 90,
+    "time_window": { "open": 1140, "close": 1380 },
+    "category": "restaurant",
+    "tags": ["cacio_e_pepe", "testaccio"]
+  },
+  {
+    "id": "rist_roscioli",
+    "name": "Roscioli Salumeria",
+    "lat": 41.8943,
+    "lon": 12.4741,
+    "score": 0.89,
+    "visit_duration": 90,
+    "time_window": { "open": 720, "close": 960 },
+    "category": "restaurant",
+    "tags": ["carbonara", "gourmet"]
+  },
+  {
+    "id": "rist_bonci",
+    "name": "Pizzarium Bonci",
+    "lat": 41.9075,
+    "lon": 12.4507,
+    "score": 0.88,
+    "visit_duration": 30,
+    "time_window": { "open": 660, "close": 1320 },
+    "category": "restaurant",
+    "tags": ["pizza_al_taglio", "street_food"]
+  },
+  {
+    "id": "bar_pompi",
+    "name": "Pompi Tiramisù",
+    "lat": 41.8831,
+    "lon": 12.5111,
+    "score": 0.85,
+    "visit_duration": 20,
+    "time_window": { "open": 600, "close": 1440 },
+    "category": "bar",
+    "tags": ["dolce", "tiramisu"]
+  },
+  {
+    "id": "gel_neve",
+    "name": "Neve di Latte",
+    "lat": 41.9272,
+    "lon": 12.4648,
+    "score": 0.86,
+    "visit_duration": 20,
+    "time_window": { "open": 720, "close": 1320 },
+    "category": "gelateria",
+    "tags": ["artigianale", "gourmet"]
+  },
+  {
+    "id": "pincio",
+    "name": "Terrazza del Pincio",
+    "lat": 41.9114,
+    "lon": 12.4795,
+    "score": 0.91,
+    "visit_duration": 30,
+    "time_window": { "open": 0, "close": 1440 },
+    "category": "viewpoint",
+    "tags": ["panorama", "fotogenico"]
+  }
+]

data/tour_results

@@ -0,0 +1,3 @@
+{"timestamp": "2026-03-25 01:39:09.552542", "profile": "family_mixed", "budget": 600, "start_time": 570, "start_lat": 41.9028, "start_lon": 12.4964, "result": {"total_distance": 7.3, "total_time": 532, "is_feasible": true, "stops": [{"poi_id": "trevi", "poi_name": "Fontana di Trevi", "arrival": 585, "departure": 630, "wait": 0}, {"poi_id": "navona", "poi_name": "Piazza Navona", "arrival": 644, "departure": 704, "wait": 0}, {"poi_id": "rist_roscioli", "poi_name": "Roscioli Salumeria", "arrival": 720, "departure": 825, "wait": 4}, {"poi_id": "bar_sant", "poi_name": "Sant'Eustachio il Caffè", "arrival": 837, "departure": 872, "wait": 0}, {"poi_id": "pantheon", "poi_name": "Pantheon", "arrival": 875, "departure": 950, "wait": 0}, {"poi_id": "luigi_francesi", "poi_name": "San Luigi dei Francesi", "arrival": 955, "departure": 1000, "wait": 0}, {"poi_id": "gel_fatamorgana", "poi_name": "Fatamorgana", "arrival": 1003, "departure": 1038, "wait": 0}, {"poi_id": "rist_bonci", "poi_name": "Pizzarium Bonci", "arrival": 1057, "departure": 1102, "wait": 0}]}}
+{"timestamp": "2026-03-25 02:02:36.908968", "profile": "family_mixed", "budget": 780, "start_time": 450, "start_lat": 41.9028, "start_lon": 12.4964, "result": {"total_score": 6.449, "total_distance": 5.0, "total_time": 435, "is_feasible": true, "stops": [{"poi_id": "trevi", "poi_name": "Fontana di Trevi", "arrival": 465, "departure": 510, "wait": 0, "travel_distance_km": 1.1, "travel_time_min": 14}, {"poi_id": "spagna", "poi_name": "Piazza di Spagna", "arrival": 522, "departure": 567, "wait": 0, "travel_distance_km": 0.0, "travel_time_min": 1}, {"poi_id": "navona", "poi_name": "Piazza Navona", "arrival": 582, "departure": 642, "wait": 0, "travel_distance_km": 0.0, "travel_time_min": 1}, {"poi_id": "bar_sant", "poi_name": "Sant'Eustachio il Caffè", "arrival": 646, "departure": 681, "wait": 0, "travel_distance_km": 0.0, "travel_time_min": 1}, {"poi_id": "luigi_francesi", "poi_name": "San Luigi dei Francesi", "arrival": 683, "departure": 728, "wait": 0, "travel_distance_km": 0.0, "travel_time_min": 1}, {"poi_id": "gel_giolitti", "poi_name": "Giolitti", "arrival": 732, "departure": 767, "wait": 0, "travel_distance_km": 0.0, "travel_time_min": 1}, {"poi_id": "rist_roscioli", "poi_name": "Roscioli Salumeria", "arrival": 780, "departure": 885, "wait": 0, "travel_distance_km": 0.0, "travel_time_min": 1}]}}
+{"timestamp": "2026-03-25 02:08:10.347900", "profile": "family_mixed", "budget": 780, "start_time": 450, "start_lat": 41.9028, "start_lon": 12.4964, "result": {"total_score": 5.659, "total_distance": 4.03, "total_time": 418, "is_feasible": true, "stops": [{"poi_id": "trevi", "poi_name": "Fontana di Trevi", "arrival": 465, "departure": 510, "wait": 0, "travel_distance_km": 1.1, "travel_time_min": 14}, {"poi_id": "navona", "poi_name": "Piazza Navona", "arrival": 524, "departure": 584, "wait": 0, "travel_distance_km": 0.87, "travel_time_min": 13}, {"poi_id": "bar_sant", "poi_name": "Sant'Eustachio il Caffè", "arrival": 588, "departure": 623, "wait": 0, "travel_distance_km": 0.18, "travel_time_min": 3}, {"poi_id": "pantheon", "poi_name": "Pantheon", "arrival": 626, "departure": 701, "wait": 0, "travel_distance_km": 0.15, "travel_time_min": 2}, {"poi_id": "luigi_francesi", "poi_name": "San Luigi dei Francesi", "arrival": 706, "departure": 751, "wait": 0, "travel_distance_km": 0.21, "travel_time_min": 4}, {"poi_id": "rist_roscioli", "poi_name": "Roscioli Salumeria", "arrival": 763, "departure": 868, "wait": 0, "travel_distance_km": 0.59, "travel_time_min": 11}]}}

demo_rome.py

@@ -0,0 +1,134 @@
+"""
+demo_rome.py — Demo aggiornato: TouristProfile + fix ristoranti + tempi transit realistici.
+"""
+import sys, os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from core.models import PoI, PoICategory, TimeWindow
+from core.distance import DistanceMatrix
+from core.profile import (
+    profile_cultural_walker, profile_foodie_transit,
+    profile_family_mixed, profile_art_lover_car,
+    TouristProfile, TransportMode, MobilityLevel,
+)
+from solver import NSGA2Solver, SolverConfig
+
+ROME_POIS = [
+    # Monumenti e luoghi
+    PoI("colosseo",   "Colosseo",             41.8902,12.4922,0.98,120,TimeWindow(540,1110),PoICategory.MONUMENT,  ["antico","unesco"]),
+    PoI("foro",       "Foro Romano",           41.8925,12.4853,0.90, 90,TimeWindow(540,1110),PoICategory.MONUMENT,  ["antico"]),
+    PoI("vaticano",   "Musei Vaticani",        41.9065,12.4534,0.97,180,TimeWindow(540,1080),PoICategory.MUSEUM,    ["arte","unesco"]),
+    PoI("sistina",    "Cappella Sistina",      41.9029,12.4545,0.96, 60,TimeWindow(540,1080),PoICategory.MUSEUM,    ["arte","rinascimento"]),
+    PoI("pantheon",   "Pantheon",              41.8986,12.4769,0.93, 60,TimeWindow(540,1140),PoICategory.MONUMENT,  ["antico","architettura"]),
+    PoI("trevi",      "Fontana di Trevi",      41.9009,12.4833,0.88, 30,TimeWindow(0,  1440),PoICategory.MONUMENT,  ["barocco","fotogenico"]),
+    PoI("spagna",     "Piazza di Spagna",      41.9059,12.4823,0.80, 30,TimeWindow(0,  1440),PoICategory.VIEWPOINT, ["shopping","fotogenico"]),
+    PoI("borghese",   "Galleria Borghese",     41.9143,12.4923,0.92,120,TimeWindow(540,1140),PoICategory.MUSEUM,    ["arte","scultura"]),
+    PoI("navona",     "Piazza Navona",         41.8992,12.4731,0.85, 45,TimeWindow(0,  1440),PoICategory.VIEWPOINT, ["barocco","fotogenico"]),
+    PoI("trastevere", "Trastevere",            41.8897,12.4703,0.82, 90,TimeWindow(600,1380),PoICategory.VIEWPOINT, ["quartiere","fotogenico"]),
+    PoI("castel",     "Castel Sant'Angelo",    41.9031,12.4663,0.83, 90,TimeWindow(540,1080),PoICategory.MONUMENT,  ["medievale","panorama"]),
+    PoI("aventino",   "Giardino degli Aranci", 41.8837,12.4793,0.75, 40,TimeWindow(480,1200),PoICategory.PARK,      ["panorama","fotogenico"]),
+    PoI("terme",      "Terme di Caracalla",    41.8788,12.4924,0.78, 75,TimeWindow(540,1080),PoICategory.MONUMENT,  ["antico"]),
+    # Ristoranti: solo per pranzo (TW 12-15) o cena (TW 19-22)
+    PoI("rist_rione", "Osteria del Rione",     41.8962,12.4751,0.74, 60,TimeWindow(720, 900),PoICategory.RESTAURANT,["cucina_romana"]),
+    PoI("rist_prati", "Trattoria Prati",       41.9042,12.4601,0.70, 75,TimeWindow(720, 900),PoICategory.RESTAURANT,["cucina_romana"]),
+    PoI("rist_testac","Testaccio da Mario",    41.8792,12.4770,0.76, 70,TimeWindow(720, 900),PoICategory.RESTAURANT,["offal","cucina_romana"]),
+    PoI("rist_cena1", "Ristorante San Pietro", 41.9050,12.4580,0.72, 80,TimeWindow(1140,1320),PoICategory.RESTAURANT,["cucina_romana"]),
+    PoI("rist_cena2", "Da Enzo al 29",         41.8891,12.4697,0.78, 90,TimeWindow(1140,1320),PoICategory.RESTAURANT,["cucina_romana","trastevere"]),
+    # Bar e caffè: colazione o pausa (TW ampia)
+    PoI("bar_greco",  "Caffè Greco",           41.9057,12.4818,0.72, 20,TimeWindow(480,1320),PoICategory.BAR,       ["storico","caffe"]),
+    PoI("bar_sant",   "Sant'Eustachio il Caffè",41.8990,12.4752,0.75, 20,TimeWindow(480,1380),PoICategory.BAR,      ["caffe","storico"]),
+    PoI("bar_campo",  "Bar del Fico",          41.8968,12.4720,0.65, 25,TimeWindow(600,1380),PoICategory.BAR,       ["aperitivo","vivace"]),
+    # Gelaterie: pomeriggio (TW 11-20)
+    PoI("gel_fatamorgana","Fatamorgana",       41.8993,12.4729,0.70, 20,TimeWindow(660,1200),PoICategory.GELATERIA, ["artigianale","insolito"]),
+    PoI("gel_giolitti",   "Giolitti",          41.9003,12.4765,0.68, 20,TimeWindow(660,1260),PoICategory.GELATERIA, ["storico","classico"]),
+    PoI("gel_prati",      "Fatamorgana Prati", 41.9090,12.4626,0.66, 20,TimeWindow(660,1260),PoICategory.GELATERIA, ["artigianale"]),
+]
+
+
+def profile_foodie_transit_updated() -> TouristProfile:
+    """Gastronomico con mezzi: pranzo + cena, bar e gelateria nel pomeriggio."""
+    return TouristProfile(
+        transport_mode     = TransportMode.TRANSIT,
+        mobility           = MobilityLevel.NORMAL,
+        allowed_categories = ["restaurant", "bar", "gelateria", "monument", "viewpoint", "park"],
+        want_lunch         = True,
+        want_dinner        = True,
+        lunch_time         = 720,   # 12:00
+        dinner_time        = 1200,  # 20:00
+        meal_window        = 60,
+        tag_weights        = {"cucina_romana": 1.6, "offal": 0.5, "vivace": 1.2, "caffe": 1.1},
+    )
+
+
+def run_profile(name, profile, config, dm):
+    print(f"\n{'━'*60}")
+    print(f"  Profilo: {name}")
+    print(f"{'━'*60}")
+    print(profile.summary())
+    dm.profile = profile
+    solver = NSGA2Solver(ROME_POIS, dm, config, profile=profile)
+
+    def cb(gen, pareto, stats):
+        if gen % 30 == 0 or gen == 1:
+            print(f"  gen {gen:3d} | pareto={stats['pareto_size']:2d} | "
+                  f"best={stats['best_scalar']:.4f} | feasible={stats['feasible_pct']:.0f}%")
+
+    front = solver.solve(callback=cb)
+    feasible = [x for x in front if x.fitness.is_feasible] or front
+    if not feasible:
+        print("  Nessuna soluzione trovata.")
+        return
+    best = max(feasible, key=lambda x: x.fitness.scalar)
+    sched = solver.evaluator.decode(best)
+
+    # Conta categorie per verifica
+    cats = {}
+    for stop in sched.stops:
+        k = stop.poi.category.value
+        cats[k] = cats.get(k, 0) + 1
+
+    print(f"\n  ★ Tour: {len(best.genes)} PoI | score={best.fitness.total_score:.2f} | "
+          f"{best.fitness.total_distance:.1f}km | {best.fitness.total_time}min")
+    print(f"     Composizione: {', '.join(f'{v}×{k}' for k,v in sorted(cats.items()))}")
+    print()
+    if sched:
+        print(sched.summary())
+
+
+def main():
+    print("Costruzione matrice distanze...")
+    dm = DistanceMatrix(ROME_POIS)
+    dm.build()
+
+    config = SolverConfig(
+        pop_size         = 60,
+        max_generations  = 200,
+        budget           = 660,    # 11 ore (09:30–20:30)
+        start_time       = 570,    # 09:30
+        start_lat        = 41.896,
+        start_lon        = 12.484,
+        stagnation_limit = 25,
+    )
+
+    profiles = [
+        ("Gastronomico con mezzi (aggiornato)", profile_foodie_transit_updated()),
+        ("Culturale a piedi",                   profile_cultural_walker()),
+        ("Gastronomico con mezzi (standard)", profile_foodie_transit()),
+        ("Family: misto",                      profile_family_mixed()),
+        ("Art Lover: con auto",                 profile_art_lover_car()),
+        ("Custom: solo viste, no pasti",         TouristProfile(
+            transport_mode=TransportMode.WALK,
+            allowed_categories=["monument","viewpoint","park","bar","gelateria"],
+            want_lunch=False, want_dinner=False,
+            tag_weights={"fotogenico":1.5,"panorama":1.4,"caffe":1.1},
+        )),
+    ]
+
+    for name, profile in profiles:
+        run_profile(name, profile, config, dm)
+
+    print(f"\n{'━'*60}\n  Completato.\n")
+
+
+if __name__ == "__main__":
+    main()

ga/operators.py

@@ -0,0 +1,191 @@
+"""
+ga/operators.py — Operatori genetici: crossover, mutation, selection.
+Tutti gli operatori lavorano su copie degli individui senza modificare
+i genitori (operazioni pure).
+"""
+from __future__ import annotations
+import random
+from core.models import Individual, PoI
+
+
+# ---------------------------------------------------------------------------
+# SELECTION
+# ---------------------------------------------------------------------------
+
+def tournament_select(
+    population: list[Individual],
+    k:          int = 3,
+    use_pareto: bool = True,
+) -> Individual:
+    """
+    Selezione torneo: estrae k individui casuali e restituisce il migliore.
+    Con use_pareto=True preferisce rango Pareto basso + crowding alto.
+    """
+    contestants = random.sample(population, k)
+    if use_pareto:
+        return min(contestants, key=lambda x: (x.fitness.rank, -x.fitness.crowd))
+    return max(contestants, key=lambda x: x.fitness.scalar)
+
+
+# ---------------------------------------------------------------------------
+# CROSSOVER
+# ---------------------------------------------------------------------------
+
+def order_crossover(parent1: Individual, parent2: Individual) -> tuple[Individual, Individual]:
+    """
+    Order Crossover (OX) adattato a tour a lunghezza variabile.
+    Preserva l'ordine relativo dei PoI condivisi tra i genitori.
+    """
+    g1, g2 = parent1.genes, parent2.genes
+    if len(g1) < 2 or len(g2) < 2:
+        return parent1.clone(), parent2.clone()
+
+    def ox(donor: list[PoI], receiver: list[PoI]) -> list[PoI]:
+        if len(donor) < 2:
+            return list(donor)
+        cut1 = random.randint(0, len(donor) - 1)
+        cut2 = random.randint(cut1, len(donor) - 1)
+        segment  = donor[cut1:cut2+1]
+        seg_ids  = {p.id for p in segment}
+        # Riempi con i PoI del receiver non già nel segmento
+        filling  = [p for p in receiver if p.id not in seg_ids]
+        child    = filling[:cut1] + segment + filling[cut1:]
+        return child
+
+    return (
+        Individual(genes=ox(g1, g2)),
+        Individual(genes=ox(g2, g1)),
+    )
+
+
+def poi_aware_crossover(
+    parent1:    Individual,
+    parent2:    Individual,
+    categories: list[str] | None = None,
+) -> tuple[Individual, Individual]:
+    """
+    PoI-aware Crossover: scambia interi sottoinsiemi per categoria.
+    Utile per preservare "nicchie tematiche" (es. tour musei vs tour gastronomico).
+    """
+    from core.models import PoICategory
+
+    if categories is None:
+        categories = [c.value for c in PoICategory]
+
+    def by_category(genes: list[PoI]) -> dict[str, list[PoI]]:
+        d: dict[str, list[PoI]] = {c: [] for c in categories}
+        for p in genes:
+            d[p.category.value].append(p)
+        return d
+
+    cat1 = by_category(parent1.genes)
+    cat2 = by_category(parent2.genes)
+
+    child1_genes, child2_genes = [], []
+
+    for cat in categories:
+        # Con probabilità 0.5 scambia le categorie tra i figli
+        if random.random() < 0.5:
+            child1_genes.extend(cat1[cat])
+            child2_genes.extend(cat2[cat])
+        else:
+            child1_genes.extend(cat2[cat])
+            child2_genes.extend(cat1[cat])
+
+    # Rimuovi duplicati mantenendo l'ordine
+    def deduplicate(genes: list[PoI]) -> list[PoI]:
+        seen, result = set(), []
+        for p in genes:
+            if p.id not in seen:
+                seen.add(p.id)
+                result.append(p)
+        return result
+
+    return (
+        Individual(genes=deduplicate(child1_genes)),
+        Individual(genes=deduplicate(child2_genes)),
+    )
+
+
+# ---------------------------------------------------------------------------
+# MUTATION
+# ---------------------------------------------------------------------------
+
+def mutate(
+    individual: Individual,
+    poi_pool:   list[PoI],
+    mut_prob:   float = 0.15,
+) -> Individual:
+    """
+    Seleziona casualmente uno degli operatori di mutazione.
+    Applicato con probabilità mut_prob.
+    """
+    if random.random() > mut_prob or not individual.genes:
+        return individual
+
+    operator = random.choice([
+        swap_mutation,
+        insert_mutation,
+        reverse_segment_mutation,
+        lambda ind, pool: add_remove_mutation(ind, pool),
+    ])
+    result = operator(individual.clone(), poi_pool)
+    result.invalidate_cache()
+    return result
+
+
+def swap_mutation(individual: Individual, _pool: list[PoI]) -> Individual:
+    """Scambia due PoI scelti casualmente nella sequenza."""
+    g = individual.genes
+    if len(g) < 2:
+        return individual
+    i, j = random.sample(range(len(g)), 2)
+    g[i], g[j] = g[j], g[i]
+    return individual
+
+
+def insert_mutation(individual: Individual, _pool: list[PoI]) -> Individual:
+    """Rimuove un PoI da una posizione e lo inserisce altrove."""
+    g = individual.genes
+    if len(g) < 2:
+        return individual
+    i = random.randrange(len(g))
+    poi = g.pop(i)
+    j = random.randint(0, len(g))
+    g.insert(j, poi)
+    return individual
+
+
+def reverse_segment_mutation(individual: Individual, _pool: list[PoI]) -> Individual:
+    """Inverte un sottosegmento casuale del tour (elimina incroci geografici)."""
+    g = individual.genes
+    if len(g) < 3:
+        return individual
+    i = random.randint(0, len(g) - 2)
+    j = random.randint(i + 1, len(g) - 1)
+    g[i:j+1] = reversed(g[i:j+1])
+    return individual
+
+
+def add_remove_mutation(individual: Individual, pool: list[PoI]) -> Individual:
+    """
+    Con prob 0.70: aggiunge un PoI casuale non ancora nel tour (esplora).
+    Con prob 0.30: rimuove il PoI con il peggior score/durata (semplifica).
+    Il bias verso l'aggiunta contrasta la tendenza del GA a produrre
+    tour sempre più corti dopo molte generazioni di mutazione.
+    """
+    g        = individual.genes
+    visited  = {p.id for p in g}
+
+    if random.random() < 0.70:   # era 0.50: bias verso aggiunta
+        candidates = [p for p in pool if p.id not in visited]
+        if candidates:
+            new_poi = random.choice(candidates)
+            pos     = random.randint(0, len(g))
+            g.insert(pos, new_poi)
+    else:
+        if g:
+            worst = min(g, key=lambda p: p.score / (p.visit_duration + 1e-9))
+            g.remove(worst)
+
+    return individual

ga/repair.py

@@ -0,0 +1,389 @@
+"""
+ga/repair.py — Motore di riparazione genetica con profilo turista.
+Garantisce:
+  1. Solo PoI di categorie ammesse dal profilo
+  2. Nessuna time window violata
+  3. Budget rispettato
+  4. Slot pasto presente se richiesto dal profilo
+"""
+from __future__ import annotations
+#import random
+from config import ROUTE_DETOUR_FACTOR
+from core.models import Individual, PoI, PoICategory
+from core.distance import DistanceMatrix, haversine_km
+from core.profile import TouristProfile
+from config import (MAX_WAIT_MIN, GROUP_VISIT_OVERHEAD_PER_PERSON, 
+                    MEAL_RESERVE_MIN, EVENING_THRESHOLD, )
+
+class RepairEngine:
+
+    def __init__(
+        self,
+        dm:          DistanceMatrix,
+        profile:     TouristProfile,
+        all_pois:    list[PoI],
+        start_time:  int,
+        budget:      int,
+        start_lat:   float,
+        start_lon:   float,
+        max_wait_min: int = MAX_WAIT_MIN,   # attesa massima tollerata per un singolo PoI (minuti)
+    ):
+        self.dm           = dm
+        self.profile      = profile
+        self.all_pois     = all_pois
+        self.start_time   = start_time
+        self.budget       = budget
+        self.start_lat    = start_lat
+        self.start_lon    = start_lon
+        self.max_wait_min = max_wait_min
+
+    def repair(self, individual: Individual) -> Individual:
+        """Pipeline: categoria → EDF → TW → budget → cap ristoranti → cap snack → pasto → TW finale."""
+        individual.invalidate_cache()
+        individual = self._filter_allowed_categories(individual)
+        individual = self._sort_by_earliest_deadline(individual)
+        individual = self.repair_time_windows(individual)
+        individual = self.repair_budget(individual)
+        individual = self._cap_restaurants(individual)
+        individual = self._cap_snacks(individual)
+        individual = self._ensure_meal_slots(individual)
+        # Passaggio finale: rimuove PoI diventati infeasible dopo l'inserimento
+        # del ristorante (es. l'ultimo monumento che ora arriva fuori TW)
+        individual = self.repair_time_windows(individual)
+        individual.invalidate_cache()
+        return individual
+
+    # ------------------------------------------------------------------
+    # 1. Rimuove PoI di categorie non ammesse dal profilo
+    # ------------------------------------------------------------------
+
+    def _filter_allowed_categories(self, individual: Individual) -> Individual:
+        individual.genes = [
+            p for p in individual.genes
+            if self.profile.allows_category(p.category.value)
+        ]
+        return individual
+
+    # ------------------------------------------------------------------
+    # 2. Ordina per Earliest Deadline First
+    # ------------------------------------------------------------------
+
+    def _sort_by_earliest_deadline(self, individual: Individual) -> Individual:
+        """
+        Ordina per earliest OPEN time: visita prima i PoI che aprono prima.
+        Evita che i ristoranti (open=720) finiscano in cima creando attese enormi.
+        """
+        individual.genes.sort(key=lambda p: p.time_window.open)
+        return individual
+
+    # ------------------------------------------------------------------
+    # 3. Rimuove PoI con TW violata
+    # ------------------------------------------------------------------
+
+    def repair_time_windows(self, individual: Individual) -> Individual:
+        """
+        Simula il tour e rimuove i PoI che causano problemi:
+          - arrivo dopo la chiusura (infeasible)
+          - attesa all'apertura superiore a max_wait_min (tour non realistico)
+        Usa group_overhead per coerenza con FitnessEvaluator.
+        """
+        group_extra = max(0, self.profile.group_size - 1) * GROUP_VISIT_OVERHEAD_PER_PERSON
+
+        valid    = []
+        time_now = self.start_time
+        prev_lat = self.start_lat
+        prev_lon = self.start_lon
+
+        for poi in individual.genes:
+            travel  = self._travel_min(prev_lat, prev_lon, poi)
+            arrival = time_now + travel
+
+            if arrival > poi.time_window.close:
+                continue   # fuori orario
+
+            wait = max(0, poi.time_window.open - arrival)
+            if wait > self.max_wait_min:
+                continue   # attesa inaccettabile
+
+            arrival   = arrival + wait
+            departure = arrival + poi.visit_duration + group_extra
+
+            valid.append(poi)
+            time_now = departure
+            prev_lat = poi.lat
+            prev_lon = poi.lon
+
+        individual.genes = valid
+        return individual
+
+    # ------------------------------------------------------------------
+    # 4. Rimuove PoI finché budget rispettato (minor score/durata prima)
+    # ------------------------------------------------------------------
+
+    def repair_budget(self, individual: Individual) -> Individual:
+        """
+        Rimuove PoI finché il budget è rispettato, riservando tempo
+        solo per gli slot pasto SERALI (cena) non ancora coperti.
+        Il pranzo (≈12:00) cade naturalmente nel flusso diurno e non
+        richiede una riserva esplicita nel budget.
+        """
+        while True:
+            sched = self._simulate_schedule(individual.genes)
+            if not individual.genes:
+                break
+
+            # Conta solo slot SERALI non ancora coperti da un ristorante
+            meal_slots = self.profile.needs_meal_slot()
+            uncovered_evening = sum(
+                1 for (slot_open, slot_close) in meal_slots
+                if slot_open >= EVENING_THRESHOLD
+                and not any(
+                    s["poi"].category == PoICategory.RESTAURANT
+                    and slot_open <= s["arrival"] <= slot_close
+                    for s in sched
+                )
+            )
+
+            effective_budget = self.budget - uncovered_evening * MEAL_RESERVE_MIN
+            total = sched[-1]["departure"] - self.start_time if sched else 0
+
+            if total <= effective_budget:
+                break
+
+            removable = [
+                p for p in individual.genes
+                if p.category != PoICategory.RESTAURANT
+            ] or individual.genes
+
+            worst = min(removable, key=lambda p: p.score / (p.visit_duration + 1e-9))
+            individual.genes.remove(worst)
+
+        return individual
+
+    # ------------------------------------------------------------------
+    # 5. Limita i ristoranti al numero di slot pasto richiesti
+    # ------------------------------------------------------------------
+
+    def _cap_restaurants(self, individual: Individual) -> Individual:
+        """
+        Limita i ristoranti nel tour: al massimo 1 per slot pasto,
+        con TW compatibile con lo slot specifico.
+
+        - Per ogni slot (pranzo, cena) tiene il ristorante con score più
+          alto la cui TW si sovrappone a quello slot.
+        - Rimuove tutti gli altri ristoranti (inclusi quelli di un slot
+          sbagliato — es. due ristoranti lunch quando serve un lunch e una cena).
+        - Se nessun pasto è richiesto, rimuove tutti i ristoranti.
+        - BAR e GELATERIA non sono toccati da questo metodo.
+        """
+        restaurants_in_tour = [
+            p for p in individual.genes
+            if p.category == PoICategory.RESTAURANT
+        ]
+        if not restaurants_in_tour:
+            return individual
+
+        meal_slots = self.profile.needs_meal_slot()
+
+        if not meal_slots:
+            individual.genes = [
+                p for p in individual.genes
+                if p.category != PoICategory.RESTAURANT
+            ]
+            return individual
+
+        to_keep: set[str] = set()
+        for (slot_open, slot_close) in meal_slots:
+            # Candidati: ristorante la cui TW si sovrappone allo slot temporale
+            # e non è già assegnato a un altro slot
+            candidates = [
+                r for r in restaurants_in_tour
+                if r.time_window.open <= slot_close
+                and r.time_window.close >= slot_open
+                and r.id not in to_keep
+            ]
+            if candidates:
+                best = max(candidates, key=lambda r: r.score)
+                to_keep.add(best.id)
+
+        remove = {r.id for r in restaurants_in_tour if r.id not in to_keep}
+        individual.genes = [p for p in individual.genes if p.id not in remove]
+        return individual
+
+    def _cap_snacks(self, individual: Individual) -> Individual:
+        """
+        Limita le soste snack (BAR, GELATERIA) ai massimi definiti nel profilo.
+        Mantiene le soste con score più alto, rimuove le eccedenti.
+        """
+        for cat, max_stops in [
+            (PoICategory.BAR,       self.profile.max_bar_stops),
+            (PoICategory.GELATERIA, self.profile.max_gelateria_stops),
+        ]:
+            in_tour = [p for p in individual.genes if p.category == cat]
+            if len(in_tour) <= max_stops:
+                continue
+            in_tour.sort(key=lambda p: p.score, reverse=True)
+            remove = {p.id for p in in_tour[max_stops:]}
+            individual.genes = [p for p in individual.genes if p.id not in remove]
+        return individual
+
+    # ------------------------------------------------------------------
+    # 6. Garantisce slot pasto se richiesto dal profilo
+    # ------------------------------------------------------------------
+
+    def _ensure_meal_slots(self, individual: Individual) -> Individual:
+        """
+        Per ogni slot pasto richiesto dal profilo, garantisce un ristorante.
+
+        Strategia:
+          1. Prova ad AGGIUNGERE il ristorante senza sforare il budget.
+          2. Se non c'è spazio, prova a SOSTITUIRE il PoI con il peggior
+             rapporto score/durata con il ristorante, se ciò libera abbastanza
+             tempo da farci stare il pasto.
+        """
+        meal_slots = self.profile.needs_meal_slot()
+        if not meal_slots:
+            return individual
+
+        restaurants = [
+            p for p in self.all_pois
+            if p.category == PoICategory.RESTAURANT
+            and self.profile.allows_category(p.category.value)
+            and p not in individual.genes
+        ]
+        if not restaurants:
+            return individual
+
+        for (slot_open, slot_close) in meal_slots:
+            schedule = self._simulate_schedule(individual.genes)
+            already_covered = any(
+                stop["poi"].category == PoICategory.RESTAURANT
+                and slot_open <= stop["arrival"] <= slot_close
+                for stop in schedule
+            )
+            if already_covered:
+                continue
+
+            inserted = False
+            original_poi_ids = {s["poi"].id for s in schedule}
+
+            # Tolleranza di attesa: slot serali (≥18:00) ammettono più attesa
+            # (rientro in hotel, aperitivo, passeggiata pre-cena = comportamento normale)
+            
+            slot_wait_tol = 90 if slot_open >= EVENING_THRESHOLD else self.max_wait_min + 15
+
+            # --- Tentativo 1: inserimento diretto ---
+            for rest in sorted(restaurants, key=lambda r: r.score, reverse=True):
+                if rest in individual.genes:
+                    continue
+                for pos in range(len(individual.genes) + 1):
+                    test_genes = individual.genes[:pos] + [rest] + individual.genes[pos:]
+                    test_sched = self._simulate_schedule(test_genes)
+                    if not test_sched:
+                        continue
+                    rest_stop = next((s for s in test_sched if s["poi"].id == rest.id), None)
+                    if rest_stop is None:
+                        continue
+
+                    arrival   = rest_stop["arrival"]
+                    wait_rest = rest_stop["wait"]
+                    total_t   = test_sched[-1]["departure"] - self.start_time
+                    new_poi_ids = {s["poi"].id for s in test_sched}
+
+                    if (slot_open <= arrival <= slot_close
+                            and wait_rest <= slot_wait_tol
+                            and total_t <= self.budget
+                            and original_poi_ids.issubset(new_poi_ids)):
+                        individual.genes.insert(pos, rest)
+                        inserted = True
+                        break
+                if inserted:
+                    break
+
+            if inserted:
+                continue
+
+            # --- Tentativo 2: sostituzione del PoI meno prezioso ---
+            # Ordina i candidati alla rimozione per minor valore (escludi ristoranti già presenti)
+            removable = [
+                p for p in individual.genes
+                if p.category not in (PoICategory.RESTAURANT, PoICategory.BAR, PoICategory.GELATERIA)
+            ]
+            if not removable:
+                continue
+            removable.sort(key=lambda p: p.score / (p.visit_duration + 1e-9))
+
+            for victim in removable:
+                for rest in sorted(restaurants, key=lambda r: r.score, reverse=True):
+                    if rest in individual.genes:
+                        continue
+                    test_genes = [r if r.id != victim.id else rest for r in individual.genes]
+                    test_sched = self._simulate_schedule(test_genes)
+                    if not test_sched:
+                        continue
+                    rest_stop = next((s for s in test_sched if s["poi"].id == rest.id), None)
+                    if rest_stop is None:
+                        continue
+                    arrival   = rest_stop["arrival"]
+                    wait_rest = rest_stop["wait"]
+                    total_t   = test_sched[-1]["departure"] - self.start_time
+                    if (slot_open <= arrival <= slot_close
+                            and wait_rest <= slot_wait_tol
+                            and total_t <= self.budget):
+                        idx = individual.genes.index(victim)
+                        individual.genes[idx] = rest
+                        inserted = True
+                        break
+                if inserted:
+                    break
+
+        individual.invalidate_cache()
+        return individual
+
+    # ------------------------------------------------------------------
+    # Helper interni
+    # ------------------------------------------------------------------
+
+    def _simulate_schedule(self, genes: list[PoI]) -> list[dict]:
+        """
+        Simula lo schedule esattamente come FitnessEvaluator.decode():
+          - salta solo PoI con arrivo > time_window.close (impossibili)
+          - include TUTTE le attese senza soglia
+          - applica group_overhead per coerenza con FitnessEvaluator
+
+        Il filtraggio per max_wait_min avviene solo in repair_time_windows,
+        prima di questa simulazione.
+        """
+        group_extra = max(0, self.profile.group_size - 1) * 5  # minuti extra per persona
+
+        stops    = []
+        time_now = self.start_time
+        prev_lat = self.start_lat
+        prev_lon = self.start_lon
+
+        for poi in genes:
+            travel  = self._travel_min(prev_lat, prev_lon, poi)
+            arrival = time_now + travel
+            if arrival > poi.time_window.close:
+                continue  # impossibile: la TW è chiusa
+            wait      = max(0, poi.time_window.open - arrival)
+            arrival   = arrival + wait
+            duration  = poi.visit_duration + group_extra
+            departure = arrival + duration
+            stops.append({"poi": poi, "arrival": arrival, "departure": departure, "wait": wait})
+            time_now = departure
+            prev_lat = poi.lat
+            prev_lon = poi.lon
+
+        return stops
+
+    def _simulate_total_time(self, genes: list[PoI]) -> int:
+        """Tempo totale del tour (minuti). Usato da repair_budget."""
+        sched = self._simulate_schedule(genes)
+        if not sched:
+            return self.budget + 1   # tour vuoto → forza rimozione
+        return sched[-1]["departure"] - self.start_time
+
+    def _travel_min(self, lat: float, lon: float, to: PoI) -> int:
+        km = haversine_km(lat, lon, to.lat, to.lon) * ROUTE_DETOUR_FACTOR
+        return self.profile.travel_time_min(km)

ga/seeding.py

@@ -0,0 +1,143 @@
+"""
+ga/seeding.py — Inizializzazione della popolazione con greedy seeding.
+Rispetta il TouristProfile in ogni costruzione:
+  - Filtra le categorie non ammesse
+  - Usa effective_score (con boost tag) nel criterio di selezione
+  - Usa travel_time_min del profilo per i tempi
+"""
+from __future__ import annotations
+import random
+from config import ROUTE_DETOUR_FACTOR
+from core.models import Individual, PoI
+from core.distance import DistanceMatrix, haversine_km
+from core.profile import TouristProfile
+from ga.repair import RepairEngine
+
+
+class GreedySeeder:
+
+    def __init__(
+        self,
+        pois:       list[PoI],
+        dm:         DistanceMatrix,
+        repair:     RepairEngine,
+        profile:    TouristProfile,
+        start_time: int,
+        budget:     int,
+        start_lat:  float,
+        start_lon:  float,
+    ):
+        self.pois       = pois
+        self.dm         = dm
+        self.repair     = repair
+        self.profile    = profile
+        self.start_time = start_time
+        self.budget     = budget
+        self.start_lat  = start_lat
+        self.start_lon  = start_lon
+        # Pool filtrato per categorie ammesse — usato in tutta la seeding
+        self.allowed_pois = [
+            p for p in pois
+            if profile.allows_category(p.category.value)
+        ]
+
+    def build_population(self, pop_size: int) -> list[Individual]:
+        population = []
+
+        n_greedy    = max(1, int(pop_size * 0.20))
+        n_perturbed = max(1, int(pop_size * 0.20))
+        n_random    = pop_size - n_greedy - n_perturbed
+
+        for _ in range(n_greedy):
+            ind = self._greedy_construct(randomize=False, alpha=0.0)
+            ind = self.repair.repair(ind)   # ← cap snack/ristoranti anche sui greedy
+            population.append(ind)
+
+        for i in range(n_perturbed):
+            alpha = 0.15 + (i / n_perturbed) * 0.35
+            ind   = self._greedy_construct(randomize=True, alpha=alpha)
+            ind   = self.repair.repair(ind)   # ← idem
+            population.append(ind)
+
+        for _ in range(n_random):
+            shuffled = random.sample(self.allowed_pois, len(self.allowed_pois))
+            ind = Individual(genes=shuffled[:random.randint(1, len(shuffled))])
+            ind = self.repair.repair(ind)
+            population.append(ind)
+
+        return population
+
+    def _greedy_construct(self, randomize: bool = False, alpha: float = 0.0) -> Individual:
+        """
+        Greedy con RCL. Usa group_overhead per coerenza con FitnessEvaluator.
+        Salta i ristoranti (li aggiunge _ensure_meal_slots) e riserva tempo
+        solo per gli slot pasto SERALI (≥18:00), non per il pranzo — il pranzo
+        cade nel flusso naturale del tour diurno e viene inserito da
+        _ensure_meal_slots senza bisogno di riserva esplicita.
+        """
+        group_extra = max(0, self.profile.group_size - 1) * 5
+
+        # Riserva tempo per ogni slot pasto che il greedy salta (tutti):
+        # - slot serali (≥18:00): 90 min (cena dopo il tour diurno)
+        # - slot diurni (<18:00): 75 min (pranzo inserito nel mezzo del tour)
+        EVENING_RESERVE   = 90
+        DAYTIME_RESERVE   = 75
+        EVENING_THRESHOLD = 1080   # 18:00
+
+        total_reserve = sum(
+            EVENING_RESERVE if slot_open >= EVENING_THRESHOLD else DAYTIME_RESERVE
+            for (slot_open, _) in self.profile.needs_meal_slot()
+        )
+        effective_end = self.start_time + self.budget - total_reserve
+
+        tour      = []
+        visited   = set()
+        time_now  = self.start_time
+        prev_lat  = self.start_lat
+        prev_lon  = self.start_lon
+
+        while True:
+            candidates = []
+
+            for poi in self.allowed_pois:
+                if poi.id in visited:
+                    continue
+                if poi.category.value == "restaurant":
+                    continue  # ristoranti: aggiunti da _ensure_meal_slots
+
+                km         = haversine_km(prev_lat, prev_lon, poi.lat, poi.lon) * ROUTE_DETOUR_FACTOR
+                travel_min = self.profile.travel_time_min(km)
+                arrival    = time_now + travel_min
+
+                if arrival > poi.time_window.close:
+                    continue
+
+                actual_arrival = max(arrival, poi.time_window.open)
+                duration = poi.visit_duration + group_extra
+                finish   = actual_arrival + duration
+                if finish > effective_end:
+                    continue
+
+                overhead  = travel_min + max(0, poi.time_window.open - arrival)
+                eff_score = self.profile.effective_score(poi)
+                ratio     = eff_score / (overhead + duration + 1e-9)
+                candidates.append((ratio, poi, actual_arrival, finish))
+
+            if not candidates:
+                break
+
+            candidates.sort(key=lambda x: x[0], reverse=True)
+
+            if randomize and len(candidates) > 1 and random.random() < alpha:
+                rcl_size = max(1, int(len(candidates) * 0.20))
+                _, poi, _, finish = random.choice(candidates[:rcl_size])
+            else:
+                _, poi, _, finish = candidates[0]
+
+            tour.append(poi)
+            visited.add(poi.id)
+            prev_lat = poi.lat
+            prev_lon = poi.lon
+            time_now = finish
+
+        return Individual(genes=tour)

requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.104.0
+uvicorn>=0.24.0
+streamlit>=1.28.0
+pydantic>=2.0.0
+pandas>=2.0.0
+requests>=2.31.0
+python-multipart>=0.0.22
+huggingface-hub>=0.19.0

solver.py

@@ -0,0 +1,264 @@
+"""
+solver.py — Entry point principale. Ciclo evolutivo NSGA-II per TOP-TW.
+Uso:
+    python -m tour_ga.solver --city rome --budget 480 --generations 200
+"""
+from __future__ import annotations
+import random
+import time
+from dataclasses import dataclass
+from typing import Callable
+
+from core.models import Individual
+from core.distance import DistanceMatrix
+from core.fitness import FitnessEvaluator
+from ga.operators import (
+    tournament_select, order_crossover, poi_aware_crossover, mutate
+)
+from ga.repair import RepairEngine
+from ga.seeding import GreedySeeder
+import config
+
+
+@dataclass
+class SolverConfig:
+    pop_size:         int   = config.GA_POP_SIZE
+    max_generations:  int   = config.GA_MAX_GENERATIONS
+    cx_prob:          float = config.GA_CX_PROB
+    mut_prob:         float = config.GA_MUT_PROB
+    tournament_k:     int   = config.GA_TOURNAMENT_K
+    stagnation_limit: int   = config.GA_STAGNATION_LIMIT
+    start_time:       int   = config.DEFAULT_START_TIME
+    budget:           int   = config.DEFAULT_BUDGET
+    start_lat:        float = config.DEFAULT_START_LAT
+    start_lon:        float = config.DEFAULT_START_LON
+    w_score:          float = config.W_SCORE
+    w_dist:           float = config.W_DIST
+    w_time:           float = config.W_TIME
+    max_wait_min:     int   = config.GA_MAX_WAIT_MIN
+    ox_crossover_prob: float = config.GA_OX_CROSSOVER_PROB
+
+
+class NSGA2Solver:
+    """
+    Implementazione NSGA-II adattata al problema TOP-TW.
+    Riceve un TouristProfile e lo propaga a tutti i componenti.
+    """
+
+    def __init__(self, pois, dm: DistanceMatrix, config: SolverConfig, profile=None):
+        from core.profile import TouristProfile # import locale per evitare dipendenze circolari
+        self.pois    = pois
+        self.dm      = dm
+        self.config  = config
+        self.profile = profile or TouristProfile()   # default: turista generico a piedi
+
+        # Inietta il profilo nella matrice distanze (per la velocità)
+        self.dm.profile = self.profile
+
+        self.repair = RepairEngine(
+            dm=dm,
+            profile=self.profile,
+            all_pois=pois,
+            start_time=config.start_time,
+            budget=config.budget,
+            start_lat=config.start_lat,
+            start_lon=config.start_lon,
+            max_wait_min=config.max_wait_min,
+        )
+        self.evaluator = FitnessEvaluator(
+            dist_matrix=dm,
+            profile=self.profile,
+            start_time=config.start_time,
+            budget=config.budget,
+            start_lat=config.start_lat,
+            start_lon=config.start_lon,
+            w_score=config.w_score,
+            w_dist=config.w_dist,
+            w_time=config.w_time,
+        )
+        self.seeder = GreedySeeder(
+            pois=pois,
+            dm=dm,
+            repair=self.repair,
+            profile=self.profile,
+            start_time=config.start_time,
+            budget=config.budget,
+            start_lat=config.start_lat,
+            start_lon=config.start_lon,
+        )
+
+        self.history: list[dict] = []  # statistiche per generazione
+
+    def solve(self, callback: Callable | None = None) -> list[Individual]:
+        """
+        Esegue il ciclo NSGA-II e restituisce il fronte di Pareto finale.
+        callback(gen, pareto_front, stats) viene chiamata ogni generazione.
+        """
+        cfg = self.config
+        t0  = time.perf_counter()
+
+        # --- Inizializzazione ---
+        population = self.seeder.build_population(cfg.pop_size)
+        population = self._evaluate_all(population)
+        population = self._nsga2_select(population + [], cfg.pop_size)
+
+        best_scalar   = max(ind.fitness.scalar for ind in population)
+        stagnation    = 0
+
+        for gen in range(cfg.max_generations):
+            # --- Generazione figli ---
+            offspring = []
+            while len(offspring) < cfg.pop_size:
+                p1 = tournament_select(population, cfg.tournament_k)
+                p2 = tournament_select(population, cfg.tournament_k)
+
+                # Alterna tra OX e PoI-aware crossover
+                if random.random() < cfg.cx_prob:
+                    if random.random() < cfg.ox_crossover_prob:
+                        c1, c2 = order_crossover(p1, p2)
+                    else:
+                        c1, c2 = poi_aware_crossover(p1, p2)
+                else:
+                    c1, c2 = p1.clone(), p2.clone()
+
+                c1 = mutate(c1, self.seeder.allowed_pois, cfg.mut_prob)
+                c2 = mutate(c2, self.seeder.allowed_pois, cfg.mut_prob)
+
+                # Riparazione obbligatoria dopo ogni operatore
+                c1 = self.repair.repair(c1)
+                c2 = self.repair.repair(c2)
+
+                offspring.extend([c1, c2])
+
+            # --- Valutazione e selezione NSGA-II ---
+            offspring  = self._evaluate_all(offspring)
+            combined   = population + offspring
+            population = self._nsga2_select(combined, cfg.pop_size)
+
+            # --- Statistiche e criterio di stop ---
+            pareto    = [ind for ind in population if ind.fitness.rank == 1]
+            new_best  = max(ind.fitness.scalar for ind in population)
+
+            stats = {
+                "gen":            gen + 1,
+                "pareto_size":    len(pareto),
+                "best_scalar":    round(new_best, 4),
+                "avg_score":      round(
+                    sum(ind.fitness.total_score for ind in population) / len(population), 3
+                ),
+                "feasible_pct":   round(
+                    sum(1 for ind in population if ind.fitness.is_feasible) / len(population) * 100, 1
+                ),
+                "elapsed_s":      round(time.perf_counter() - t0, 2),
+            }
+            self.history.append(stats)
+
+            if callback:
+                callback(gen + 1, pareto, stats)
+
+            if new_best > best_scalar + 1e-6:
+                best_scalar = new_best
+                stagnation  = 0
+            else:
+                stagnation += 1
+
+            if stagnation >= cfg.stagnation_limit:
+                print(f"  Early stop a gen {gen+1}: stagnazione per {stagnation} generazioni.")
+                break
+
+        pareto_front = [ind for ind in population if ind.fitness.rank == 1]
+        return sorted(pareto_front, key=lambda x: -x.fitness.total_score)
+
+    # ------------------------------------------------------------------
+    # NSGA-II core: fast non-dominated sort + crowding distance
+    # ------------------------------------------------------------------
+
+    def _evaluate_all(self, pop: list[Individual]) -> list[Individual]:
+        for ind in pop:
+            self.evaluator.evaluate(ind)
+        return pop
+
+    def _nsga2_select(
+        self, combined: list[Individual], target_size: int
+    ) -> list[Individual]:
+        """Selezione NSGA-II: ranking Pareto + crowding distance."""
+        fronts = self._fast_non_dominated_sort(combined)
+
+        next_pop: list[Individual] = []
+        for front in fronts:
+            if len(next_pop) + len(front) <= target_size:
+                next_pop.extend(front)
+            else:
+                self._assign_crowding_distance(front)
+                front.sort(key=lambda x: x.fitness.crowd, reverse=True)
+                next_pop.extend(front[:target_size - len(next_pop)])
+                break
+
+        return next_pop
+
+    def _fast_non_dominated_sort(
+        self, pop: list[Individual]
+    ) -> list[list[Individual]]:
+        """
+        Algoritmo NSGA-II O(MN²) per la costruzione dei fronti.
+        M = numero obiettivi, N = dimensione popolazione.
+        """
+        n = len(pop)
+        dom_count  = [0] * n          # quanti individui dominano i
+        dom_set    = [[] for _ in range(n)]  # individui dominati da i
+        fronts     = [[]]
+
+        for i in range(n):
+            for j in range(n):
+                if i == j:
+                    continue
+                fi, fj = pop[i].fitness, pop[j].fitness
+                if fi.dominates(fj):
+                    dom_set[i].append(j)
+                elif fj.dominates(fi):
+                    dom_count[i] += 1
+            if dom_count[i] == 0:
+                pop[i].fitness.rank = 1
+                fronts[0].append(pop[i])
+
+        rank = 1
+        current_front = fronts[0]
+        while current_front:
+            next_front = []
+            for ind in current_front:
+                idx_i = pop.index(ind)
+                for idx_j in dom_set[idx_i]:
+                    dom_count[idx_j] -= 1
+                    if dom_count[idx_j] == 0:
+                        pop[idx_j].fitness.rank = rank + 1
+                        next_front.append(pop[idx_j])
+            rank += 1
+            fronts.append(next_front)
+            current_front = next_front
+
+        return [f for f in fronts if f]
+
+    def _assign_crowding_distance(self, front: list[Individual]):
+        """Calcola la crowding distance per il front dato."""
+        n = len(front)
+        if n == 0:
+            return
+        for ind in front:
+            ind.fitness.crowd = 0.0
+
+        objectives = [
+            lambda x:  x.fitness.total_score,      # massimizza
+            lambda x: -x.fitness.total_distance,   # minimizza → negativo
+            lambda x: -x.fitness.total_time,        # minimizza → negativo
+        ]
+        for obj_fn in objectives:
+            sorted_f = sorted(front, key=obj_fn)
+            sorted_f[0].fitness.crowd  = float('inf')
+            sorted_f[-1].fitness.crowd = float('inf')
+            f_min = obj_fn(sorted_f[0])
+            f_max = obj_fn(sorted_f[-1])
+            f_range = f_max - f_min or 1e-9
+            for i in range(1, n - 1):
+                sorted_f[i].fitness.crowd += (
+                    obj_fn(sorted_f[i+1]) - obj_fn(sorted_f[i-1])
+                ) / f_range

streamlit_ui.py

@@ -0,0 +1,168 @@
+"""
+streamlit_ui.py — Streamlit UI for Tour Generator.
+Allows uploading POIs and selecting profile to generate tours.
+"""
+import streamlit as st
+import requests
+import json
+import os
+import pandas as pd
+from typing import Optional
+from pathlib import Path
+from huggingface_hub import CommitScheduler
+
+DATASET_REPO_ID = "NextGenTech/tour-generator-logs" 
+
+LOG_DIR = Path("data")
+LOG_DIR.mkdir(parents=True, exist_ok=True)
+LOG_FILE = LOG_DIR / "tour_results.jsonl"
+
+scheduler = CommitScheduler(
+    repo_id=DATASET_REPO_ID,
+    repo_type="dataset",
+    folder_path=LOG_DIR,
+    path_in_repo="logs",
+    every=15
+)
+
+st.title("🗺️ Tour Generator")
+st.markdown("Upload Points of Interest and select a user profile to generate an optimized tour using genetic algorithms.")
+
+# Get available profiles
+try:
+    response = requests.get("http://localhost:8000/profiles")
+    if response.status_code == 200:
+        available_profiles = response.json()["profiles"]
+    else:
+        available_profiles = ["cultural_walker", "foodie_transit", "family_mixed", "art_lover_car"]
+except:
+    available_profiles = ["cultural_walker", "foodie_transit", "family_mixed", "art_lover_car"]
+
+st.header("📍 Upload Points of Interest (POIs)")
+pois_file = st.file_uploader(
+    "Upload POIs as CSV or JSON file",
+    type=['csv', 'json'],
+    help="CSV columns: id,name,lat,lon,score,visit_duration,time_window_open,time_window_close,category,tags\nJSON: list of POI objects"
+)
+
+st.header("👤 Select User Profile")
+profile_option = st.radio("Profile Type", ["Predefined", "Custom"])
+
+profile_name: Optional[str] = None
+profile_data: Optional[dict] = None
+
+if profile_option == "Predefined":
+    profile_name = st.selectbox("Choose a predefined profile", available_profiles)
+    if profile_name:
+        try:
+            response = requests.get(f"http://localhost:8000/profiles/{profile_name}")
+            if response.status_code == 200:
+                profile_data = response.json()
+                st.subheader(f"Profile Details: {profile_name}")
+                st.json(profile_data)
+        except:
+            st.warning("Could not load profile details")
+else:
+    profile_file = st.file_uploader(
+        "Upload custom profile JSON",
+        type=['json'],
+        help="JSON object with TouristProfile fields"
+    )
+    if profile_file:
+        try:
+            profile_data = json.load(profile_file)
+            st.json(profile_data)
+        except:
+            st.error("Invalid JSON file")
+
+st.header("⚙️ Tour Parameters")
+col1, col2 = st.columns(2)
+with col1:
+    budget = st.number_input("Time Budget (minutes)", value=480, min_value=60, help="Total available time for the tour")
+    start_lat = st.number_input("Start Latitude", value=41.9028, format="%.4f")
+with col2:
+    start_time = st.number_input("Start Time (minutes from midnight)", value=540, min_value=0, max_value=1439, help="e.g., 540 = 9:00 AM")
+    start_lon = st.number_input("Start Longitude", value=12.4964, format="%.4f")
+
+if st.button("🚀 Generate Tour", type="primary"):
+    if not pois_file:
+        st.error("Please upload a POIs file")
+        st.stop()
+    
+    if profile_option == "Custom" and not profile_data:
+        st.error("Please upload a custom profile JSON")
+        st.stop()
+
+    # Prepare request
+    files = {'pois_file': pois_file}
+    data = {
+        'budget': budget,
+        'start_time': start_time,
+        'start_lat': start_lat,
+        'start_lon': start_lon,
+    }
+    
+    if profile_name:
+        data['profile_name'] = profile_name
+    elif profile_data:
+        data['profile_json'] = json.dumps(profile_data)
+    
+    with st.spinner("Generating tour... This may take a few moments."):
+        try:
+            response = requests.post("http://localhost:8000/generate_tour", files=files, data=data, timeout=60)
+            
+            if response.status_code == 200:
+                result = response.json()
+                
+                # Log the result
+                log_entry = {
+                    "timestamp": str(pd.Timestamp.now()),
+                    "profile": profile_name if profile_name else "custom",
+                    "budget": budget,
+                    "start_time": start_time,
+                    "start_lat": start_lat,
+                    "start_lon": start_lon,
+                    "result": result
+                }
+                
+                with scheduler.lock:
+                    with LOG_FILE.open("a", encoding="utf-8") as f:
+                        json.dump(log_entry, f, ensure_ascii=False)
+                        f.write("\n")
+                
+                st.success("✅ Tour generated successfully!")
+                
+                # Display summary
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    st.metric("Total Score", f"{result['total_score']:.2f}")
+                with col2:
+                    st.metric("Total Distance", f"{result['total_distance']:.1f} km")
+                with col3:
+                    st.metric("Total Time", f"{result['total_time']} min")
+                
+                st.write(f"**Feasible:** {'✅ Yes' if result['is_feasible'] else '❌ No'}")
+                
+                # Display stops
+                st.header("📋 Tour Itinerary")
+                if result['stops']:
+                    stops_df = pd.DataFrame(result['stops'])
+                    stops_df['arrival_time'] = stops_df['arrival'].apply(lambda x: f"{x//60:02d}:{x%60:02d}")
+                    stops_df['departure_time'] = stops_df['departure'].apply(lambda x: f"{x//60:02d}:{x%60:02d}")
+                    stops_df['wait_min'] = stops_df['wait']
+                    
+                    st.dataframe(
+                        stops_df[['poi_name', 'arrival_time', 'departure_time', 'wait_min', 'travel_distance_km', 'travel_time_min']],
+                        width="stretch"
+                    )
+                else:
+                    st.info("No stops in the generated tour")
+                    
+            else:
+                st.error(f"Error: {response.status_code} - {response.text}")
+                
+        except requests.exceptions.RequestException as e:
+            st.error(f"Failed to connect to the API. Make sure the FastAPI server is running on localhost:8000\nError: {str(e)}")
+
+st.markdown("---")
+st.markdown("**Note:** Make sure to start the FastAPI server first: `python app.py` or `uvicorn app:app --reload`")