148 lines
8.9 KiB
Markdown
148 lines
8.9 KiB
Markdown
Certamente! Ho preparato due versioni della presentazione, una in italiano e una in inglese. Entrambe evidenziano non solo le funzionalità visibili all'utente, ma anche i punti di forza dell'architettura software, che sono molto importanti per un progetto di questo livello.
|
|
|
|
---
|
|
|
|
### Presentazione (Italiano)
|
|
|
|
## FlightMonitor: Applicazione Avanzata per il Monitoraggio del Traffico Aereo
|
|
|
|
**FlightMonitor** è un'applicazione desktop sviluppata in Python, progettata per offrire una suite completa di strumenti per il monitoraggio, la registrazione e l'analisi del traffico aereo. Nata come strumento per sviluppatori e appassionati di aviazione, l'applicazione combina un'interfaccia utente reattiva con un backend robusto e multi-threaded per la gestione dei dati in tempo reale e storici.
|
|
|
|
---
|
|
|
|
### Caratteristiche Principali
|
|
|
|
* **Monitoraggio Live:** Visualizza in tempo reale il traffico aereo in una specifica area geografica (Bounding Box). I dati vengono aggiornati a intervalli configurabili, ottimizzati in base allo stato di autenticazione dell'utente (utente registrato vs. anonimo).
|
|
|
|
* **Analisi Dati Storici:** Permette di scaricare e visualizzare i dati di volo per un intervallo di tempo passato, definendo l'area di interesse e l'intervallo di campionamento.
|
|
|
|
* **Mappa Interattiva e Intelligente:**
|
|
* Una mappa completamente interattiva basata su tile, con caching su disco per performance ottimali e uso offline.
|
|
* Funzionalità di pan, zoom e recenter.
|
|
* Visualizzazione delle tracce dei velivoli con colori unici per ogni aereo.
|
|
* Una griglia geografica (reticolo) dinamica con meridiani e paralleli, che si adatta intelligentemente al livello di zoom per una leggibilità ottimale.
|
|
|
|
* **Viste Dettagliate dei Dati:**
|
|
* Un pannello di dettaglio rapido che mostra le informazioni principali del velivolo selezionato.
|
|
* Una finestra di dettaglio completa con tutte le informazioni statiche (dal database) e dinamiche (dati di volo correnti), inclusa una mappa dedicata alla traccia completa del volo.
|
|
|
|
* **Logging Dati Avanzato:**
|
|
* Possibilità di registrare l'intera sessione di monitoraggio.
|
|
* Salvataggio dei **dati JSON grezzi** ricevuti dal provider, per analisi offline e debug.
|
|
* Creazione automatica di un **file di report** riassuntivo con i dati della sessione e il conteggio degli aerei per ogni interrogazione.
|
|
|
|
* **Gestione Database:**
|
|
* Importazione di database di aeromobili da file CSV con una dialog di progresso dedicata.
|
|
* Archiviazione dei dati di volo in un database SQLite giornaliero per una gestione efficiente.
|
|
|
|
* **Personalizzazione:**
|
|
* Salvataggio e caricamento di **profili di aree geografiche** per un accesso rapido alle zone di interesse comune.
|
|
* Configurazione centralizzata per un facile tuning di parametri API, polling rate e stile della UI.
|
|
|
|
---
|
|
|
|
### Architettura Tecnica
|
|
|
|
Il progetto è costruito su un'architettura **MVC-like (Model-View-Controller)** pulita, con una forte enfasi sulla **separazione delle responsabilità (SoC)**.
|
|
|
|
* **Model:** Lo strato dati astrae completamente la fonte (OpenSky, ecc.) attraverso un **modello dati canonico** (`CanonicalFlightState`). Gli `Adapter` dedicati gestiscono la comunicazione con le API esterne. Lo storage è affidato a SQLite con una gestione separata per dati dinamici e statici.
|
|
|
|
* **View:** L'interfaccia, basata su **Tkinter (ttk)**, è composta da pannelli modulari e riutilizzabili. È un componente "passivo" che riceve dati dal Controller e notifica le interazioni dell'utente.
|
|
|
|
* **Controller:** Il `AppController` orchestra il flusso di lavoro. Non contiene la logica di business, ma delega a componenti specializzati come i `DataProcessor`, `MapCommandHandler`, `RawDataLogger` e `CleanupManager`.
|
|
|
|
* **Flusso Dati Asincrono:** Le operazioni di rete (chiamate API) e di rendering della mappa vengono eseguite in **thread separati** per garantire che l'interfaccia utente rimanga sempre fluida e reattiva. La comunicazione tra i thread e il thread principale della GUI avviene in modo sicuro tramite **code (`queue.Queue`)**, seguendo le best practice per le applicazioni concorrenti.
|
|
|
|
---
|
|
|
|
### Stack Tecnologico
|
|
|
|
* **Linguaggi:** Python (con hint di tipo per robustezza)
|
|
* **GUI:** Tkinter (con widget moderni `ttk`)
|
|
* **Networking:** `requests`
|
|
* **Elaborazione Immagini:** `Pillow (PIL)`
|
|
* **Dati Geospaziali:** `mercantile`, `pyproj`
|
|
* **Database:** `sqlite3`
|
|
|
|
---
|
|
|
|
### Sviluppi Futuri
|
|
|
|
L'architettura modulare è predisposta per future espansioni, tra cui:
|
|
* Integrazione di nuove fonti dati (es. FlightAware, ADSB-Hub).
|
|
* Implementazione della modalità **Playback** per rivedere le sessioni registrate.
|
|
* Creazione di dashboard con grafici e statistiche avanzate.
|
|
|
|
---
|
|
---
|
|
|
|
### Presentation (English)
|
|
|
|
## FlightMonitor: An Advanced Aircraft Tracking Application
|
|
|
|
**FlightMonitor** is a desktop application developed in Python, designed to offer a comprehensive suite of tools for monitoring, recording, and analyzing air traffic. Conceived as a tool for developers and aviation enthusiasts, the application combines a responsive user interface with a robust, multi-threaded backend for managing real-time and historical data.
|
|
|
|
---
|
|
|
|
### Key Features
|
|
|
|
* **Live Monitoring:** Displays real-time air traffic within a user-defined geographical area (Bounding Box). Data is updated at configurable intervals, optimized based on the user's authentication status (registered vs. anonymous user).
|
|
|
|
* **Historical Data Analysis:** Allows for the download and visualization of flight data for a past time range, enabling users to define the area of interest and the sampling interval.
|
|
|
|
* **Interactive and Intelligent Map:**
|
|
* A fully interactive, tile-based map with on-disk caching for optimal performance and offline use.
|
|
* Features pan, zoom, and recenter functionalities.
|
|
* Displays aircraft tracks with unique colors for each plane.
|
|
* A dynamic geographical grid (graticule) with meridians and parallels that intelligently adapts to the current zoom level for optimal readability.
|
|
|
|
* **Detailed Data Views:**
|
|
* A quick-look details panel showing essential information for the currently selected aircraft.
|
|
* A full-details window with all static information (from the database) and dynamic data (current flight status), including a dedicated map for the aircraft's complete flight track.
|
|
|
|
* **Advanced Data Logging:**
|
|
* The ability to record an entire monitoring session.
|
|
* Saves the **raw JSON data** received from the provider, ideal for offline analysis and debugging.
|
|
* Automatically generates a summary **report file** containing session metadata and the aircraft count for each query.
|
|
|
|
* **Database Management:**
|
|
* Imports aircraft databases from CSV files through a dedicated progress dialog.
|
|
* Archives flight data into a daily SQLite database for efficient management.
|
|
|
|
* **Customization:**
|
|
* Saves and loads **geographical area profiles** for quick access to common zones of interest.
|
|
* Centralized configuration for easy tuning of API parameters, polling rates, and UI styling.
|
|
|
|
---
|
|
|
|
### Technical Architecture
|
|
|
|
The project is built on a clean, **MVC-like (Model-View-Controller)** architecture with a strong emphasis on the **Separation of Concerns (SoC)**.
|
|
|
|
* **Model:** The data layer completely abstracts the source (e.g., OpenSky) through a **canonical data model** (`CanonicalFlightState`). Dedicated `Adapters` handle communication with external APIs. Storage is managed by SQLite, with separate handling for dynamic and static data.
|
|
|
|
* **View:** The interface, based on **Tkinter (ttk)**, is composed of modular and reusable panels. It acts as a "passive" component, receiving data from the Controller and notifying it of user interactions.
|
|
|
|
* **Controller:** The `AppController` orchestrates the application's workflow. It does not contain business logic itself but delegates to specialized components like `DataProcessors`, `MapCommandHandler`, `RawDataLogger`, and `CleanupManager`.
|
|
|
|
* **Asynchronous Data Flow:** Network operations (API calls) and map rendering are executed in **separate worker threads** to ensure the user interface remains always fluid and responsive. Communication between worker threads and the main GUI thread is handled safely via **queues (`queue.Queue`)**, following best practices for concurrent applications.
|
|
|
|
---
|
|
|
|
### Technology Stack
|
|
|
|
* **Languages:** Python (with type hints for robustness)
|
|
* **GUI:** Tkinter (with modern `ttk` widgets)
|
|
* **Networking:** `requests`
|
|
* **Image Processing:** `Pillow (PIL)`
|
|
* **Geospatial Data:** `mercantile`, `pyproj`
|
|
* **Database:** `sqlite3`
|
|
|
|
---
|
|
|
|
### Future Developments
|
|
|
|
The modular architecture is designed for future expansions, including:
|
|
* Integration of new data sources (e.g., FlightAware, ADSB-Hub).
|
|
* Implementation of a **Playback mode** to review recorded sessions.
|
|
* Creation of dashboards with advanced charts and statistics. |