# 3D Gaussian Splatting

**Splatting Gaussiano 3D** es una técnica revolucionaria de reconstrucción de escenas 3D en tiempo real con más de **15.000 estrellas en GitHub**. A diferencia de los métodos basados en NeRF, Gaussian Splatting representa escenas como millones de pequeños Gaussianos 3D que pueden renderizarse a **velocidades de fotogramas en tiempo real** (100+ FPS) mientras logra una calidad fotorrealista. Desplégalo en la nube GPU de Clore.ai para reconstruir y explorar escenas 3D a partir de tus propias fotos.

***

## ¿Qué es 3D Gaussian Splatting?

Los métodos tradicionales NeRF codifican implícitamente una escena en una red neuronal, requiriendo ray marching por píxel en el momento del renderizado. Gaussian Splatting adopta un enfoque fundamentalmente distinto:

1. **Inicialización:** Comienza a partir de una nube de puntos dispersa (proveniente de COLMAP)
2. **Representación:** Expande cada punto en un Gaussiano 3D con posición, escala, rotación, opacidad y color en armónicos esféricos
3. **Optimización:** Renderiza diferenciablemente los Gaussianos y optimiza frente a las imágenes de entrenamiento
4. **Renderizado:** Proyecta los Gaussianos en el plano de la imagen mediante composición alfa (extremadamente rápido)

**Principales ventajas sobre NeRF:**

* Renderizado en tiempo real (100+ FPS a 1080p)
* Mejor reconstrucción de detalles finos
* Representación 3D explícita (editable, exportable)
* Entrenamiento más rápido (30–60 min frente a horas)
* Funciona en GPUs de consumo

***

## Prerrequisitos

| Requisito      | Mínimo        | Recomendado     |
| -------------- | ------------- | --------------- |
| VRAM GPU       | 12 GB         | 24 GB           |
| GPU            | RTX 3080 12GB | RTX 4090 / A100 |
| RAM            | 16 GB         | 32 GB           |
| Almacenamiento | 30 GB         | 60 GB           |
| CUDA           | 11.7+         | 12.1+           |

{% hint style="warning" %}
Gaussian Splatting tiene requisitos estrictos de CUDA. La versión de CUDA debe coincidir con la `extensión compilada diff-gaussian-rasterization.` Usar el Dockerfile proporcionado elimina problemas de compatibilidad.
{% endhint %}

***

## Paso 1 — Alquila una GPU en Clore.ai

