Informe de Calidad de Reconstrucción

Resumen

MipMapEngine SDK genera un informe de calidad detallado después de completar tareas de reconstrucción, que contiene información del dispositivo, eficiencia de reconstrucción, configuración de parámetros y calidad de resultados. El informe se almacena en formato JSON en el archivo report/report.json, junto con miniaturas de visualización para vista previa rápida.

Estructura del Informe

1. Información del Dispositivo

Registra la configuración de hardware utilizada para la reconstrucción:

Campo	Tipo	Descripción
cpu_name	string	Nombre del CPU
gpu_name	string	Nombre del GPU

Ejemplo:

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

2. Eficiencia de Reconstrucción

Registra el tiempo de procesamiento para cada etapa (en minutos):

Campo	Tipo	Descripción
feature_extraction_time	float	Tiempo de extracción de características
feature_match_time	float	Tiempo de coincidencia de características
sfm_time	float	Tiempo de ajuste de haces
at_time	float	Tiempo total de AT
reconstruction_time	float	Tiempo total de reconstrucción (excluyendo AT)

Ejemplo:

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

3. Parámetros de Reconstrucción

Registra los parámetros de entrada de la tarea y la configuración:

Parámetros de Cámara

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

Orden del array de parámetros: [f, cx, cy, k1, k2, p1, p2, k3]

• f: Distancia focal
• cx, cy: Coordenadas del punto principal
• k1, k2, k3: Coeficientes de distorsión radial
• p1, p2: Coeficientes de distorsión tangencial

Otros Parámetros

Campo	Tipo	Descripción
input_camera_count	int	Número de cámaras de entrada
input_image_count	int	Número de imágenes de entrada
reconstruction_level	int	Nivel de reconstrucción (1=Ultra-alto, 2=Alto, 3=Medio)
production_type	string	Tipo de producto
max_ram	float	Uso máximo de RAM (GB)

Información del Sistema de Coordenadas

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

Tipos de sistemas de coordenadas:

• 0: LocalENU (Este-Norte-Arriba local)
• 1: Local (Sistema de coordenadas local)
• 2: Geodetic (Sistema de coordenadas geodésico)
• 3: Projected (Sistema de coordenadas proyectado)
• 4: ECEF (Centrado en la Tierra-Fijo en la Tierra)

4. Resultados de Reconstrucción

Parámetros de Cámara después de AT

Registra los parámetros intrínsecos de cámara optimizados:

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

Diferencias de Posición de Imagen

Registra la optimización de posición para cada imagen:

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

Métricas de Calidad

Campo	Tipo	Descripción
removed_image_count	int	Imágenes eliminadas después de AT
residual_rmse	float	RMSE de residuos de puntos de imagen
tie_point_count	int	Número de puntos de enlace
scene_area	float	Área de la escena (metros cuadrados)
scene_gsd	float	Distancia de muestreo en tierra (metros)
flight_height	float	Altura de vuelo (metros)
block_count	int	Número de bloques de reconstrucción

5. Otra Información

Campo	Tipo	Descripción
sdk_version	string	Versión del SDK

Miniaturas de Visualización

La carpeta thumbnail en el directorio del informe contiene los siguientes archivos de visualización:

1. Gráfico de Residuos de Cámara

camera_{id}_residual.png - Imagen en color de 24 bits

• Buen resultado de calibración: Los residuos son similares en tamaño en todas las posiciones con direcciones aleatorias
• Mal resultado de calibración: Residuos grandes con patrones direccionales obvios

tip

Los residuos grandes no necesariamente indican una mala precisión general, ya que esto solo refleja la precisión interna de la cámara. La precisión final debe considerar la precisión de las coordenadas del punto de control y la calidad del modelo de manera integral.

2. Mapa de Superposición

overlap_map.png - Imagen en escala de grises de 8 bits

• Rango de valor de píxel: 0-255
• Se puede renderizar como mapa de colores para mostrar la distribución de superposición
• Se utiliza para evaluar el diseño de la ruta de vuelo y la calidad de cobertura de imagen

3. Miniatura del Área de Levantamiento

rgb_thumbnail.jpg - Imagen en color de 32 bits

• Para vista previa rápida del proyecto
• Muestra la extensión del área de levantamiento y los resultados de reconstrucción

Ejemplos de Interpretación del Informe

Ejemplo de Informe 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"
}

Métricas de Evaluación de Calidad

Estándares de Calidad Excelente

• residual_rmse < 1.0 píxeles
• removed_image_count / input_image_count < 5%
• tie_point_count > 10000
• Diferencia de posición promedio < 0.5 metros

Situaciones que Requieren Atención

