La creación de entornos digitales, modelos 3D y gemelos digitales exige una combinación de herramientas y técnicas, algunas gratis, otras no. Nada nuevo hasta aquí. En este blog (con 2 vídeos detallados al respecto) sobre cómo transformar vídeos 360 en modelos 3D en linux. Además, esta entrada pretende servir también como centro de documentación, desde la técnica de las imágenes equirrectangulares y sus aspectos más ingenieriles hasta los programas principales para generación de estos modelos, sus parámetros, ventajas e inconvenientes. Gracias una vez más por haber llegado hasta aquí.

Los vídeos

Parte I - Procesos

En este vídeo verás cómo instalar y usar los principales programas de fotogrametría en linux, concretamente Ubuntu 24.04.

Parte II - Resultados

En este vídeo verás el análisis de los resultados obtenidos en la primera parte, cargando los modelos en Blender y configurando una serie de cámaras para analizar de forma justa los modelos obtenidos.

Un tanto para la historia (apoyado solo sutilmente por Claude)

La fundación matemática que subyace a la fotogrametría de 360 grados se remonta casi 2,000 años al trabajo de Marinus de Tiro alrededor del 100 d.C., quien desarrolló la proyección equirrectangular como una solución para representar superficies esféricas en mapas planos. Esta técnica cartográfica antigua, posteriormente refinada por Claudio Ptolomeo, proporciona el marco matemático que permite a las cámaras 360 grados modernas capturar entornos esféricos completos en un formato que el software de fotogrametría puede procesar efectivamente.

La genialidad de la proyección equirectangular radica en su simplicidad: cada píxel corresponde directamente a mediciones angulares, con una relación de aspecto estándar de 2:1 mapeando 360 grados horizontalmente a 180 grados verticalmente. Esta correspondencia directa píxel-ángulo crea eficiencia computacional que los procesadores modernos pueden manejar en tiempo real.

El ecosistema de software de fotogrametría ha evolucionado dramáticamente para acomodar flujos de trabajo de 360 grados, con líderes claros emergiendo junto a retadores innovadores. Agisoft Metashape es uno de los más potentes, además de estar desarrollado de forma nativa para linux y por lo tanto su ejecución es todavía más fácil. Tiene además la posibilidad de usar fotografías 2:1 (equirrectangulares) directamente. Y tiene más: la fortaleza del software radica en su pipeline de procesamiento automatizado que maneja todo desde la extracción de frames de video hasta la generación final de malla sin requerir pasos manuales de preprocesamiento. En resumen, este programa lo tiene todo y nos podemos evitar con él los pasos previos de extracción y subextración (que habréis visto en el interludio de los vídeos - Parte I).

3DF Zephyr emerge como una alternativa europea convincente, distinguido por sus algoritmos propietarios de reconstrucción internos que no dependen de bibliotecas de terceros. La fortaleza del software radica en sus herramientas especializadas para imágenes de 360 grados, incluyendo descomposición automática equirectangular en seis caras de cubo y soporte nativo para configuraciones de cámaras mixtas. La pega que le pongo es que no tengan un periodo de prueba plenamente funcional y solo se pueda probar con 50 fotos. Me hubiera gustado mucho poder comparar la reconstrucción total del edificio con Metashape.

He intentado usar Reality Scan en Linux sin éxito. Es una pena, porque este software debería funcionar como un puente entre fotogrametría y desarrollo de juegos, con capacidades de exportación sin problemas a Unreal Engine e integración con la biblioteca Quixel Megascans. Por desgracia, no termina de generar los modelos 3D en Wine, por lo que tendré que hacer pruebas más adelante.

Las alternativas de código abierto han madurado significativamente, con OpenDroneMap proporcionando capacidades comprensivas de fotogrametría a través de su arquitectura modular basada en bibliotecas OpenSfM, OpenMVS y PDAL. El software soporta cámaras de 360 grados a través de configuraciones especializadas y ofrece resultados de calidad profesional, aunque se ve muy influenciado por los parámetros y condiciones de captura.

Similarmente, Meshroom, gratuito y el que creo que es el mejor programa tras Metashape, aprovecha el framework AliceVision para proporcionar algoritmos de vanguardia en una interfaz gratuita basada en nodos, aunque requiere más experiencia técnica para lograr resultados óptimos.

