Rapporto di Qualità della Ricostruzione

Panoramica

MipMapEngine SDK genera un rapporto di qualità dettagliato dopo il completamento delle attività di ricostruzione, contenente informazioni sul dispositivo, efficienza di ricostruzione, impostazioni dei parametri e qualità dei risultati. Il rapporto viene salvato in formato JSON nel file report/report.json, insieme alle miniature di visualizzazione per l'anteprima rapida.

Struttura del Rapporto

1. Informazioni sul Dispositivo

Registra la configurazione hardware utilizzata per la ricostruzione:

Campo	Tipo	Descrizione
cpu_name	string	Nome della CPU
gpu_name	string	Nome della GPU

Esempio:

{
  "cpu_name": "Intel(R) Core(TM) i9-10900K CPU @ 3.70GHz",
  "gpu_name": "NVIDIA GeForce RTX 3080"
}

2. Efficienza della Ricostruzione

Registra il tempo di elaborazione per ogni fase (in minuti):

Campo	Tipo	Descrizione
feature_extraction_time	float	Tempo di estrazione delle caratteristiche
feature_match_time	float	Tempo di corrispondenza delle caratteristiche
sfm_time	float	Tempo di bundle adjustment
at_time	float	Tempo totale AT
reconstruction_time	float	Tempo totale di ricostruzione (escluso AT)

Esempio:

{
  "feature_extraction_time": 12.5,
  "feature_match_time": 8.3,
  "sfm_time": 15.2,
  "at_time": 36.0,
  "reconstruction_time": 48.6
}

3. Parametri di Ricostruzione

Registra i parametri di input dell'attività e la configurazione:

Parametri della Fotocamera

"initial_camera_parameters": [
  {
    "camera_name": "DJI_FC6310",
    "width": 5472,
    "height": 3648,
    "id": 0,
    "parameters": [3850.5, 2736, 1824, -0.02, 0.05, 0.001, -0.001, 0.01]
  }
]

Ordine dell'array dei parametri: [f, cx, cy, k1, k2, p1, p2, k3]

• f: Lunghezza focale
• cx, cy: Coordinate del punto principale
• k1, k2, k3: Coefficienti di distorsione radiale
• p1, p2: Coefficienti di distorsione tangenziale

Altri Parametri

Campo	Tipo	Descrizione
input_camera_count	int	Numero di fotocamere in input
input_image_count	int	Numero di immagini in input
reconstruction_level	int	Livello di ricostruzione (1=Ultra-alto, 2=Alto, 3=Medio)
production_type	string	Tipo di prodotto
max_ram	float	Utilizzo massimo RAM (GB)

Informazioni sul Sistema di Coordinate

"production_cs_3d": {
  "epsg_code": 4326,
  "origin_offset": [0, 0, 0],
  "type": 2
}

Tipi di sistemi di coordinate:

• 0: LocalENU (Est-Nord-Su locale)
• 1: Local (Sistema di coordinate locale)
• 2: Geodetic (Sistema di coordinate geodetico)
• 3: Projected (Sistema di coordinate proiettato)
• 4: ECEF (Centrato sulla Terra-Fisso sulla Terra)

4. Risultati della Ricostruzione

Parametri della Fotocamera dopo AT

Registra i parametri intrinseci ottimizzati della fotocamera:

"AT_camera_parameters": [
  {
    "camera_name": "DJI_FC6310",
    "width": 5472,
    "height": 3648,
    "id": 0,
    "parameters": [3852.1, 2735.8, 1823.6, -0.019, 0.048, 0.0008, -0.0009, 0.009]
  }
]

Differenze di Posizione delle Immagini

Registra l'ottimizzazione della posizione per ogni immagine:

"image_pos_diff": [
  {
    "id": 0,
    "pos_diff": 0.125
  },
  {
    "id": 1,
    "pos_diff": 0.087
  }
]

Metriche di Qualità