• residual_rmse > 2.0 píxeles: Posibles errores sistemáticos
• removed_image_count > 10%: Problemas de calidad de imagen o superposición
• tie_point_count < 5000: Puntos de características insuficientes, afectando la precisión

Herramientas de Análisis de Informes

Ejemplo de Análisis en 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)
    
    # Calcular métricas de eficiencia
    total_time = report['at_time'] + report['reconstruction_time']
    images_per_minute = report['input_image_count'] / total_time
    
    # Calcular métricas de calidad
    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']])
    
    # Generar informe de análisis
    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

# Ejemplo de uso
analysis = analyze_quality_report('report/report.json')
print(f"Eficiencia de procesamiento: {analysis['efficiency']['images_per_minute']:.1f} imágenes/minuto")
print(f"Residuo promedio: {analysis['quality']['residual_rmse']:.2f} píxeles")
print(f"Resolución terrestre: {analysis['scale']['gsd_cm']:.1f} cm")

Visualización del Informe de Calidad

import matplotlib.pyplot as plt
from PIL import Image

def visualize_quality_report(report_dir):
    # Leer datos del informe
    with open(f'{report_dir}/report.json', 'r') as f:
        report = json.load(f)
    
    # Crear gráficos
    fig, axes = plt.subplots(2, 2, figsize=(12, 10))
    
    # 1. Gráfico circular de distribución de tiempo
    times = [
        report['feature_extraction_time'],
        report['feature_match_time'],
        report['sfm_time'],
        report['reconstruction_time']
    ]
    labels = ['Extracción de Características', 'Coincidencia de Características', 'Ajuste de Haces', 'Reconstrucción 3D']
    axes[0, 0].pie(times, labels=labels, autopct='%1.1f%%')
    axes[0, 0].set_title('Distribución del Tiempo de Procesamiento')
    
    # 2. Histograma de diferencia de posición
    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('Diferencia de Posición (metros)')
    axes[0, 1].set_ylabel('Número de Imágenes')
    axes[0, 1].set_title('Distribución de Optimización de Posición de Imagen')
    
    # 3. Mapa de superposición
    overlap_img = Image.open(f'{report_dir}/thumbnail/overlap_map.png')
    axes[1, 0].imshow(overlap_img, cmap='jet')
    axes[1, 0].set_title('Distribución de Superposición de Imágenes')
    axes[1, 0].axis('off')
    
    # 4. Texto de métricas clave
    metrics_text = f"""
    Imágenes de entrada: {report['input_image_count']}
    Imágenes eliminadas: {report['removed_image_count']}
    RMSE de residuos: {report['residual_rmse']:.2f} px
    Puntos de enlace: {report['tie_point_count']:,}
    Área de la escena: {report['scene_area']/10000:.1f} hectáreas
    Resolución terrestre: {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étricas Clave de Calidad')
    axes[1, 1].axis('off')
    
    plt.tight_layout()
    plt.savefig('quality_report_summary.png', dpi=150)
    plt.show()

Verificación Automática de Calidad

Configuración de Umbrales de Calidad

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):
    """Evaluar automáticamente el nivel de calidad de reconstrucción"""
    
    # Calcular métricas
    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']])
    
    # Evaluar nivel
    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'

Aplicaciones de Integración de Informes

Monitor de Calidad de Procesamiento por Lotes

def batch_quality_monitor(project_dirs):
    """Monitor de calidad de proyectos por lotes"""
    
    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']
            })
    
    # Generar informe resumen
    df = pd.DataFrame(results)
    df.to_csv('batch_quality_report.csv', index=False)
    
    # Estadísticas
    print(f"Total de proyectos: {len(results)}")
    print(f"Excelente: {len(df[df['quality'] == 'excellent'])}")
    print(f"Bueno: {len(df[df['quality'] == 'good'])}")
    print(f"Aceptable: {len(df[df['quality'] == 'acceptable'])}")
    print(f"Pobre: {len(df[df['quality'] == 'poor'])}")
    
    return df

Mejores Prácticas

1. Verificaciones regulares de informes: Revisar las métricas de calidad después de cada reconstrucción
2. Establecer líneas base: Registrar métricas de calidad de proyectos típicos como referencias
3. Alertas de anomalías: Configurar scripts automatizados para detectar métricas anormales
4. Análisis de tendencias: Rastrear tendencias de métricas de calidad a lo largo del tiempo
5. Sugerencias de optimización: Ajustar parámetros de captura y procesamiento basándose en métricas del informe

---

Consejo: El informe de calidad es una herramienta importante para evaluar y optimizar los flujos de trabajo de reconstrucción. Se recomienda integrarlo en flujos de trabajo automatizados.