1. Inicia sesión en [clore.ai](https://clore.ai).
2. Haz clic **Marketplace** y filtra por VRAM ≥ 16 GB.
3. Selecciona un servidor: la RTX 4090 ofrece la mejor relación precio/rendimiento.
4. Establece la imagen Docker a tu imagen personalizada (ver Paso 2).
5. Establecer puertos abiertos: `22` (SSH) y `8080` (visor web).
6. Haz clic **Alquilar**.

***

## Paso 2 — Dockerfile

Construye una imagen Docker personalizada con todas las dependencias:

```dockerfile
FROM pytorch/pytorch:2.1.2-cuda12.1-cudnn8-devel

ENV DEBIAN_FRONTEND=noninteractive
ENV TORCH_CUDA_ARCH_LIST="6.0;6.1;7.0;7.5;8.0;8.6;8.9;9.0+PTX"

RUN apt-get update && apt-get install -y \
    git wget curl cmake build-essential \
    libboost-program-options-dev libboost-filesystem-dev \
    libboost-graph-dev libboost-system-dev libboost-test-dev \
    libeigen3-dev libflann-dev libfreeimage-dev \
    libmetis-dev libgoogle-glog-dev libgflags-dev \
    libsqlite3-dev libglew-dev qtbase5-dev libqt5opengl5-dev \
    libcgal-dev libceres-dev \
    ffmpeg libgl1 libglib2.0-0 \
    openssh-server \
    python3-pip python3-dev \
    && rm -rf /var/lib/apt/lists/*

# Instalar COLMAP
RUN apt-get update && apt-get install -y colmap && rm -rf /var/lib/apt/lists/*

# Configurar SSH
RUN mkdir /var/run/sshd && \
    echo 'root:clore123' | chpasswd && \
    sed -i 's/#PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config

WORKDIR /workspace

# Clonar el repositorio 3DGS original
RUN git clone https://github.com/graphdeco-inria/gaussian-splatting /workspace/gaussian-splatting \
    --recursive

# Instalar dependencias de Python
RUN cd /workspace/gaussian-splatting && \
    pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu121 && \
    pip install -r requirements.txt

# Construir extensiones CUDA
RUN cd /workspace/gaussian-splatting && \
    pip install submodules/diff-gaussian-rasterization && \
    pip install submodules/simple-knn

# Instalar dependencias del visor web
RUN pip install viser==0.1.29 nerfview==0.0.4 trimesh

EXPOSE 22 8080

CMD service ssh start && tail -f /dev/null
```

### Compilar y subir

Construye la imagen y súbela a tu cuenta de Docker Hub (reemplaza `YOUR_DOCKERHUB_USERNAME` con tu nombre de usuario real):

```bash
docker build -t TU_NOMBRE_DE_DOCKERHUB/gaussian-splatting:latest .
docker push TU_NOMBRE_DE_DOCKERHUB/gaussian-splatting:latest
```

{% hint style="info" %}
No existe una imagen Docker preconstruida oficial para 3D Gaussian Splatting en Docker Hub. El repositorio oficial en [graphdeco-inria/gaussian-splatting](https://github.com/graphdeco-inria/gaussian-splatting) no proporciona una — constrúyela a partir del Dockerfile anterior. La imagen debe construirse con las banderas de arquitectura CUDA correctas que coincidan con tu GPU objetivo.
{% endhint %}

Usa `TU_NOMBRE_DE_DOCKERHUB/gaussian-splatting:latest` en tu configuración de Clore.ai.

***

## Paso 3 — Conéctate vía SSH

```bash
ssh root@<clore-host> -p <assigned-ssh-port>
```

Verifica la compilación:

```bash
cd /workspace/gaussian-splatting
python -c "from diff_gaussian_rasterization import GaussianRasterizationSettings; print('CUDA extension OK')"
```

***

## Paso 4 — Prepara tu conjunto de datos

### Opción A: Usar el conjunto de datos Tandt (Tanks and Temples)

Conjunto de pruebas clásico para pruebas rápidas:

```bash
mkdir -p /workspace/data && cd /workspace/data

# Descargar escena de prueba pequeña
wget https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/datasets/input/tandt.zip
unzip tandt.zip
```

### Opción B: Procesar tus propias fotos

```bash
# Subir fotos
scp -P <port> -r ./my_photos/ root@<clore-host>:/workspace/data/

# Ejecutar el script de procesamiento COLMAP (proporcionado con 3DGS)
cd /workspace/gaussian-splatting

python convert.py \
    -s /workspace/data/my_photos \
    --no_gpu   # opcional: si el solucionador GPU de COLMAP causa conflictos
```

{% hint style="info" %}
El `convert.py` el script ejecuta la tubería completa de COLMAP: extracción de características, matching, reconstrucción dispersa y undistortion. Esto toma 5–30 minutos dependiendo del número de imágenes.
{% endhint %}

### Opción C: Procesar desde video

```bash
# Extraer fotogramas del video a 2 fps
ffmpeg -i /workspace/data/my_video.mp4 \
    -vf fps=2 \
    /workspace/data/frames/frame_%04d.jpg

# Luego ejecutar el procesamiento COLMAP en los fotogramas
python convert.py -s /workspace/data/frames
```

***

## Paso 5 — Entrenar un Gaussian Splat

### Entrenamiento estándar

```bash
cd /workspace/gaussian-splatting

python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --iterations 30000 \
    --eval
```

### Entrenamiento en el conjunto Tandt

```bash
python train.py \
    -s /workspace/data/tandt/truck \
    -m /workspace/output/truck \
    --iterations 30000 \
    --eval
```

### Entrenamiento rápido (vista previa rápida)

```bash
python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene_fast \
    --iterations 7000
```

{% hint style="info" %}
Entrenar hasta 7.000 iteraciones lleva \~10 minutos en una RTX 4090 y proporciona una buena vista previa de calidad. Las 30.000 iteraciones completas llevan \~30–40 minutos y producen la calidad final.
{% endhint %}

### Progreso del entrenamiento

Monitorea la salida del entrenamiento: verás métricas como:

```
[ITER 1000] Evaluating train: L1 0.04, PSNR 26.12 dB
[ITER 7000] Evaluating train: L1 0.02, PSNR 29.45 dB
[ITER 30000] Evaluating train: L1 0.01, PSNR 32.80 dB
```

PSNR por encima de 30 dB indica una reconstrucción de alta calidad.

***

## Paso 6 — Renderizar y visualizar

### Renderizar desde el modelo entrenado

```bash
python render.py \
    -m /workspace/output/my_scene \
    --skip_train
```

Los renders se guardan en `/workspace/output/my_scene/test/ours_30000/renders/`.

### Crear un video de vuelo

```bash
# Convertir los fotogramas renderizados a video
ffmpeg -framerate 24 \
    -pattern_type glob \
    -i '/workspace/output/my_scene/test/ours_30000/renders/*.png' \
    -c:v libx264 \
    -pix_fmt yuv420p \
    /workspace/output/flythrough.mp4
```

### Evaluar métricas

```bash
python metrics.py -m /workspace/output/my_scene
```

Salida esperada:

```
SSIM : 0.8324
PSNR : 32.81
LPIPS: 0.1893
```

***

## Paso 7 — Visor web interactivo

Para explorar la escena entrenada de forma interactiva:

### Usando nerfview/viser

```python
# /workspace/view_splat.py
import viser
import numpy as np
from plyfile import PlyData
import torch

server = viser.ViserServer(host="0.0.0.0", port=8080)
print("Visor en ejecución en http://0.0.0.0:8080")

# Cargar archivo PLY
ply_path = "/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply"
plydata = PlyData.read(ply_path)

xyz = np.stack([
    plydata['vertex']['x'],
    plydata['vertex']['y'],
    plydata['vertex']['z'],
], axis=-1)

# Añadir la nube de puntos al visor
server.add_point_cloud(
    name="/splat",
    points=xyz,
    colors=np.ones((len(xyz), 3)) * 0.7,
    point_size=0.003,
)

import time
while True:
    time.sleep(0.01)
```

```bash
python /workspace/view_splat.py &
```

Luego abre: `http://<clore-host>:<public-port-8080>`

### Alternativa: Usar SuperSplat (visor basado en navegador)

Descarga el `.ply` archivo y ábrelo en [SuperSplat](https://playcanvas.com/super-splat):

```bash
# Descargar desde tu máquina local
scp -P <port> root@<clore-host>:/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply ./
```

Luego arrastra y suelta el `.ply` en el navegador SuperSplat en: `https://playcanvas.com/super-splat`

***

## Opciones avanzadas

### Controlar el número de Gaussianos

```bash
# Mayor densificación para escenas más detalladas
python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --densify_until_iter 15000 \
    --densify_grad_threshold 0.0002
```

### Fondo blanco (para objetos)

```bash
python train.py \
    -s /workspace/data/my_object \
    -m /workspace/output/my_object \
    --white_background
```

### Escenas a gran escala

```bash
# Aumentar el intervalo de reinicio de opacidad para escenas exteriores
python train.py \
    -s /workspace/data/outdoor \
    -m /workspace/output/outdoor \
    --opacity_reset_interval 5000 \
    --iterations 50000
```

***

## Alternativa: Gaussian Splatting con gsplat

`gsplat` es una implementación más rápida y eficiente en memoria:

```bash
pip install gsplat

# Entrenamiento con gsplat
python examples/simple_trainer.py \
    --data_dir /workspace/data/my_photos \
    --result_dir /workspace/gsplat_output
```

***

## Solución de problemas

### Fallo en la compilación de la extensión CUDA

```
error: no kernel image is available for execution on the device
```

**Solución:** Reconstruye para la arquitectura específica de tu GPU:

```bash
export TORCH_CUDA_ARCH_LIST="8.6"  # Para RTX 3090/4090
cd /workspace/gaussian-splatting
pip install submodules/diff-gaussian-rasterization --force-reinstall
```

### COLMAP falla al reconstruir

**Soluciones:**

* Asegura ≥ 50% de solapamiento entre imágenes
* Usa más fotos (se recomiendan 100+)
* Prueba matching secuencial para fotogramas de video: añade `--match sequential` a convert.py

### Memoria insuficiente durante el entrenamiento

```bash
# Reducir el número máximo de Gaussianos
python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --max_num_splats 2000000  # el valor por defecto es ~6M
```

### Elementos flotantes en la escena

Artefactos flotantes por la inicialización de Gaussianos:

* Aumente `--densify_grad_threshold` para ser más selectivo
* Usa `--prune_opacity_threshold 0.005` para eliminar Gaussianos de baja opacidad antes

***

## Recomendaciones de GPU en Clore.ai

El entrenamiento de Gaussian Splatting es intensivo en cómputo GPU con llamadas frecuentes a kernels CUDA. La VRAM determina la complejidad máxima de la escena (número de Gaussianos); el cómputo determina la velocidad de entrenamiento.

| GPU           | VRAM  | Precio en Clore.ai | Entrenamiento de 30K iteraciones | Máx. Gaussianos |
| ------------- | ----- | ------------------ | -------------------------------- | --------------- |
| RTX 3090      | 24 GB | \~$0.12/h          | \~45–55 min                      | \~6M            |
| RTX 4090      | 24 GB | \~$0.70/h          | \~30–35 min                      | \~6M            |
| A100 40GB     | 40 GB | \~$1.20/h          | \~12–18 min                      | \~10M+          |
| RTX 3080 12GB | 12 GB | \~$0.08/h          | \~70 min                         | \~3M (limitado) |

{% hint style="info" %}
**La RTX 3090 a \~$0.12/h es la mejor opción** para Gaussian Splatting. Una ejecución completa de entrenamiento de 30K iteraciones cuesta \~$0.09–0.11 en tiempo de GPU. Para múltiples escenas en una sesión, el costo es insignificante.

Para experimentos rápidos: entrena primero hasta 7.000 iteraciones (\~15 min en RTX 3090, \~$0.03). Comprueba la calidad en el visor web. Solo ejecuta las 30K iteraciones completas para la salida final.
{% endhint %}

**Nota sobre el preprocesamiento COLMAP:** COLMAP (Structure from Motion) se ejecuta en CPU/GPU pero el cómputo pesado se realiza en CPU. La mayoría de servidores de Clore.ai tienen CPUs adecuadas para escenas con menos de 200 imágenes. Para conjuntos de datos de 500+ imágenes, busca servidores con 16+ núcleos de CPU.

***

## Recursos Útiles

* [3D Gaussian Splatting en GitHub](https://github.com/graphdeco-inria/gaussian-splatting)
* [Artículo original (SIGGRAPH 2023)](https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/)
* [gsplat — Implementación rápida](https://github.com/nerfstudio-project/gsplat)
* [SuperSplat — Visor en navegador](https://playcanvas.com/super-splat)
* [Comunidad de Gaussian Splatting (Reddit)](https://www.reddit.com/r/gaussiansplatting/)
* [Awesome Gaussian Splatting](https://github.com/MrNeRF/awesome-3D-gaussian-splatting)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/generacion-3d/gaussian-splatting.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.