Campo	Tipo	Descrizione
removed_image_count	int	Immagini rimosse dopo AT
residual_rmse	float	RMSE dei residui dei punti immagine
tie_point_count	int	Numero di punti di legame
scene_area	float	Area della scena (metri quadrati)
scene_gsd	float	Distanza di campionamento a terra (metri)
flight_height	float	Altezza di volo (metri)
block_count	int	Numero di blocchi di ricostruzione

5. Altre Informazioni

Campo	Tipo	Descrizione
sdk_version	string	Versione SDK

Miniature di Visualizzazione

La cartella thumbnail nella directory del rapporto contiene i seguenti file di visualizzazione:

1. Grafico dei Residui della Fotocamera

camera_{id}_residual.png - Immagine a colori a 24 bit

• Buon risultato di calibrazione: I residui sono simili in dimensione tra le posizioni con direzioni casuali
• Cattivo risultato di calibrazione: Grandi residui con evidenti pattern direzionali

suggerimento

Grandi residui non indicano necessariamente una scarsa precisione complessiva, poiché questo riflette solo la precisione interna della fotocamera. La precisione finale dovrebbe considerare in modo completo la precisione delle coordinate dei punti di controllo e la qualità del modello.

2. Mappa di Sovrapposizione

overlap_map.png - Immagine in scala di grigi a 8 bit

• Intervallo dei valori dei pixel: 0-255
• Può essere renderizzata come mappa a colori per mostrare la distribuzione della sovrapposizione
• Utilizzata per valutare la progettazione del percorso di volo e la qualità della copertura delle immagini

3. Miniatura dell'Area di Rilevamento

rgb_thumbnail.jpg - Immagine a colori a 32 bit

• Per anteprima rapida del progetto
• Mostra l'estensione dell'area di rilevamento e i risultati della ricostruzione

Esempi di Interpretazione del Rapporto

Esempio di Rapporto Completo

{
  "cpu_name": "Intel(R) Core(TM) i9-10900K CPU @ 3.70GHz",
  "gpu_name": "NVIDIA GeForce RTX 3080",
  "feature_extraction_time": 12.5,
  "feature_match_time": 8.3,
  "sfm_time": 15.2,
  "at_time": 36.0,
  "reconstruction_time": 48.6,
  "initial_camera_parameters": [{
    "camera_name": "DJI_FC6310",
    "width": 5472,
    "height": 3648,
    "id": 0,
    "parameters": [3850.5, 2736, 1824, -0.02, 0.05, 0.001, -0.001, 0.01]
  }],
  "input_camera_count": 1,
  "input_image_count": 156,
  "reconstruction_level": 2,
  "production_type": "all",
  "production_cs_3d": {
    "epsg_code": 4326,
    "origin_offset": [0, 0, 0],
    "type": 2
  },
  "production_cs_2d": {
    "epsg_code": 3857,
    "origin_offset": [0, 0, 0],
    "type": 3
  },
  "max_ram": 28.5,
  "AT_camera_parameters": [{
    "camera_name": "DJI_FC6310",
    "width": 5472,
    "height": 3648,
    "id": 0,
    "parameters": [3852.1, 2735.8, 1823.6, -0.019, 0.048, 0.0008, -0.0009, 0.009]
  }],
  "removed_image_count": 2,
  "residual_rmse": 0.68,
  "tie_point_count": 125840,
  "scene_area": 850000.0,
  "scene_gsd": 0.025,
  "flight_height": 120.5,
  "block_count": 1,
  "sdk_version": "3.0.1"
}

Metriche di Valutazione della Qualità

Standard di Qualità Eccellente

• residual_rmse < 1.0 pixel
• removed_image_count / input_image_count < 5%
• tie_point_count > 10000
• Differenza di posizione media < 0.5 metri

Situazioni che Richiedono Attenzione