Procesos

Video 360 a imágenes

Como ya has visto, algunos programas permiten usar directamente el vídeo equirrectangular, pero como esto no es común a todos, no lo haremos así. Estén como estén escritos, los programas tienen ciertos procesos en común:

1. Detección de puntos en común entre imágenen.
2. Generación de la nube de puntos (espacia) a partir de los puntos detectados en el paso 1.
3. Generación del modelo 3D (mesh) a partir de la conexión entre puntos.
4. Generación de la textura a partir de las imágenes y que se pega al modelo 3D como una piel.

Obviamente la ingeniería detrás de cada proceso no es parte de lo que aquí vamos a ver, pues para eso ya están los propios programas. Lo que vamos a intentar explicar es cómo una imagen de 2 lentes se junta en una sola imagen de proporciones 2:1 (equirrectangualar) y cómo esta puede después convertirse en múltiples imágenes planas y dicho sea de paso, proyectadas.

Proceso casi fácil (necesita pensar un poco)

Veamos un ejemplo. Este sería un ejemplo de una imagen equirrectangular (como ya habrás podido observar en otros post, podrías cargarla en la herramienta de Marzipano y la verías como si te rodeara en 360 grados):

El siguiente paso sería transformar, o mejor dicho, extraer de esta megaimagen (de 7680x3840 pixeles de la Insta360X5 8K) los frames, subframes o vistas que pueden ser usadas en los programas de fotogrametría. Para esta extracción, vamos a usar en primer lugar ffmpeg, pues sus herramientas no solo son gratuitas y usables desde la terminal si no que las podemos sistematizar para cambiar cualquier parámetro y hacer esta extracción de forma masiva. Además, así entendemos mejor de qué estamos hablando.

La primera posibilidad sería extraer 6 fotos de la equirrectangular. Los parámetros son autoexplicativos pero en resumen le estamos indicando que transforme en 6 vistas de 110 grados de ángulo de visión

rm "test.png"
ffmpeg -y -i "VID_20250524_163431_00_029_0001.png" \
		-vf "v360=e:h_fov=110:v_fov=110:yaw=0:pitch=0" \
		"test.png" \
		-v quiet 2>/dev/null 

La imagen de abajo a la izquierda es la más clara pues se ve como la transformación de la vista hacia abajo de la cámara, donde estaría yo con el palo selfie y la gorra de vender perritos calientes, pasaría del hombre estirado de la equirrectangular al hombre proporcionado con bonita sombra de la imagen. Lo mismo para cada uno de los cuadros. ¿Esto nos vale? No. Necesitamos estas vistas por separado.

Otro ejemplo, vamos a sacar un solo frame del cuadro:

ffmpeg -y -i "VID_20250524_163431_00_029_0001.png" \
		-vf "v360=e:flat:d_fov=0:yaw=0:pitch=45:w=1080:h=1080" \
		"test.png" \
		-v quiet 2>/dev/null 

Este tipo de imagen ya se parece más a lo que podríamos meter en las herramientas. Pero vamos un paso más allá porque ffmpeg puede. Con el parámetro c6x1 que significa algo así como 6 columnas en 1 fila.

ffmpeg -y -i "VID_20250524_163431_00_029_0001.png" \
    -vf "v360=e:c6x1" \
    -q:v 1 \
    "test.png" \
    -v quiet 2>/dev/null

v360 filter tienen por defecto esta estructura para el orden: right ‘r’, left ‘l’, up ‘u’, down ‘d’, forward ‘f’, back ‘b’. Default value is ‘rludfb’. Podemos configurar esto a placer, por ejemplo:

ffmpeg -y -i "VID_20250524_163431_00_029_0001.png" \
    -vf "v360=e:c6x1:out_forder=brludf" \
    -q:v 1 \
    "test.png" \
    -v quiet 2>/dev/null

Y ahora, sabiendo esto y poniéndolo en castellano lo que podemos hacer es pensar primero en qué orden de extracción nos gustaría tener para cada uno de los frames equirrectangulares. Para mi, la mejor lógica (y con la que después podemos sistematizar y renombra cada uno de los archivos de la extraccción) es: frontal, derecha, detrás, izquierda, arriba y abajo. Por lo tanto: frblud. Calma, dedicadle un minutillo tranquilo que todo tiene sentido.

