Rekonstruktions-Qualitätsbericht

Überblick

MipMapEngine SDK generiert nach Abschluss von Rekonstruktionsaufgaben einen detaillierten Qualitätsbericht, der Geräteinformationen, Rekonstruktionseffizienz, Parametereinstellungen und Ergebnisqualität enthält. Der Bericht wird im JSON-Format in der Datei report/report.json gespeichert, zusammen mit Visualisierungs-Thumbnails für die Schnellvorschau.

Berichtsstruktur

1. Geräteinformationen

Zeichnet die für die Rekonstruktion verwendete Hardware-Konfiguration auf:

Feld	Typ	Beschreibung
`cpu_name`	string	CPU-Name
`gpu_name`	string	GPU-Name

Beispiel:

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

2. Rekonstruktionseffizienz

Zeichnet die Verarbeitungszeit für jede Phase auf (in Minuten):

Feld	Typ	Beschreibung
`feature_extraction_time`	float	Feature-Extraktionszeit
`feature_match_time`	float	Feature-Matching-Zeit
`sfm_time`	float	Bundle-Adjustment-Zeit
`at_time`	float	Gesamt-AT-Zeit
`reconstruction_time`	float	Gesamt-Rekonstruktionszeit (ohne AT)

Beispiel:

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

3. Rekonstruktionsparameter

Zeichnet Aufgaben-Eingabeparameter und Konfiguration auf:

Kameraparameter

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

Parameter-Array-Reihenfolge: [f, cx, cy, k1, k2, p1, p2, k3]

f: Brennweite
cx, cy: Hauptpunkt-Koordinaten
k1, k2, k3: Radiale Verzerrungskoeffizienten
p1, p2: Tangentiale Verzerrungskoeffizienten

Weitere Parameter

Feld	Typ	Beschreibung
`input_camera_count`	int	Anzahl der Eingabekameras
`input_image_count`	int	Anzahl der Eingabebilder
`reconstruction_level`	int	Rekonstruktionslevel (1=Ultra-hoch, 2=Hoch, 3=Mittel)
`production_type`	string	Produkttyp
`max_ram`	float	Maximale RAM-Nutzung (GB)

Koordinatensystem-Informationen

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

Koordinatensystem-Typen:

0: LocalENU (Lokales Ost-Nord-Oben)
1: Local (Lokales Koordinatensystem)
2: Geodetic (Geodätisches Koordinatensystem)
3: Projected (Projiziertes Koordinatensystem)
4: ECEF (Erdzentriert-Erdfest)

4. Rekonstruktionsergebnisse

Kameraparameter nach AT

Zeichnet optimierte interne Kameraparameter auf:

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

Bildpositionsunterschiede

Zeichnet Positionsoptimierung für jedes Bild auf:

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

Qualitätsmetriken

Feld	Typ	Beschreibung
`removed_image_count`	int	Nach AT entfernte Bilder
`residual_rmse`	float	Bildpunkt-Residuen-RMSE
`tie_point_count`	int	Anzahl der Verknüpfungspunkte
`scene_area`	float	Szenenfläche (Quadratmeter)
`scene_gsd`	float	Bodenauflösung (Meter)
`flight_height`	float	Flughöhe (Meter)
`block_count`	int	Anzahl der Rekonstruktionsblöcke

5. Weitere Informationen

Feld	Typ	Beschreibung
`sdk_version`	string	SDK-Version

Visualisierungs-Thumbnails

Der Ordner thumbnail im Berichtsverzeichnis enthält die folgenden Visualisierungsdateien:

1. Kamera-Residuen-Plot

camera_{id}_residual.png - 24-Bit-Farbbild

Gutes Kalibrierungsergebnis: Residuen sind in der Größe über Positionen ähnlich mit zufälligen Richtungen
Schlechtes Kalibrierungsergebnis: Große Residuen mit offensichtlichen Richtungsmustern

tipp

Große Residuen deuten nicht unbedingt auf schlechte Gesamtgenauigkeit hin, da dies nur die interne Kameragenauigkeit widerspiegelt. Die endgültige Genauigkeit sollte Kontrollpunkt-Koordinatengenauigkeit und Modellqualität umfassend berücksichtigen.

2. Überlappungskarte

overlap_map.png - 8-Bit-Graustufenbild

Pixelwertbereich: 0-255
Kann als Farbkarte gerendert werden, um Überlappungsverteilung zu zeigen
Wird zur Bewertung von Flugwegdesign und Bildabdeckungsqualität verwendet

3. Vermessungsbereich-Thumbnail

rgb_thumbnail.jpg - 32-Bit-Farbbild

Für schnelle Projektvorschau
Zeigt Vermessungsbereichsumfang und Rekonstruktionsergebnisse

Beispiele zur Berichtsinterpretation

Vollständiges Berichtsbeispiel

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

Qualitätsbewertungsmetriken

Exzellente Qualitätsstandards

residual_rmse < 1.0 Pixel
removed_image_count / input_image_count < 5%
tie_point_count > 10000
Durchschnittliche Positionsdifferenz < 0.5 Meter

Situationen, die Aufmerksamkeit erfordern

residual_rmse > 2.0 Pixel: Mögliche systematische Fehler
removed_image_count > 10%: Bildqualitäts- oder Überlappungsprobleme
tie_point_count < 5000: Unzureichende Feature-Punkte, beeinträchtigt Genauigkeit

Berichtsanalyse-Tools