• residual_rmse > 2.0 pixel: Possibili errori sistematici
• removed_image_count > 10%: Problemi di qualità dell'immagine o sovrapposizione
• tie_point_count < 5000: Punti caratteristici insufficienti, influisce sulla precisione

Strumenti di Analisi del Rapporto

Esempio di Analisi Python

import json
import numpy as np

def analyze_quality_report(report_path):
    with open(report_path, 'r', encoding='utf-8') as f:
        report = json.load(f)
    
    # Calcola metriche di efficienza
    total_time = report['at_time'] + report['reconstruction_time']
    images_per_minute = report['input_image_count'] / total_time
    
    # Calcola metriche di qualità
    removal_rate = report['removed_image_count'] / report['input_image_count']
    avg_pos_diff = np.mean([item['pos_diff'] for item in report['image_pos_diff']])
    
    # Genera rapporto di analisi
    analysis = {
        'efficiency': {
            'total_time_minutes': total_time,
            'images_per_minute': images_per_minute,
            'area_per_hour': report['scene_area'] / (total_time / 60)
        },
        'quality': {
            'residual_rmse': report['residual_rmse'],
            'removal_rate_percent': removal_rate * 100,
            'avg_position_diff_meters': avg_pos_diff,
            'tie_points_per_image': report['tie_point_count'] / report['input_image_count']
        },
        'scale': {
            'area_sqm': report['scene_area'],
            'gsd_cm': report['scene_gsd'] * 100,
            'flight_height_m': report['flight_height']
        }
    }
    
    return analysis

# Esempio di utilizzo
analysis = analyze_quality_report('report/report.json')
print(f"Efficienza di elaborazione: {analysis['efficiency']['images_per_minute']:.1f} immagini/minuto")
print(f"Residuo medio: {analysis['quality']['residual_rmse']:.2f} pixel")
print(f"Risoluzione a terra: {analysis['scale']['gsd_cm']:.1f} cm")

Visualizzazione del Rapporto di Qualità

import matplotlib.pyplot as plt
from PIL import Image

def visualize_quality_report(report_dir):
    # Leggi dati del rapporto
    with open(f'{report_dir}/report.json', 'r') as f:
        report = json.load(f)
    
    # Crea grafici
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    
    # 1. Grafico a torta della distribuzione del tempo
    times = [
        report['feature_extraction_time'],
        report['feature_match_time'],
        report['sfm_time'],
        report['reconstruction_time']
    ]
    labels = ['Estrazione Caratteristiche', 'Corrispondenza Caratteristiche', 'Bundle Adjustment', 'Ricostruzione 3D']
    axes[0, 0].pie(times, labels=labels, autopct='%1.1f%%')
    axes[0, 0].set_title('Distribuzione del Tempo di Elaborazione')
    
    # 2. Istogramma differenza di posizione
    pos_diffs = [item['pos_diff'] for item in report['image_pos_diff']]
    axes[0, 1].hist(pos_diffs, bins=20, edgecolor='black')
    axes[0, 1].set_xlabel('Differenza di Posizione (metri)')
    axes[0, 1].set_ylabel('Numero di Immagini')
    axes[0, 1].set_title('Distribuzione Ottimizzazione Posizione Immagini')
    
    # 3. Mappa di sovrapposizione
    overlap_img = Image.open(f'{report_dir}/thumbnail/overlap_map.png')
    axes[1, 0].imshow(overlap_img, cmap='jet')
    axes[1, 0].set_title('Distribuzione Sovrapposizione Immagini')
    axes[1, 0].axis('off')
    
    # 4. Testo metriche chiave
    metrics_text = f"""
    Immagini di input: {report['input_image_count']}
    Immagini rimosse: {report['removed_image_count']}
    RMSE residui: {report['residual_rmse']:.2f} px
    Punti di legame: {report['tie_point_count']:,}
    Area della scena: {report['scene_area']/10000:.1f} ettari
    Risoluzione a terra: {report['scene_gsd']*100:.1f} cm
    """
    axes[1, 1].text(0.1, 0.5, metrics_text, fontsize=12, 
                    verticalalignment='center', family='monospace')
    axes[1, 1].set_title('Metriche Chiave di Qualità')
    axes[1, 1].axis('off')
    
    plt.tight_layout()
    plt.savefig('quality_report_summary.png', dpi=150)
    plt.show()

