Rapport de Qualité de Reconstruction

Vue d'ensemble

MipMapEngine SDK génère un rapport de qualité détaillé après l'achèvement des tâches de reconstruction, contenant les informations de l'appareil, l'efficacité de reconstruction, les paramètres de configuration et la qualité des résultats. Le rapport est stocké au format JSON dans le fichier report/report.json, avec des vignettes de visualisation pour un aperçu rapide.

Structure du Rapport

1. Informations sur l'Appareil

Enregistre la configuration matérielle utilisée pour la reconstruction :

Champ	Type	Description
`cpu_name`	string	Nom du CPU
`gpu_name`	string	Nom du GPU

Exemple :

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

2. Efficacité de Reconstruction

Enregistre le temps de traitement pour chaque étape (en minutes) :

Champ	Type	Description
`feature_extraction_time`	float	Temps d'extraction des caractéristiques
`feature_match_time`	float	Temps de correspondance des caractéristiques
`sfm_time`	float	Temps d'ajustement de faisceaux
`at_time`	float	Temps total AT
`reconstruction_time`	float	Temps total de reconstruction (hors AT)

Exemple :

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

3. Paramètres de Reconstruction

Enregistre les paramètres d'entrée de la tâche et la configuration :

Paramètres de Caméra

"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]
  }
]

Ordre du tableau de paramètres : [f, cx, cy, k1, k2, p1, p2, k3]

f : Distance focale
cx, cy : Coordonnées du point principal
k1, k2, k3 : Coefficients de distorsion radiale
p1, p2 : Coefficients de distorsion tangentielle

Autres Paramètres

Champ	Type	Description
`input_camera_count`	int	Nombre de caméras d'entrée
`input_image_count`	int	Nombre d'images d'entrée
`reconstruction_level`	int	Niveau de reconstruction (1=Ultra-élevé, 2=Élevé, 3=Moyen)
`production_type`	string	Type de produit
`max_ram`	float	Utilisation maximale de la RAM (Go)

Informations sur le Système de Coordonnées

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

Types de systèmes de coordonnées :

0 : LocalENU (Est-Nord-Haut local)
1 : Local (Système de coordonnées local)
2 : Geodetic (Système de coordonnées géodésique)
3 : Projected (Système de coordonnées projeté)
4 : ECEF (Centré sur la Terre-Fixe sur la Terre)

4. Résultats de Reconstruction

Paramètres de Caméra après AT

Enregistre les paramètres intrinsèques optimisés de la caméra :

"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]
  }
]

Différences de Position d'Image

Enregistre l'optimisation de position pour chaque image :

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

Métriques de Qualité

Champ	Type	Description
`removed_image_count`	int	Images supprimées après AT
`residual_rmse`	float	RMSE des résidus de points d'image
`tie_point_count`	int	Nombre de points de liaison
`scene_area`	float	Surface de la scène (mètres carrés)
`scene_gsd`	float	Distance d'échantillonnage au sol (mètres)
`flight_height`	float	Hauteur de vol (mètres)
`block_count`	int	Nombre de blocs de reconstruction

5. Autres Informations

Champ	Type	Description
`sdk_version`	string	Version du SDK

Vignettes de Visualisation

Le dossier thumbnail dans le répertoire du rapport contient les fichiers de visualisation suivants :

1. Graphique des Résidus de Caméra

camera_{id}_residual.png - Image couleur 24 bits

Bon résultat de calibrage : Les résidus sont de taille similaire à travers les positions avec des directions aléatoires
Mauvais résultat de calibrage : Grands résidus avec des motifs directionnels évidents

astuce

De grands résidus n'indiquent pas nécessairement une mauvaise précision globale, car cela reflète uniquement la précision interne de la caméra. La précision finale doit prendre en compte de manière globale la précision des coordonnées des points de contrôle et la qualité du modèle.

2. Carte de Chevauchement

overlap_map.png - Image en niveaux de gris 8 bits

Plage de valeur de pixel : 0-255
Peut être rendue en carte couleur pour montrer la distribution du chevauchement
Utilisée pour évaluer la conception de la trajectoire de vol et la qualité de couverture d'image

3. Vignette de la Zone de Levé

rgb_thumbnail.jpg - Image couleur 32 bits

Pour un aperçu rapide du projet
Montre l'étendue de la zone de levé et les résultats de reconstruction

Exemples d'Interprétation du Rapport

Exemple de Rapport Complet

{
  "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"
}

Métriques d'Évaluation de la Qualité

Normes de Qualité Excellente

residual_rmse < 1,0 pixels
removed_image_count / input_image_count < 5%
tie_point_count > 10000
Différence de position moyenne < 0,5 mètres

Situations Nécessitant une Attention

residual_rmse > 2,0 pixels : Erreurs systématiques possibles
removed_image_count > 10% : Problèmes de qualité d'image ou de chevauchement
tie_point_count < 5000 : Points de caractéristiques insuffisants, affectant la précision

Outils d'Analyse de Rapport

Exemple d'Analyse 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)
    
    # Calculer les métriques d'efficacité
    total_time = report['at_time'] + report['reconstruction_time']
    images_per_minute = report['input_image_count'] / total_time
    
    # Calculer les métriques de 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']])
    
    # Générer le rapport d'analyse
    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