Ahora lo que necesitamos es, no solo transformar la imagen equirrectangular en la tira de 6 imágenes, si no separar cada uno de esos cuadros, porque esas serán precisamente las imágenes válidas para la reconstrucción. Y por eso hemos empezado por ffmpeg, porque cuando le pillas la lógica (y te apoyas con buenas instrucciones en una IA) puedes tener scripts como este:

input_image="VID_20250524_163431_00_029_0001.png"
temp_mosaic="temp_c6x1_mosaic.png"
basename="c6x1_cube"

# Generar mosaico c6x1
ffmpeg -y -i "$input_image" \
    -vf "v360=e:c6x1:out_forder=frblud" \
    -q:v 1 \
    "$temp_mosaic" \
    -v quiet 2>/dev/null

# Obtener dimensiones y calcular ancho de cada cubo
dimensions=$(ffprobe -v quiet -select_streams v:0 -show_entries stream=width,height -of csv=s=x:p=0 "$temp_mosaic")
width=$(echo $dimensions | cut -d'x' -f1)
height=$(echo $dimensions | cut -d'x' -f2)
cube_width=$((width / 6))

# Nombres de caras
declare -a FACE_NAMES=("front" "right" "back" "left" "up" "down")

# Trocear en 6 imágenes
for i in {0..5}; do
    x_offset=$((i * cube_width))
    counter=$(printf "%02d" $((i + 1)))
    output_name="${basename}_${counter}_${FACE_NAMES[i]}.png"
    
    ffmpeg -y -i "$temp_mosaic" \
        -vf "crop=${cube_width}:${height}:${x_offset}:0" \
        -q:v 1 \
        "$output_name" \
        -v quiet 2>/dev/null
done

Este script lee la imagen y extrae a una carpeta de un nivel superior los “subframes” o “vistas” manteniendo el nombre del archivo original y agregando al final la vista (front, back, etc). Si ejecutas esto iterativamente sobre todos los frames del vídeo irías obteniendo un repositorio de imágenes que ya sí, pues meter en Meshroom, 3DF Zephyr o ODM.

Antes de pasar a la forma fácil de hacer todo esto te daré el script completo que te permite hacer desde terminal todo:

1. Convertir el vídeo 360 en frames, extrayendo 1 frame cada x segundos (configurado ahora con 2 segundos).
2. Convertir los frames en la tira de 6 vistas.
3. Extraer cada vista de cada frame agregando el sufijo de la posición al archivo final.

# Configuración
FRAME_INTERVAL=2  # Extraer 1 frame cada 2 segundos

# Directorios (un nivel superior)
FRAMES_DIR="../frames"
EXTRACT_DIR="../frames_extract" 

# Crear directorios básicos
mkdir -p "$FRAMES_DIR" "$EXTRACT_DIR"

# PASO 1: Extraer 1 frame cada 10 segundos
for video in *.mp4; do
    video_name=$(basename "$video" .mp4)
    frame_pattern="${FRAMES_DIR}/${video_name}_%06d.png"
    
    # Verificar si ya existen frames
    existing_frames=$(ls ${FRAMES_DIR}/${video_name}_*.png 2>/dev/null | wc -l)
    if [ $existing_frames -gt 0 ]; then
        continue
    fi
    
    # Extraer 1 frame cada 10 segundos            
    ffmpeg -i "$video" \
        -vf "fps=1/$FRAME_INTERVAL" \
        -q:v 2 \
        "$frame_pattern" \
        -v quiet 2>/dev/null
done