Controllo Automatico della Qualità

Configurazione delle Soglie di Qualità

QUALITY_THRESHOLDS = {
    'excellent': {
        'residual_rmse': 0.5,
        'removal_rate': 0.02,
        'tie_points_per_image': 1000,
        'pos_diff_avg': 0.1
    },
    'good': {
        'residual_rmse': 1.0,
        'removal_rate': 0.05,
        'tie_points_per_image': 500,
        'pos_diff_avg': 0.5
    },
    'acceptable': {
        'residual_rmse': 2.0,
        'removal_rate': 0.10,
        'tie_points_per_image': 200,
        'pos_diff_avg': 1.0
    }
}

def assess_quality(report):
    """Valuta automaticamente il livello di qualità della ricostruzione"""
    
    # Calcola metriche
    removal_rate = report['removed_image_count'] / report['input_image_count']
    tie_points_per_image = report['tie_point_count'] / report['input_image_count']
    pos_diff_avg = np.mean([item['pos_diff'] for item in report['image_pos_diff']])
    
    # Valuta livello
    for level, thresholds in QUALITY_THRESHOLDS.items():
        if (report['residual_rmse'] <= thresholds['residual_rmse'] and
            removal_rate <= thresholds['removal_rate'] and
            tie_points_per_image >= thresholds['tie_points_per_image'] and
            pos_diff_avg <= thresholds['pos_diff_avg']):
            return level
    
    return 'poor'

Applicazioni di Integrazione dei Rapporti

Monitoraggio della Qualità dell'Elaborazione in Batch

def batch_quality_monitor(project_dirs):
    """Monitoraggio qualità progetti in batch"""
    
    results = []
    
    for project_dir in project_dirs:
        report_path = os.path.join(project_dir, 'report/report.json')
        
        if os.path.exists(report_path):
            with open(report_path, 'r') as f:
                report = json.load(f)
            
            quality_level = assess_quality(report)
            
            results.append({
                'project': project_dir,
                'images': report['input_image_count'],
                'area': report['scene_area'],
                'gsd': report['scene_gsd'],
                'rmse': report['residual_rmse'],
                'quality': quality_level,
                'time': report['at_time'] + report['reconstruction_time']
            })
    
    # Genera rapporto di riepilogo
    df = pd.DataFrame(results)
    df.to_csv('batch_quality_report.csv', index=False)
    
    # Statistiche
    print(f"Progetti totali: {len(results)}")
    print(f"Eccellente: {len(df[df['quality'] == 'excellent'])}")
    print(f"Buono: {len(df[df['quality'] == 'good'])}")
    print(f"Accettabile: {len(df[df['quality'] == 'acceptable'])}")
    print(f"Scarso: {len(df[df['quality'] == 'poor'])}")
    
    return df

Migliori Pratiche

1. Controlli regolari dei rapporti: Rivedere le metriche di qualità dopo ogni ricostruzione
2. Stabilire baseline: Registrare metriche di qualità da progetti tipici come riferimenti
3. Avvisi di anomalie: Configurare script automatizzati per rilevare metriche anomale
4. Analisi delle tendenze: Tracciare le tendenze delle metriche di qualità nel tempo
5. Suggerimenti di ottimizzazione: Regolare i parametri di acquisizione ed elaborazione in base alle metriche del rapporto

---

Suggerimento: Il rapporto di qualità è uno strumento importante per valutare e ottimizzare i flussi di lavoro di ricostruzione. Si consiglia di integrarlo nei flussi di lavoro automatizzati.