# Exemple d'utilisation
analysis = analyze_quality_report('report/report.json')
print(f"Efficacité de traitement : {analysis['efficiency']['images_per_minute']:.1f} images/minute")
print(f"Résidu moyen : {analysis['quality']['residual_rmse']:.2f} pixels")
print(f"Résolution au sol : {analysis['scale']['gsd_cm']:.1f} cm")

Visualisation du Rapport de Qualité

import matplotlib.pyplot as plt
from PIL import Image

def visualize_quality_report(report_dir):
    # Lire les données du rapport
    with open(f'{report_dir}/report.json', 'r') as f:
        report = json.load(f)
    
    # Créer des graphiques
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    
    # 1. Diagramme circulaire de distribution du temps
    times = [
        report['feature_extraction_time'],
        report['feature_match_time'],
        report['sfm_time'],
        report['reconstruction_time']
    ]
    labels = ['Extraction de Caractéristiques', 'Correspondance de Caractéristiques', 'Ajustement de Faisceaux', 'Reconstruction 3D']
    axes[0, 0].pie(times, labels=labels, autopct='%1.1f%%')
    axes[0, 0].set_title('Distribution du Temps de Traitement')
    
    # 2. Histogramme de différence de position
    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('Différence de Position (mètres)')
    axes[0, 1].set_ylabel('Nombre d\'Images')
    axes[0, 1].set_title('Distribution d\'Optimisation de Position d\'Image')
    
    # 3. Carte de chevauchement
    overlap_img = Image.open(f'{report_dir}/thumbnail/overlap_map.png')
    axes[1, 0].imshow(overlap_img, cmap='jet')
    axes[1, 0].set_title('Distribution de Chevauchement d\'Images')
    axes[1, 0].axis('off')
    
    # 4. Texte des métriques clés
    metrics_text = f"""
    Images d'entrée : {report['input_image_count']}
    Images supprimées : {report['removed_image_count']}
    RMSE des résidus : {report['residual_rmse']:.2f} px
    Points de liaison : {report['tie_point_count']:,}
    Surface de la scène : {report['scene_area']/10000:.1f} hectares
    Résolution au sol : {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('Métriques Clés de Qualité')
    axes[1, 1].axis('off')
    
    plt.tight_layout()
    plt.savefig('quality_report_summary.png', dpi=150)
    plt.show()

Vérification Automatique de la Qualité

Configuration des Seuils de 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):
    """Évaluer automatiquement le niveau de qualité de reconstruction"""
    
    # Calculer les métriques
    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']])
    
    # Évaluer le niveau
    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'

Applications d'Intégration de Rapports

Surveillance de la Qualité du Traitement par Lots

def batch_quality_monitor(project_dirs):
    """Surveillance de la qualité des projets par lots"""
    
    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']
            })
    
    # Générer un rapport de synthèse
    df = pd.DataFrame(results)
    df.to_csv('batch_quality_report.csv', index=False)
    
    # Statistiques
    print(f"Total des projets : {len(results)}")
    print(f"Excellent : {len(df[df['quality'] == 'excellent'])}")
    print(f"Bon : {len(df[df['quality'] == 'good'])}")
    print(f"Acceptable : {len(df[df['quality'] == 'acceptable'])}")
    print(f"Médiocre : {len(df[df['quality'] == 'poor'])}")
    
    return df

Meilleures Pratiques

Vérifications régulières des rapports : Examiner les métriques de qualité après chaque reconstruction
Établir des références : Enregistrer les métriques de qualité des projets typiques comme références
Alertes d'anomalies : Configurer des scripts automatisés pour détecter les métriques anormales
Analyse des tendances : Suivre les tendances des métriques de qualité au fil du temps
Suggestions d'optimisation : Ajuster les paramètres de capture et de traitement en fonction des métriques du rapport

Conseil : Le rapport de qualité est un outil important pour évaluer et optimiser les flux de travail de reconstruction. Il est recommandé de l'intégrer dans les flux de travail automatisés.

Vue d'ensemble​

Structure du Rapport​

1. Informations sur l'Appareil​

2. Efficacité de Reconstruction​

3. Paramètres de Reconstruction​

Paramètres de Caméra​

Autres Paramètres​

Informations sur le Système de Coordonnées​

4. Résultats de Reconstruction​

Paramètres de Caméra après AT​

Différences de Position d'Image​

Métriques de Qualité​

5. Autres Informations​

Vignettes de Visualisation​

1. Graphique des Résidus de Caméra​

2. Carte de Chevauchement​

3. Vignette de la Zone de Levé​

Exemples d'Interprétation du Rapport​

Exemple de Rapport Complet​

Métriques d'Évaluation de la Qualité​

Normes de Qualité Excellente​

Situations Nécessitant une Attention​

Outils d'Analyse de Rapport​

Exemple d'Analyse Python​

Visualisation du Rapport de Qualité​

Vérification Automatique de la Qualité​

Configuration des Seuils de Qualité​

Applications d'Intégration de Rapports​

Surveillance de la Qualité du Traitement par Lots​

Meilleures Pratiques​