VALLONGOL/SXXXXXXX_RadarDataReader
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

update manual

Browse Source
This commit is contained in:
VALLONGOL 2025-07-15 15:03:14 +02:00
parent 41fffa2b2f
commit c467509717
3 changed files with 142 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

139
doc/English-manual.md
View File

@ -1,105 +1,106 @@
## English
### **User Manual - Radar Data Reader & Processor (v2.0)**
### **User Manual - Radar Data Reader & Processor**
#### **1. Introduction: A Complete Workflow**
#### **1. Introduction**
Welcome to the Radar Data Reader & Processor. This tool is designed to guide you through a complete workflow for radar data analysis, transforming raw flight recordings into structured, analysis-ready data.
This manual provides a comprehensive guide to using the Radar Data Reader & Processor application. The application is designed to orchestrate an entire radar data analysis workflow, from raw recordings to final data extraction, by solving three main problems:
1. **Flight Analysis**: Analyze an entire recorded flight session (`.rec` files) to automatically identify and summarize significant operational segments.
2. **Data Export and Processing**: Extract specific data from the generated flight segments (`.out` files) into standard formats (CSV, JSON) using fully customizable export profiles.
3. **Manual Conversion**: Provide a controlled interface for the `g_reconvert.exe` command-line utility for manual or specific conversions.
The application is organized to follow a logical, three-phase path:
#### **2. System Requirements**
1. **Phase 1: Flight Analysis**: Start with an entire folder of `.rec` files to automatically identify and summarize the flight's significant operational segments.
2. **Phase 2: Segment Export**: Once the segments of interest are identified, this phase extracts them, creating raw data files (`.out`, video, etc.) for each one.
3. **Phase 3: Data Processing**: The final step is to batch-process the exported segments to extract the desired numerical values into standard formats (CSV, JSON) using custom profiles.
* A Python 3 environment.
* Required Python libraries (e.g., `pandas`, `numpy`).
* The **`g_reconvert.exe`** executable must be accessible on the system. The application is a wrapper and depends on this file for its core functionalities.
This manual will guide you through each phase.
#### **3. Initial Setup**
#### **2. Initial Setup (Mandatory Step)**
On first launch, the application creates a `config/config.json` file in its directory. It is **critical** to configure the application correctly before use.
Before using the application, it is **critical** to specify the location of the `g_reconvert.exe` executable, which the application depends on.
1. Start the application.
1. Launch the application.
2. Navigate to the **"4. REC to OUT Converter"** tab.
3. Click the **"g_reconverter Advanced Config..."** button.
4. In the new window, the first field is **"Executable Path"**. Click **"Browse..."** and select the exact location of your `g_reconvert.exe` file.
5. Click **"Save & Close"**.
4. In the window that opens, the first field is **"Executable Path"**. Click **"Browse..."** and select the exact location of your `g_reconvert.exe` file.
5. Click **"Save & Close"**. The configuration will be saved for future use.
Without this step, none of the features that rely on `g_reconvert.exe` (Flight Analysis, Conversion) will work.
#### **4. Interface Guide**
The main interface has been reorganized to follow a logical workflow through its tabs:
1. **`1. Flight Analyzer`**: The starting point. Analyzes an entire flight folder, summarizes segments, and allows you to export the raw data of the segments of interest.
2. **`2. Segment Processor`**: The second step. Batch-processes the `.out` files of segments exported from the first tab to extract data into CSV/JSON.
3. **`3. Single OUT Processor`**: For detailed analysis of a single, arbitrary `.out` file.
4. **`4. REC to OUT Converter`**: For manual conversions from `.rec` to `.out`.
The window also includes a **Log Console** for real-time messages and a **Status Bar** to indicate the current state.
**Without this step, the main features of the application will not work.**
---
### **Main Workflow**
### **Guide to the Main Workflow**
#### **5. Step 1: Flight Analysis and Segment Export (Tab "Flight Analyzer")**
This section describes the most common and powerful use case for the application.
This is the primary feature to begin an analysis.
#### **3. Phase 1 & 2: Flight Analysis and Segment Export (Tab `1. Flight Analyzer`)**
This is your command center for starting a new analysis. Here, you will identify and export the key moments of the flight.
**Goal**: To turn a folder full of `.rec` files into a list of operational segments and generate the raw data for the ones you are interested in.
**Steps:**
1. **Select Flight Folder**: Click **"Browse..."** next to "Recordings Folder" and select the folder containing the complete sequence of `.rec` files for the flight.
2. **Name the Flight**: Enter an identifying name for the flight in the "Flight Name" field. This name will be used to create a dedicated workspace folder.
3. **Start Analysis**: Click **"Start Flight Analysis"**. The application will run `g_reconvert.exe` in the background to analyze all files. This process may take some time.
4. **View Results**: Upon completion, the "Flight Summary & Segments" table will be populated with a summary of all operational segments found, showing modes, durations, and file references.
5. **Export Segments**: Select one or more segments from the table and click **"Export Selected Segment(s)"**. The application will create a subfolder for each selected segment within the flight's workspace folder, containing an `.out` file and other ancillary files (video, GPS, etc.).
2. **Name the Flight**: Enter a unique identifier for the flight in the "Flight Name" field (e.g., `FlightTest_May25`). This name will be used to create a dedicated workspace folder (`flight_workspace/FlightTest_May25`) where all results will be saved.
3. **Start Preliminary Analysis**: Click **"Start Flight Analysis"**. The application will run `g_reconvert.exe` in the background to analyze all files, generate a text report, and create a full-mission video. This process may take several minutes.
4. **View Results**: Upon completion, the "Flight Summary & Segments" table will be populated with a summary of all operational segments found, showing modes, durations, and reference files.
5. **Export Segments of Interest**:
* Select one or more segments from the table that you wish to analyze in detail.
* Click **"Export Selected Segment(s)"**.
* The application will create a subfolder for each selected segment within the flight's workspace. Each subfolder will contain an `.out` file with the raw data for that segment, along with other ancillary files (segment video, GPS track, etc.).
#### **6. Step 2: Batch Processing of Segments (Tab "Segment Processor")**
**Outcome of this phase**: You now have a well-organized workspace folder with a flight summary and subfolders containing raw data ready for extraction.
After exporting segments, this tab allows you to extract data from all of them in a single operation.
#### **4. Phase 3: Data Extraction from Segments (Tab `2. Segment Processor`)**
1. **Load Segments**: Click **"Load Exported Segments from Current Flight"**. The table will be populated with the previously exported segments. A "Ready" status indicates the segment is ready for processing.
2. **Select Segments**: Select the segments you wish to process. You can use the "Select All Ready" and "Select None" buttons to speed up selection.
3. **Configure Output**:
* **Output Directory**: Choose the final destination folder for your CSV and JSON files.
* **Formats and Profiles**: Enable CSV and/or JSON export by checking the respective boxes and select an **Export Profile** for each.
* **Additional Options**: Configure options such as creating separate folders for each analysis or the CSV format.
4. **Start Processing**: Click **"Process Selected Segments"**. The application will analyze each selected `.out` file and create the corresponding data files in the output directory. The progress bar will show the current status.
Now that you have your exported segments, it's time to extract the numerical data you need.
**Goal**: To batch-process the `.out` files from the exported segments to generate CSV or JSON files based on custom profiles.
**Steps:**
1. **Load Exported Segments**: Click **"Load Exported Segments from Current Flight"**. The table will be populated with the segments found in the current flight's workspace.
* Segments ready for processing will have a **"Ready"** status (in green).
* Segments you saw in the previous tab but have not yet exported will have a **"Not Exported"** status (in gray) and will not be selectable.
2. **Configure the Output**:
* **Output Directory**: Choose a **dedicated** destination folder for your final data files (e.g., `C:/Final_Analysis/FlightTest_May25`).
* **Formats and Profiles**: Enable CSV and/or JSON export by checking the corresponding boxes and select an **Export Profile** for each. (See Section 6 for creating profiles).
* **Folder Structure**: Check **"Create a separate folder for each segment's analysis"** if you want each analysis file (e.g., `segment_A.csv`) to be saved in its own subfolder. Leave it unchecked to have all analysis files in the same directory.
3. **Select and Start**:
* Select the "Ready" segments you want to process from the table.
* Click **"Process Selected Segments"**.
4. **View the Results**: The application will process each segment, generating the CSV/JSON files in the output directory you specified. You can monitor the progress from the progress bar and the console.
**Outcome of this phase**: You have obtained clean, structured data files, ready to be imported into MATLAB, Python, Excel, or other analysis tools.
---
### **Additional Features**
### **Supporting and Advanced Features**
#### **7. Single `.out` File Analysis (Tab "Single OUT Processor")**
#### **5. Single `.out` File Analysis (Tab `3. Single OUT Processor`)**
This tab is useful for analyzing an isolated `.out` file, not necessarily tied to a full flight analysis.
Use this tab when you have a single `.out` file you want to analyze quickly, outside of a full flight analysis workflow. The functionality is identical to Phase 3 but applied to a single file.
1. **Select Input File**: Click **"Browse..."** and select the `.out` file to analyze.
2. **Configure Output**: Set the output directory, base filename, and export profiles.
3. **Start Processing**: Click **"Process .out File"**. Data will be extracted according to the chosen profile.
#### **6. Creating and Managing Export Profiles**
#### **8. Advanced Management: The Export Profile Editor**
The Profile Editor (`File -> Manage Export Profiles...`) is the heart of data extraction customization.
To access the editor, go to `File -> Manage Export Profiles...`.
* **Left Panel (Profiles)**: Create new profiles (e.g., "Thermal_Analysis", "Tracking_Performance") or delete old ones.
* **Center Panel (Available Fields)**: Browse the tree of all data structures and fields the application can read. Fields marked with `(Enum)` can be translated into human-readable text. Select a field and click **`>>`** to add it to the current profile.
* **Right Panel (Selected Fields for Profile)**:
* View and reorder the fields of the selected profile using the **Up/Down** buttons.
* **"Translate" Column**: This is a powerful feature. By clicking the checkbox in this column, you can decide whether an `(Enum)` field should be exported as its raw numerical value (e.g., `15`) or its text representation (e.g., `STT_MASTER_MODE`), making your CSV files instantly readable.
* **Left Pane (Profiles)**: Manage profiles (create, delete, select).
* **Middle Pane (Available Fields)**: Displays a tree of all extractable data fields. Fields marked with `(Enum)` can be translated into human-readable formats. Select a field and use **`>>`** to add it.
* **Right Pane (Selected Fields for Profile)**: Shows the fields for the current profile. Use **`<<`** to remove them and **Up/Down** to reorder.
* **"Translate" Column**: Click the cell in this column to toggle the translation of a value from numeric to text (e.g., from `15` to `STT_MASTER_MODE`).
#### **7. Manual Conversion (Tab `4. REC to OUT Converter`)**
#### **9. Manual `.rec` -> `.out` Conversion (Tab "REC to OUT Converter")**
This tab provides a simple frontend for `g_reconvert.exe`, useful for quick conversions or for testing specific parameter combinations without going through the entire analysis workflow.
This tab offers direct control over `g_reconvert.exe` for simple conversions.
#### **8. Troubleshooting and Frequently Asked Questions (FAQ)**
1. **Select Input**: Choose the first `.rec` file and the number of files to concatenate.
2. **Choose Output**: Define the destination folder.
3. **Start Conversion**: Click **"Convert REC to OUT"**.
* **Q: The application starts, but no functions seem to work. What should I do?**
* **A**: You have almost certainly not set the path to `g_reconvert.exe`. Carefully follow the steps in the "Initial Setup" section.
#### **10. Frequently Asked Questions (FAQ)**
* **Q: Why does exporting a segment seem to fail or crash?**
* **A**: `g_reconvert.exe` can be sensitive to its input parameters. The current export logic relies on specifying the number of `.rec` files to process. If the problem persists, ensure the `.rec` files are not corrupted.
* **Q: Why do none of the features work?**
* **A**: Ensure you have correctly set the path to `g_reconvert.exe` as described in the "Initial Setup" section.
* **Q: When I start an analysis, a second window of my application opens. Is this normal?**
* **A**: This is a known behavior when running an application packaged with PyInstaller. While the current code should prevent this issue using `multiprocessing.freeze_support()`, if it occurs, it indicates that the new process was not handled correctly.
* **Q: Why does a segment in the "Segment Processor" tab appear gray and unselectable?**
* **A**: This means the segment has not yet been exported (or the export failed). Go back to the "Flight Analyzer" tab, select that segment, and click "Export Selected Segment(s)".
* **Q: How can I add a field that I don't see in the "Available Fields" tree?**
* **A**: This requires a source code modification. You will need to define the new data structure in the `radar_data_reader/core/structures` package and update the parsing logic in `radar_data_reader/core/struct_parser.py`.
* **Q: Can I add a data field that I don't see in the "Available Fields" tree?**
* **A**: Yes, but it requires modifying the source code. You will need to define the new C-style data structure in the `radar_data_reader/core/structures` package and teach the `struct_parser.py` how to read it from the binary file.