Python-Analysebeispiel

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)
    
    # Effizienzmetriken berechnen
    total_time = report['at_time'] + report['reconstruction_time']
    images_per_minute = report['input_image_count'] / total_time
    
    # Qualitätsmetriken berechnen
    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']])
    
    # Analysebericht generieren
    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

# Verwendungsbeispiel
analysis = analyze_quality_report('report/report.json')
print(f"Verarbeitungseffizienz: {analysis['efficiency']['images_per_minute']:.1f} Bilder/Minute")
print(f"Durchschnittliche Residuen: {analysis['quality']['residual_rmse']:.2f} Pixel")
print(f"Bodenauflösung: {analysis['scale']['gsd_cm']:.1f} cm")

Qualitätsbericht-Visualisierung

import matplotlib.pyplot as plt
from PIL import Image

def visualize_quality_report(report_dir):
    # Berichtsdaten lesen
    with open(f'{report_dir}/report.json', 'r') as f:
        report = json.load(f)
    
    # Diagramme erstellen
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    
    # 1. Zeitverteilungs-Kreisdiagramm
    times = [
        report['feature_extraction_time'],
        report['feature_match_time'],
        report['sfm_time'],
        report['reconstruction_time']
    ]
    labels = ['Feature-Extraktion', 'Feature-Matching', 'Bundle-Adjustment', '3D-Rekonstruktion']
    axes[0, 0].pie(times, labels=labels, autopct='%1.1f%%')
    axes[0, 0].set_title('Verarbeitungszeitverteilung')
    
    # 2. Positionsdifferenz-Histogramm
    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('Positionsdifferenz (Meter)')
    axes[0, 1].set_ylabel('Bildanzahl')
    axes[0, 1].set_title('Bildpositions-Optimierungsverteilung')
    
    # 3. Überlappungskarte
    overlap_img = Image.open(f'{report_dir}/thumbnail/overlap_map.png')
    axes[1, 0].imshow(overlap_img, cmap='jet')
    axes[1, 0].set_title('Bildüberlappungsverteilung')
    axes[1, 0].axis('off')
    
    # 4. Schlüsselmetriken-Text
    metrics_text = f"""
    Eingabebilder: {report['input_image_count']}
    Entfernte Bilder: {report['removed_image_count']}
    Residuen-RMSE: {report['residual_rmse']:.2f} px
    Verknüpfungspunkte: {report['tie_point_count']:,}
    Szenenfläche: {report['scene_area']/10000:.1f} Hektar
    Bodenauflösung: {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('Schlüssel-Qualitätsmetriken')
    axes[1, 1].axis('off')
    
    plt.tight_layout()
    plt.savefig('quality_report_summary.png', dpi=150)
    plt.show()

Automatisierte Qualitätsprüfung

Qualitätsschwellenwert-Konfiguration

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):
    """Automatisch Rekonstruktionsqualitätslevel bewerten"""
    
    # Metriken berechnen
    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']])
    
    # Level bewerten
    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'

Berichtsintegrations-Anwendungen

Stapelverarbeitungs-Qualitätsüberwachung

def batch_quality_monitor(project_dirs):
    """Stapelprojekt-Qualitätsüberwachung"""
    
    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']
            })
    
    # Zusammenfassungsbericht generieren
    df = pd.DataFrame(results)
    df.to_csv('batch_quality_report.csv', index=False)
    
    # Statistiken
    print(f"Gesamtprojekte: {len(results)}")
    print(f"Exzellent: {len(df[df['quality'] == 'excellent'])}")
    print(f"Gut: {len(df[df['quality'] == 'good'])}")
    print(f"Akzeptabel: {len(df[df['quality'] == 'acceptable'])}")
    print(f"Schlecht: {len(df[df['quality'] == 'poor'])}")
    
    return df

Best Practices

Regelmäßige Berichtsprüfungen: Qualitätsmetriken nach jeder Rekonstruktion überprüfen
Baselines etablieren: Qualitätsmetriken von typischen Projekten als Referenzen aufzeichnen
Anomalie-Warnungen: Automatisierte Skripte zur Erkennung abnormaler Metriken einrichten
Trendanalyse: Qualitätsmetrik-Trends über Zeit verfolgen
Optimierungsvorschläge: Erfassungs- und Verarbeitungsparameter basierend auf Berichtsmetriken anpassen

Tipp: Der Qualitätsbericht ist ein wichtiges Werkzeug zur Bewertung und Optimierung von Rekonstruktions-Workflows. Es wird empfohlen, ihn in automatisierte Workflows zu integrieren.

Überblick​

Berichtsstruktur​

1. Geräteinformationen​

2. Rekonstruktionseffizienz​

3. Rekonstruktionsparameter​

Kameraparameter​

Weitere Parameter​

Koordinatensystem-Informationen​

4. Rekonstruktionsergebnisse​

Kameraparameter nach AT​

Bildpositionsunterschiede​

Qualitätsmetriken​

5. Weitere Informationen​

Visualisierungs-Thumbnails​

1. Kamera-Residuen-Plot​

2. Überlappungskarte​

3. Vermessungsbereich-Thumbnail​

Beispiele zur Berichtsinterpretation​

Vollständiges Berichtsbeispiel​

Qualitätsbewertungsmetriken​

Exzellente Qualitätsstandards​

Situationen, die Aufmerksamkeit erfordern​

Berichtsanalyse-Tools​

Python-Analysebeispiel​

Qualitätsbericht-Visualisierung​

Automatisierte Qualitätsprüfung​

Qualitätsschwellenwert-Konfiguration​

Berichtsintegrations-Anwendungen​

Stapelverarbeitungs-Qualitätsüberwachung​

Best Practices​