> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/3d-generierung/gaussian-splatting.md).

# 3D Gaussian Splatting

**3D Gaussian Splatting** ist eine revolutionäre Echtzeit-3D-Szenenrekonstruktionsmethode mit über **15.000 GitHub-Sternen**. Im Gegensatz zu NeRF-basierten Methoden stellt Gaussian Splatting Szenen als Millionen winziger 3D-Gaussfunktionen dar, die mit **Echtzeit-Bildraten** (100+ FPS) gerendert werden können und dabei photorealistische Qualität erreichen. Setzen Sie es auf Clore.ais GPU-Cloud ein, um 3D-Szenen aus Ihren eigenen Fotos zu rekonstruieren und zu erkunden.

***

## Was ist 3D Gaussian Splatting?

Traditionelle NeRF-Methoden kodieren eine Szene implizit in einem neuronalen Netzwerk und erfordern beim Rendern pro Pixel Ray-Marching. Gaussian Splatting verfolgt einen grundlegend anderen Ansatz:

1. **Initialisierung:** Beginnen Sie mit einer spärlichen Punktwolke (von COLMAP)
2. **Darstellung:** Erweitern Sie jeden Punkt zu einer 3D-Gaussfunktion mit Position, Skala, Rotation, Opazität und Farbinformationen in Kugelharmonischen
3. **Optimierung:** Differenzierbar Gaussfunktionen rendern und gegenüber Trainingsbildern optimieren
4. **Rendering:** Gaussfunktionen mittels Alpha-Komposition auf die Bildebene projizieren (extrem schnell)

**Wesentliche Vorteile gegenüber NeRF:**

* Echtzeit-Rendering (100+ FPS bei 1080p)
* Bessere Rekonstruktion feiner Details
* Explizite 3D-Darstellung (bearbeitbar, exportierbar)
* Schnelleres Training (30–60 Min statt Stunden)
* Funktioniert auf Consumer-GPUs

***

## Voraussetzungen

| Anforderung | Minimum       | Empfohlen       |
| ----------- | ------------- | --------------- |
| GPU-VRAM    | 12 GB         | 24 GB           |
| GPU         | RTX 3080 12GB | RTX 4090 / A100 |
| RAM         | 16 GB         | 32 GB           |
| Speicher    | 30 GB         | 60 GB           |
| CUDA        | 11.7+         | 12.1+           |

{% hint style="warning" %}
Gaussian Splatting hat strenge CUDA-Anforderungen. Die CUDA-Version muss mit der `diff-gaussian-rasterization` kompilierten Erweiterung übereinstimmen. Die Verwendung des bereitgestellten Dockerfiles beseitigt Kompatibilitätsprobleme.
{% endhint %}

***

## Schritt 1 — Mieten Sie eine GPU auf Clore.ai