# PASO 2: Convertir frames a c6x1 (6 vistas)
frame_files=(${FRAMES_DIR}/*.png)

for frame_file in "${frame_files[@]}"; do
    if [ ! -e "$frame_file" ]; then continue; fi
    
    frame_name=$(basename "$frame_file" .png)
    temp_mosaic="${EXTRACT_DIR}/temp_${frame_name}.png"
    
    # Verificar si ya se procesó este frame (debe tener 6 vistas)
    existing_extracts=$(ls ${EXTRACT_DIR}/${frame_name}_*.png 2>/dev/null | wc -l)
    if [ $existing_extracts -ge 6 ]; then
        continue
    fi
    
    # Generar mosaico c6x1
    ffmpeg -y -i "$frame_file" \
        -vf "v360=e:c6x1:out_forder=frblud" \
        -q:v 1 \
        "$temp_mosaic" \
        -v quiet 2>/dev/null
    
    if [ $? -eq 0 ]; then
        # Obtener dimensiones y trocear
        dimensions=$(ffprobe -v quiet -select_streams v:0 -show_entries stream=width,height -of csv=s=x:p=0 "$temp_mosaic")
        width=$(echo $dimensions | cut -d'x' -f1)
        height=$(echo $dimensions | cut -d'x' -f2)
        cube_width=$((width / 6))
        
        declare -a FACE_NAMES=("front" "right" "back" "left" "up" "down")
        
        # Trocear en 6 imágenes
        for i in {0..5}; do
            x_offset=$((i * cube_width))
            counter=$(printf "%02d" $((i + 1)))
            output_name="${EXTRACT_DIR}/${frame_name}_${counter}_${FACE_NAMES[i]}.png"
            
            ffmpeg -y -i "$temp_mosaic" \
                -vf "crop=${cube_width}:${height}:${x_offset}:0" \
                -q:v 1 \
                "$output_name" \
                -v quiet 2>/dev/null
        done
        
        # Eliminar archivo temporal
        rm "$temp_mosaic"
    fi
done

Se me olvidaba, un extra más. Si además quieres ir a por nota, podrías intentar generar también capas de máscara (lo verás explicado en el vídeo) que puede acelerar el proceso de identificación de puntos en común ya que sirve para eliminar de la búsqueda zonas que no interesan. En esta serie de fotos nos podría interesar enmascarar el cielo. Con un poco de atención podréis generar también scripts como este para transformar las vistas extraídas en imágenes de máscara. He probado varios algoritmos de detección automática del cielo y el que mejor me ha ido ha sido el NRBR.

INPUT_DIR="${1:-.}"
OUTPUT_DIR="$(dirname "$INPUT_DIR")/mask"
mkdir -p "$OUTPUT_DIR"

python3 -c "
import cv2, numpy as np, glob, os
for img_path in glob.glob('$INPUT_DIR/*.jpg') + glob.glob('$INPUT_DIR/*.png'):
    img = cv2.imread(img_path)
    b, r = img[:,:,0].astype(float), img[:,:,2].astype(float)
    nrbr = (b - r) / (b + r + 1)
    mask = ((nrbr > 0.1) * 255).astype('uint8')
    name = os.path.splitext(os.path.basename(img_path))[0] + '.png'
    cv2.imwrite('$OUTPUT_DIR/' + name, mask)
    print(f'✓ {name}')
"

Proceso fácil (un mono podría hacerlo)

Todo lo visto en el apartado anterior puede hacerse directamente con Meshroom y la herramienta split360images.

Solo tenéis que seleccionar primero el directorio donde están las imágenes equirrectangulares previamente extraídas del vídeo y con eso, el programa se encarga de extraer 6 vistas siguiendo una lógica similar…pero no igual. Cambian dos cosas con este sistema:

1. Las extracciones se mandan a carpetas distintas (0 a 5) y en cada una de ellas se ponen juntas las vistas desde un ángulo concreto. Por ejemplo, en la carpeta 0 tendréis todas las fotografías frontales de la cámara.
2. No se extraen vistas ni hacia arriba ni hacia abajo (lo cual sí puede conseguirse con el método anterior).

Por lo visto 3DF Zephyr también puede hacer esta misma extracción, pero teniendo ya dos posibilidades, ¿para qué usar una tercera?

Para saber más

Para saber más sobre extracción y parámetros de ffmpeg te recomiendo estos dos enlaces:

• https://www.jiras.se/ffmpeg/mono.html
• https://ffmpeg.org/ffmpeg-filters.html#v360

Resultados

Os enlazo directamente a la parte del vídeo en la que se ve todo esto resumido. Así no tengo que explicar más.

Diario y apuntes sobre los programas

Como una imagen vale más que mil palabras, todo lo relativo a la instalación y ejecución de los programas está ya contado en los vídeos de arriba. Dejaré aquí apuntadas algunas cosas y usaré esto como un diario en el que pueda ir anotando aspectos que vayan cambiando al actualizar y ejecutar otros proyectos.

Meshroom

Documentación fundamental

• MESHROOM MANUAL OFICIAL
• Cualquiera de los post de este profesor
• Tutorial básico y necesario para no pulsar botones como un mono enfurecido. Explica claramente cada nodo y lo que el programa pretende hacer en cada paso

Notas

1. El proceso con Meshroom es más complejo, porque es gratis, y a veces falla, porque es gratis. Es de largo el programa más lento cuando intentamos hacer grandes reconstrucciones. Solo puedo decir que ojo cuando uséis muchas fotos con entorno lejano y cielo porque podríais llegar a resultados “cerrados” (el modelo mesh se pliega sobre sí mismo) que luego dan la lata para limpiar:

1. El nodo Depthmap no funciona correctamente con los actuales drivers de nvidia y usando las dos gráficas (4060 ti y 5060 ti). Hay que ejecutar llegados a este punto la aplicación indicando que use solo la 0 (por desgracia la 4060). De esta forma el nodo sí avanza. Si este es vuestro caso, debéis lanzar el programa indicando que use solo una de las gráficas…una pena.

#!/bin/bash
CUDA_VISIBLE_DEVICES=0 /home/cesarkero/Meshroom-2023.3.0/Meshroom "$@"

1. Una posible clave para que no haya problemas especialmente en la reconstrucción de los exteriores con cámara 360 y sin hacer trabajo extra de selección de imágenes o máscaras de zonas a NO REPRESENTAR es seguir esta documentación oficial. Concretamente, en el nodo Meshing hay que subir el valor por defecto para Min Observations Angle for SfM Space Estimation a 50. Si lo dejáis en 10, el resultado es un mesh envuelto en su propio entorno:

RealityScan

Documentación fundamental

• Posiblemente se pueda instalar la botella directamente así: https://ubuntushell.com/install-epic/
• Puedes intentarlo directamente descargando el instalador de RealityScan aquí pero a mi no me ha funcionado…https://www.realityscan.com/en-US/download
• La aplicación, ejecutada sin más desde Bottles funciona en los pasos previos de posicionamiento de imágenes, sin embargo, cuando llega el momento de reconstruir el mesh, pide drivers CUDA y falla. Parece que hay solución…

3DF Zephyr

Documentación fundamental

• Arranca en wine.
• Aquí tienes lo básico para la instalación.
• Documentación sobre imágenes 360. El programa permite hacer cosas a partir de las imágenes equirrectangulares y no deja de ser algo similar a lo que ya se puede hacer con la función de ffmpeg.

Evolución

Gaussian splatting - La simple técnica inquietante…

El campo de la reconstrucción 3D está experimentando un cambio revolucionario con la emergencia de técnicas de renderizado neuronal que complementan los enfoques tradicionales de fotogrametría. 3D Gaussian Splatting (3DGS) ha emergido como una alternativa revolucionaria a Neural Radiance Fields, ofreciendo renderizado en tiempo real a 90+ FPS mientras mantiene calidad fotorrealista. Esta representación explícita usando elipsoides gaussianos 3D permite renderizado eficiente basado en rasterización que puede manejar iluminación compleja y efectos dependientes de la vista que desafían los enfoques tradicionales basados en mallas.

El avance vino con el paper SIGGRAPH 2023 de Kerbl et al. demostrando que las representaciones gaussianas 3D explícitas podían lograr entrenamiento 1000× más rápido que NeRF mientras mantenían calidad visual superior. Para flujos de trabajo de 360 grados, esta tecnología ofrece ventajas particulares en manejar las distorsiones extremas y condiciones de iluminación complejas comunes en imágenes omnidireccionales. Desarrollos recientes como Street Gaussian demuestran aplicaciones prácticas para reconstrucción dinámica de escenas urbanas con cobertura completa de 360 grados, incluyendo vehículos y peatones en movimiento.

Neural Radiance Fields (NeRF) continúan evolucionando rápidamente, con Instant-NGP de NVIDIA logrando aceleraciones dramáticas a través de codificación hash multiresolución que reduce el tiempo de entrenamiento de horas a segundos. La integración de la tecnología con flujos de trabajo de 360 grados muestra promesa particular para aplicaciones de VR inmersivas, donde técnicas como Foveated NeRF permiten renderizado en tiempo real de entornos fotorrealistas. El sistema VR-NeRF de Meta demuestra cómo configuraciones personalizadas de múltiples cámaras pueden capturar contenido de 360 grados de alta fidelidad para experiencias inmersivas.

Las implicaciones prácticas para la fotogrametría de 360 grados son profundas. Los flujos de trabajo híbridos que combinan fotogrametría tradicional para estimación inicial de estructura con métodos neuronales para refinamiento se están convirtiendo en práctica estándar. Estos enfoques aprovechan la precisión geométrica de métodos tradicionales mientras usan redes neuronales para manejar materiales desafiantes como superficies transparentes o reflectivas con las que la fotogrametría convencional lucha. El resultado son reconstrucciones 3D más completas y precisas que capturan tanto precisión geométrica como apariencia fotorrealista.

¿Y todo esto en qué se traduce?

Pues aquí os lo explica el máquina entre los máquinas, Carlos Santana Vega (@dotcsv):

Voxeles (triangle splatting) - La más inquietante técnica que podría reventar a la simple técnica inquietante

Supongo que te estarás reponiendo todavía de lo que acabas de ver en la sección anterior. Pero imagina que eso es solo el principio y que hay mucho más. Hay vertientes de este tipo de técnica que son todavía más precisas en algunos puntos. Te dejo este vídeo para que veas cuál podría ser el siguiente paso: la técnica de triangle splatting.

No dejéis de visitar este canal realmente técnico pero donde se pueden ver métodos de reconstrucción 3D muy interesantes Pixel Reconstruct

Conclusión

He llegado hasta aquí exhausto pero me voy a currar yo las conclusiones (aunque me apetecería cascarle todo esto al GPT y que se apañe para un cierre). Como habrás podido comprobar, aquí no hay resultados porque lo único buscado es ver qué caminos reconstructivos tenemos a nuestra disposición en Linux. Si quieres ver resultados vete directamente al segundo de los vídeos y aprende cómo montar los modelos en Blender y cómo configurar cámaras para hacer comparativas justas.

Como ayer vi Batalla de Restaurantes, voy a hacer un cierre tipo Chicote:

Lo relevante aquí es que hay alternativas y también programas a los que le queda recorrido.

Reality Scan tiene una pinta espectacular, pero sus problemas de iteroperabilidad y su alto consumo de Wine hacen que CUDA no pueda ser ejecutado. Todavía no acabo de ver que pueda funcionar, pero estoy seguro de que lo seguiré intentando.

3DF Zephyr podría ser la alternativa europea (¿y la europea?) a todos los demás. Funciona en Bottles y se ve ligerito. Sin embargo su prueba limitada a 50 imágenes hace preguntarse si realmente merecerá la pena a gran escala. Creo que me quedaré con la duda.

OpenDroneMap no nació para este ejercicio, sin embargo, usando los parámetros más simples, ha sido capaz de levantar esa pared. Cabría preguntarse si sería posible configurar un script iterativo que sea capaz de hacer una buena reconstrucción. Esto nos llevaría a imaginar un escenario utópico: generarlo todo sin necesidad de supervisión. De la cámara al plato. Un sueño.

Meshroom es un veterano libre y que sigue dando guerra. Es más lento que el caballo del malo y merecería la pena que ese proyecto se revitalizase con nuevas incorporaciones y algoritmos más “sensatos”. No obstante, funciona y lo que hace lo hace bien. Si tienes tiempo y no dinero, este es tu sitio.

Por último, Metashape, el padre que se come a todos. Su funcionamiento es impecable y es capaz de generar modelos complejos de la forma más sencilla. Y todo, con un funcionamiento perfecto en Ubuntu 24.04. Toma, coge mi dinero.

Espero que hayas apreciado el esfuerzo en todo esto. Podrías apoyarme de muchas formas: contratándome, contactándome o simplemente compartiéndolo.