137
doc/Italian-manual.md
View File

@ -1,105 +1,106 @@
## Italiano
### **Manuale Utente - Radar Data Reader & Processor (v2.0)**
### **Manuale Utente - Radar Data Reader & Processor**
#### **1. Introduzione: Un Flusso di Lavoro Completo**
#### **1. Introduzione**
Benvenuto nel Radar Data Reader & Processor. Questo strumento è stato progettato per guidarti in un flusso di lavoro completo per l'analisi dei dati radar, trasformando le registrazioni grezze di un intero volo in dati strutturati e pronti per l'analisi.
Questo manuale fornisce una guida completa all'utilizzo dell'applicazione Radar Data Reader & Processor. L'applicazione è progettata per orchestrare un intero flusso di lavoro di analisi dei dati radar, dalla registrazione grezza all'estrazione finale dei dati, risolvendo tre problemi principali:
1. **Analisi di Volo**: Analizzare un'intera sessione di volo registrata (`.rec` files) per identificare e riassumere automaticamente i segmenti operativi significativi.
2. **Esportazione e Processamento Dati**: Estrarre dati specifici dai segmenti di volo generati (`.out` files) in formati standard (CSV, JSON) utilizzando profili di esportazione personalizzabili.
3. **Conversione Manuale**: Fornire un'interfaccia controllata per l'utility a riga di comando `g_reconvert.exe` per conversioni manuali o specifiche.
L'applicazione è organizzata per seguire un percorso logico in tre fasi principali:
#### **2. Requisiti di Sistema**
1. **Fase 1: Analisi del Volo (Flight Analysis)**: Si parte da un'intera cartella di file `.rec` per identificare e riassumere automaticamente i segmenti operativi significativi del volo.
2. **Fase 2: Esportazione dei Segmenti**: Una volta identificati i segmenti di interesse, questa fase li estrae, creando i dati grezzi (`.out`, video, etc.) per ciascuno di essi.
3. **Fase 3: Processamento dei Dati (Data Processing)**: L'ultimo passo consiste nell'analizzare in blocco i segmenti esportati per estrarre i valori numerici desiderati in formati standard (CSV, JSON) utilizzando profili personalizzati.
* Un ambiente Python 3 installato.
* Le librerie Python richieste (es. `pandas`, `numpy`).
* L'eseguibile **`g_reconvert.exe`** deve essere accessibile dal sistema. L'applicazione è un wrapper e dipende da questo file per le sue funzionalità principali.
Questo manuale ti guiderà attraverso ogni fase.
#### **3. Configurazione Iniziale**
#### **2. Configurazione Iniziale (Passo Obbligatorio)**
Al primo avvio, l'applicazione crea un file `config/config.json` nella sua directory. È **fondamentale** configurare correttamente l'applicazione prima dell'uso.
Prima di utilizzare l'applicazione, è **fondamentale** indicare dove si trova l'eseguibile `g_reconvert.exe`, da cui l'applicazione dipende.
1. Avvia l'applicazione.
2. Vai alla scheda **"4. REC to OUT Converter"**.
3. Clicca sul pulsante **"g_reconverter Advanced Config..."**.
4. Nella finestra che si apre, il primo campo è **"Executable Path"**. Clicca su **"Browse..."** e seleziona la posizione esatta del tuo file `g_reconvert.exe`.
5. Clicca su **"Save & Close"**.
5. Clicca su **"Save & Close"**. La configurazione verrà salvata per gli usi futuri.
Senza questo passaggio, nessuna delle funzionalità che dipendono da `g_reconvert.exe` (Analisi di Volo, Conversione) funzionerà.
#### **4. Guida all'Interfaccia**
L'interfaccia principale è stata riorganizzata per seguire un flusso di lavoro logico attraverso le sue schede (tab):
1. **`1. Flight Analyzer`**: Il punto di partenza. Analizza un'intera cartella di volo, riassume i segmenti e permette di esportare i dati grezzi dei segmenti di interesse.
2. **`2. Segment Processor`**: Il secondo passo. Processa in blocco i file `.out` dei segmenti esportati dalla prima tab per estrarre i dati in CSV/JSON.
3. **`3. Single OUT Processor`**: Per l'analisi dettagliata di un singolo file `.out` arbitrario.
4. **`4. REC to OUT Converter`**: Per conversioni manuali da `.rec` a `.out`.
La finestra include anche una **Log Console** per messaggi in tempo reale e una **Status Bar** per indicare lo stato corrente.
**Senza questo passaggio, le funzioni principali dell'applicazione non funzioneranno.**
---
### **Flusso di Lavoro Principale**
### **Guida al Flusso di Lavoro Principale**
#### **5. Passo 1: Analisi del Volo e Esportazione Segmenti (Tab "Flight Analyzer")**
Questa sezione descrive il caso d'uso più comune e potente dell'applicazione.
Questa è la funzionalità principale per iniziare un'analisi.
#### **3. Fase 1 & 2: Analisi del Volo ed Esportazione Segmenti (Tab `1. Flight Analyzer`)**
1. **Seleziona Cartella del Volo**: Clicca su **"Browse..."** accanto a "Recordings Folder" e seleziona la cartella contenente la sequenza completa di file `.rec` del volo.
2. **Dai un Nome al Volo**: Inserisci un nome identificativo per il volo nel campo "Flight Name". Questo nome verrà usato per creare una cartella di lavoro dedicata.
3. **Avvia Analisi**: Clicca **"Start Flight Analysis"**. L'applicazione eseguirà `g_reconvert.exe` in background per analizzare tutti i file. Questo processo potrebbe richiedere del tempo.
4. **Visualizza Risultati**: Al termine, la tabella "Flight Summary & Segments" verrà popolata con un riepilogo di tutti i segmenti operativi trovati, mostrando modalità, durate e file di riferimento.
5. **Esporta Segmenti**: Seleziona uno o più segmenti dalla tabella e clicca su **"Export Selected Segment(s)"**. L'applicazione creerà una sottocartella per ogni segmento selezionato all'interno della cartella di lavoro del volo, contenente un file `.out` e altri file ausiliari (video, GPS, etc.).
Questa è la tua centrale di comando per iniziare una nuova analisi. Qui identificherai ed esporterai i momenti salienti del volo.
#### **6. Passo 2: Processamento in Blocco dei Segmenti (Tab "Segment Processor")**
**Obiettivo**: Trasformare una cartella piena di file `.rec` in un elenco di segmenti operativi e generare i dati grezzi per quelli che ti interessano.
Dopo aver esportato i segmenti, questa tab permette di estrarre i dati da tutti loro in una sola operazione.
**Passaggi:**
1. **Seleziona Cartella del Volo**: Clicca su **"Browse..."** e seleziona la cartella contenente la sequenza completa di file `.rec`.
2. **Dai un Nome al Volo**: Inserisci un nome unico per il volo (es. `VoloTest_25Maggio`). Questo nome verrà usato per creare una cartella di lavoro dedicata (`flight_workspace/VoloTest_25Maggio`) dove verranno salvati tutti i risultati.
3. **Avvia Analisi Preliminare**: Clicca su **"Start Flight Analysis"**. L'applicazione eseguirà `g_reconvert.exe` in background per analizzare l'intero volo, generare un report testuale e creare un video completo della missione. Questo processo può richiedere diversi minuti.
4. **Visualizza i Segmenti**: Al termine, la tabella "Flight Summary & Segments" si popolerà con un riepilogo di tutti i segmenti operativi trovati (cambi di modalità, scala, etc.).
5. **Esporta i Segmenti di Interesse**:
* Seleziona dalla tabella uno o più segmenti che desideri analizzare in dettaglio.
* Clicca su **"Export Selected Segment(s)"**.
* L'applicazione creerà una sottocartella per ogni segmento selezionato all'interno della cartella di lavoro del volo. Ogni sottocartella conterrà un file `.out` con i dati grezzi di quel segmento e altri file ausiliari (video del segmento, traccia GPS, etc.).
1. **Carica Segmenti**: Clicca su **"Load Exported Segments from Current Flight"**. La tabella si popolerà con i segmenti precedentemente esportati. Lo stato "Ready" indica che il segmento è pronto per il processing.
2. **Seleziona Segmenti**: Seleziona i segmenti che vuoi processare. Puoi usare i bottoni "Select All Ready" e "Select None" per velocizzare la selezione.
3. **Configura Output**:
* **Output Directory**: Scegli la cartella di destinazione finale per i tuoi file CSV e JSON.
* **Formati e Profili**: Abilita l'esportazione CSV e/o JSON spuntando le relative caselle e seleziona un **Profilo di Esportazione** per ciascuno.
* **Opzioni Aggiuntive**: Configura opzioni come la creazione di cartelle separate per ogni analisi o il formato del CSV.
4. **Avvia Processo**: Clicca su **"Process Selected Segments"**. L'applicazione analizzerà ogni file `.out` selezionato e creerà i file di dati corrispondenti nella directory di output. La barra di progresso mostrerà l'avanzamento.
**Risultato di questa fase**: Hai una cartella di lavoro ben organizzata, con un sommario del volo e sottocartelle contenenti i dati grezzi pronti per l'estrazione.
#### **4. Fase 3: Estrazione Dati dai Segmenti (Tab `2. Segment Processor`)**
Ora che hai i segmenti esportati, è il momento di estrarre i dati numerici che ti servono.
**Obiettivo**: Processare in blocco i file `.out` dei segmenti esportati per generare file CSV o JSON basati su profili personalizzati.
**Passaggi:**
1. **Carica Segmenti Esportati**: Clicca su **"Load Exported Segments from Current Flight"**. La tabella si popolerà con i segmenti trovati nella cartella di lavoro del volo attuale.
* I segmenti pronti per l'analisi avranno lo stato **"Ready"** (in verde).
* I segmenti che hai visto nella tab precedente ma che non hai ancora esportato avranno lo stato **"Not Exported"** (in grigio) e non saranno selezionabili.
2. **Configura l'Output**:
* **Output Directory**: Scegli una cartella di destinazione **dedicata** per i file di dati finali (es. `C:/Analisi_Finali/VoloTest_25Maggio`).
* **Profili di Esportazione**: Seleziona dai menu a tendina i profili CSV e/o JSON che definiscono quali dati estrarre. (Vedi sezione 6 per la creazione dei profili).
* **Struttura Cartelle**: Spunta **"Create a separate folder for each segment's analysis"** se vuoi che ogni file di analisi (es. `segmento_A.csv`) venga salvato in una sua sottocartella. Lascialo deselezionato per avere tutti i file di analisi nella stessa directory.
3. **Seleziona e Avvia**:
* Seleziona dalla tabella i segmenti con stato "Ready" che vuoi processare.
* Clicca su **"Process Selected Segments"**.
4. **Visualizza i Risultati**: L'applicazione processerà ogni segmento, generando i file CSV/JSON nella cartella di output che hai specificato. Puoi monitorare l'avanzamento dalla barra di progresso e dalla console.
**Risultato di questa fase**: Hai ottenuto i file di dati puliti e strutturati, pronti per essere importati in MATLAB, Python, Excel o altri strumenti di analisi.
---
### **Funzionalità Aggiuntive**
### **Funzionalità di Supporto e Avanzate**
#### **7. Analisi di un Singolo File `.out` (Tab "Single OUT Processor")**
#### **5. Analisi di un Singolo File `.out` (Tab `3. Single OUT Processor`)**
Questa scheda è utile per analizzare un file `.out` isolato, non necessariamente legato a un'analisi di volo completa.
Usa questa tab quando hai un singolo file `.out` che vuoi analizzare rapidamente, al di fuori di un'analisi di volo completa. Il funzionamento è identico alla Fase 3, ma applicato a un solo file.
1. **Seleziona File di Input**: Clicca **"Browse..."** e seleziona il file `.out` da analizzare.
2. **Configura Output**: Imposta la directory di output, il nome del file base e i profili di esportazione.
3. **Avvia Processo**: Clicca **"Process .out File"**. I dati verranno estratti secondo il profilo scelto.
#### **6. Creare e Gestire i Profili di Esportazione**
#### **8. Gestione Avanzata: L'Editor dei Profili di Esportazione**
L'Editor dei Profili (`File -> Manage Export Profiles...`) è il cuore della personalizzazione dell'estrazione dati.
Per accedere all'editor, vai su `File -> Manage Export Profiles...`.
* **Pannello Sinistro (Profiles)**: Crea nuovi profili (es. "Analisi_Termica", "Tracking_Performance") o elimina quelli vecchi.
* **Pannello Centrale (Available Fields)**: Esplora l'albero di tutte le strutture dati e i campi che l'applicazione è in grado di leggere. I campi marcati con `(Enum)` possono essere tradotti in testo leggibile. Seleziona un campo e clicca **`>>`** per aggiungerlo al profilo corrente.
* **Pannello Destro (Selected Fields for Profile)**:
* Visualizza e riordina i campi del profilo selezionato con i bottoni **Up/Down**.
* **Colonna "Translate"**: Questa è una funzione potente. Cliccando sulla casella, puoi decidere se un campo `(Enum)` debba essere esportato come il suo valore numerico grezzo (es. `15`) o come la sua rappresentazione testuale (es. `STT_MASTER_MODE`), rendendo i tuoi file CSV immediatamente leggibili.
* **Pannello Sinistro (Profiles)**: Gestisci i profili (crea, elimina, seleziona).
* **Pannello Centrale (Available Fields)**: Visualizza tutti i campi dati estraibili. I campi `(Enum)` possono essere tradotti in formati leggibili. Seleziona un campo e usa **`>>`** per aggiungerlo.
* **Pannello Destro (Selected Fields for Profile)**: Mostra i campi del profilo corrente. Usa **`<<`** per rimuoverli e **Up/Down** per riordinarli.
* **Colonna "Translate"**: Clicca sulla cella in questa colonna per attivare/disattivare la traduzione di un valore da numerico a testuale (es. da `15` a `STT_MASTER_MODE`).
#### **7. Conversione Manuale (Tab `4. REC to OUT Converter`)**
#### **9. Conversione Manuale `.rec` -> `.out` (Tab "REC to OUT Converter")**
Questa tab è un semplice frontend per `g_reconvert.exe`, utile per conversioni rapide o per testare specifiche combinazioni di parametri senza passare per l'intero workflow di analisi.
Questa scheda offre un controllo diretto su `g_reconvert.exe` per semplici conversioni.
#### **8. Troubleshooting e Domande Frequenti (FAQ)**
1. **Seleziona Input**: Scegli il primo file `.rec` e il numero di file da concatenare.
2. **Scegli Output**: Definisci la cartella di destinazione.
3. **Avvia Conversione**: Clicca **"Convert REC to OUT"**.
* **D: L'applicazione si avvia ma nessuna funzione sembra partire. Cosa devo fare?**
* **R**: Quasi certamente non hai configurato il percorso di `g_reconvert.exe`. Segui attentamente i passaggi della sezione "Configurazione Iniziale".
#### **10. Domande Frequenti (FAQ)**
* **D: Perché l'esportazione di un segmento sembra non funzionare o crashare?**
* **R**: `g_reconvert.exe` può essere sensibile ai parametri passati. La logica di esportazione attuale si basa sull'indicazione del numero di file `.rec` da processare. Se il problema persiste, assicurati che i file `.rec` non siano corrotti.
* **D: Perché nessuna funzione sembra funzionare?**
* **R**: Controlla di aver impostato correttamente il percorso di `g_reconvert.exe` come descritto nella sezione "Configurazione Iniziale".
* **D: Quando avvio un'analisi, si apre una seconda finestra della mia applicazione. È normale?**
* **R**: Questo è un comportamento noto quando si esegue l'applicazione da un eseguibile creato con PyInstaller. Sebbene il codice attuale dovrebbe prevenire questo problema tramite `multiprocessing.freeze_support()`, se dovesse verificarsi, è un'indicazione che il nuovo processo non è stato gestito correttamente.
* **D: Perché un segmento nella tab "Segment Processor" appare in grigio e non è selezionabile?**
* **R**: Significa che il segmento non è stato ancora esportato (o l'esportazione non è riuscita). Torna alla tab "Flight Analyzer", seleziona quel segmento e clicca su "Export Selected Segment(s)".
* **D: Come posso aggiungere un campo che non vedo nell'albero "Available Fields"?**
* **R**: Questo richiede una modifica al codice sorgente. Dovrai definire la nuova struttura dati nel package `radar_data_reader/core/structures` e aggiornare la logica di parsing in `radar_data_reader/core/struct_parser.py`.
* **D: Posso aggiungere un campo dati che non vedo nell'Editor dei Profili?**
* **R**: Sì, ma richiede una modifica al codice sorgente. Dovrai definire la nuova struttura dati C-style nel package `radar_data_reader/core/structures` e insegnare al `struct_parser.py` come leggerla dal file binario.

6
radar_data_reader/_version.py
View File

@ -6,10 +6,10 @@
import re
# --- Version Data (Generated) ---
__version__ = "v.0.0.0.41-1-g14d0277"
GIT_COMMIT_HASH = "14d02771f7759faad5264da407c125cdc7a734bb"
__version__ = "v.0.0.0.42-0-g56fb41c"
GIT_COMMIT_HASH = "56fb41c3f8e78e5a59a5aaf56cb2cee135285dca"
GIT_BRANCH = "master"
BUILD_TIMESTAMP = "2025-07-15T12:37:45.493596+00:00"
BUILD_TIMESTAMP = "2025-07-15T12:54:20.374655+00:00"
IS_GIT_REPO = True
# --- Default Values (for comparison or fallback) ---