1. Melden Sie sich an bei [clore.ai](https://clore.ai).
2. Klicken Sie **Marktplatz** und filtern Sie nach VRAM ≥ 16 GB.
3. Wählen Sie einen Server — die RTX 4090 bietet das beste Preis-/Leistungsverhältnis.
4. Setzen Sie das Docker-Image auf Ihr benutzerdefiniertes Image (siehe Schritt 2).
5. Offene Ports festlegen: `22` (SSH) und `8080` (Web-Viewer).
6. Klicken Sie **Mieten**.

***

## Schritt 2 — Dockerfile

Erstellen Sie ein benutzerdefiniertes Docker-Image mit allen Abhängigkeiten:

```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/*

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

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

WORKDIR /workspace

# Originales 3DGS-Repository klonen
RUN git clone https://github.com/graphdeco-inria/gaussian-splatting /workspace/gaussian-splatting \
    --recursive

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

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

# Abhängigkeiten für Web-Viewer installieren
RUN pip install viser==0.1.29 nerfview==0.0.4 trimesh

EXPOSE 22 8080

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

### Build und Push

Baue das Image und pushe es in dein eigenes Docker Hub-Konto (ersetze `YOUR_DOCKERHUB_USERNAME` durch deinen tatsächlichen Benutzernamen):

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

{% hint style="info" %}
Es gibt kein offizielles vorgefertigtes Docker-Image für 3D Gaussian Splatting auf Docker Hub. Das offizielle Repository unter [graphdeco-inria/gaussian-splatting](https://github.com/graphdeco-inria/gaussian-splatting) bietet keines an — bauen Sie es aus dem obigen Dockerfile. Das Image muss mit den korrekten CUDA-Architekturflags erstellt werden, die zu Ihrer Ziel-GPU passen.
{% endhint %}

Verwende `YOUR_DOCKERHUB_USERNAME/gaussian-splatting:latest` in Ihrer Clore.ai-Konfiguration.

***

## Schritt 3 — Verbindung per SSH

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

Überprüfen Sie den Build:

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

***

## Schritt 4 — Bereiten Sie Ihr Dataset vor

### Option A: Verwenden Sie das Tandt (Tanks and Temples) Dataset

Klassisches Benchmark-Dataset für schnelle Tests:

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

# Kleine Testszene herunterladen
wget https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/datasets/input/tandt.zip
unzip tandt.zip
```

### Option B: Verarbeiten Sie Ihre eigenen Fotos

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

# Führen Sie das COLMAP-Verarbeitungsskript aus (mit 3DGS bereitgestellt)
cd /workspace/gaussian-splatting

python convert.py \
    -s /workspace/data/my_photos \
    --no_gpu   # optional: falls der COLMAP-GPU-Solver Konflikte verursacht
```

{% hint style="info" %}
Der `convert.py` Das Skript führt die gesamte COLMAP-Pipeline aus: Merkmalserkennung, Matching, spärliche Rekonstruktion und Entzerrung. Das dauert je nach Bildanzahl 5–30 Minuten.
{% endhint %}

### Option C: Verarbeitung aus Video

```bash
# Extrahieren Sie Frames aus dem Video mit 2 fps
ffmpeg -i /workspace/data/my_video.mp4 \
    -vf fps=2 \
    /workspace/data/frames/frame_%04d.jpg

# Führen Sie dann die COLMAP-Verarbeitung für die Frames aus
python convert.py -s /workspace/data/frames
```

***

## Schritt 5 — Trainieren Sie einen Gaussian Splat

### Standardtraining

```bash
cd /workspace/gaussian-splatting

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

### Training auf dem Tandt-Dataset

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

### Schnelles Training (Schnellvorschau)

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

{% hint style="info" %}
Training bis 7.000 Iterationen dauert \~10 Minuten auf einer RTX 4090 und liefert eine gute Vorschauqualität. Vollständige 30.000 Iterationen dauern \~30–40 Minuten und erzeugen die Endqualität.
{% endhint %}

### Trainingsfortschritt

Überwachen Sie die Trainingsausgabe — Sie sehen Metriken wie:

```
[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 über 30 dB deutet auf eine hochqualitative Rekonstruktion hin.

***

## Schritt 6 — Rendern und Visualisieren

### Aus trainiertem Modell rendern

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

Gerenderte Bilder werden gespeichert unter `/workspace/output/my_scene/test/ours_30000/renders/`.

### Erstellen Sie ein Flythrough-Video

```bash
# Gerenderte Frames in Video konvertieren
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
```

### Metriken auswerten

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

Erwartete Ausgabe:

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

***

## Schritt 7 — Interaktiver Web-Viewer

Um die trainierte Szene interaktiv zu erkunden:

### Verwendung von 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("Viewer läuft unter http://0.0.0.0:8080")

# PLY-Datei laden
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)

# Punktwolke zum Viewer hinzufügen
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 &
```

Öffnen Sie dann: `http://<clore-host>:<public-port-8080>`

### Alternative: Verwenden Sie SuperSplat (browserbasierter Viewer)

Laden Sie die `.ply` Datei herunter und öffnen Sie sie in [SuperSplat](https://playcanvas.com/super-splat):

```bash
# Herunterladen von Ihrem lokalen Rechner
scp -P <port> root@<clore-host>:/workspace/output/my_scene/point_cloud/iteration_30000/point_cloud.ply ./
```

Ziehen Sie dann per Drag & Drop die `.ply` in den SuperSplat-Browser unter: `https://playcanvas.com/super-splat`

***

## Erweiterte Optionen

### Anzahl der Gaussfunktionen steuern

```bash
# Höhere Verdichtung für detailliertere Szenen
python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --densify_until_iter 15000 \
    --densify_grad_threshold 0.0002
```

### Weißer Hintergrund (für Objekte)

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

### Große Szenen im Maßstab

```bash
# Erhöhen Sie das Intervall zum Zurücksetzen der Opazität für Außenaufnahmen
python train.py \
    -s /workspace/data/outdoor \
    -m /workspace/output/outdoor \
    --opacity_reset_interval 5000 \
    --iterations 50000
```

***

## Alternative: Gaussian Splatting mit gsplat

`gsplat` ist eine schnellere, speichereffiziente Implementierung:

```bash
pip install gsplat

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

***

## Fehlerbehebung

### CUDA-Erweiterungs-Build schlägt fehl

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

**Lösung:** Bauen Sie neu für Ihre spezifische GPU-Architektur:

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

### COLMAP kann nicht rekonstruieren

**Lösungen:**

* Stellen Sie ≥ 50% Bildüberlappung sicher
* Verwenden Sie mehr Fotos (100+ empfohlen)
* Versuchen Sie sequentielles Matching für Video-Frames: fügen Sie `--match sequential` zu convert.py hinzu

### Während des Trainings kein Speicher mehr

```bash
# Reduzieren Sie die maximale Anzahl der Gaussfunktionen
python train.py \
    -s /workspace/data/my_photos \
    -m /workspace/output/my_scene \
    --max_num_splats 2000000  # Standard ist ~6M
```

### Schwebende Artefakte in der Szene

Schwebende Artefakte durch Gauss-Initialisierung:

* Erhöhen `--densify_grad_threshold` um selektiver zu sein
* Verwende `--prune_opacity_threshold 0.005` um Gaussfunktionen mit geringer Opazität früher zu entfernen

***

## Clore.ai GPU-Empfehlungen

Das Training von Gaussian Splatting ist GPU-rechenintensiv mit häufigen CUDA-Kernel-Aufrufen. VRAM bestimmt die maximale Szenenkomplexität (Anzahl der Gaussfunktionen); Rechenleistung bestimmt die Trainingsgeschwindigkeit.

| GPU           | VRAM  | Clore.ai-Preis | 30K-Iter-Training | Max. Gaussfunktionen |
| ------------- | ----- | -------------- | ----------------- | -------------------- |
| RTX 3090      | 24 GB | \~$0.12/Stunde | \~45–55 Min       | \~6M                 |
| RTX 4090      | 24 GB | \~$0.70/Stunde | \~30–35 Min       | \~6M                 |
| A100 40GB     | 40 GB | \~$1.20/Stunde | \~12–18 Min       | \~10M+               |
| RTX 3080 12GB | 12 GB | \~$0.08/Stunde | \~70 Min          | \~3M (begrenzt)      |

{% hint style="info" %}
**RTX 3090 zu \~$0.12/Stunde ist die beste Wahl** für Gaussian Splatting. Ein vollständiger 30K-Iterationen-Trainingslauf kostet \~$0.09–0.11 an GPU-Zeit. Für mehrere Szenen in einer Sitzung sind die Kosten vernachlässigbar.

Für schnelle Experimente: trainieren Sie zunächst bis 7.000 Iterationen (\~15 Min auf RTX 3090, \~$0.03). Prüfen Sie die Qualität im Web-Viewer. Führen Sie nur für das endgültige Ergebnis die vollen 30K Iterationen aus.
{% endhint %}

**Hinweis zur COLMAP-Vorverarbeitung:** COLMAP (Structure from Motion) läuft auf CPU/GPU, aber die schwere Berechnung erfolgt auf der CPU. Die meisten Clore.ai-Server haben ausreichend CPUs für Szenen mit weniger als 200 Bildern. Für Datensätze mit 500+ Bildern suchen Sie nach Servern mit 16+ CPU-Kernen.

***

## Nützliche Ressourcen

* [3D Gaussian Splatting GitHub](https://github.com/graphdeco-inria/gaussian-splatting)
* [Originalpaper (SIGGRAPH 2023)](https://repo-sam.inria.fr/fungraph/3d-gaussian-splatting/)
* [gsplat — schnelle Implementierung](https://github.com/nerfstudio-project/gsplat)
* [SuperSplat — Browser-Viewer](https://playcanvas.com/super-splat)
* [Gaussian Splatting Community (Reddit)](https://www.reddit.com/r/gaussiansplatting/)
* [Awesome Gaussian Splatting](https://github.com/MrNeRF/awesome-3D-gaussian-splatting)


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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-de/3d-generierung/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.