> 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 3D-Szenenrekonstruktion in Echtzeit mit über **15.000 GitHub-Sternen**. Im Gegensatz zu NeRF-basierten Methoden stellt Gaussian Splatting Szenen als Millionen winziger 3D-Gaussian dar, die gerendert werden können mit **Echtzeit-Bildraten** (100+ FPS) und dabei fotorealistische Qualität erreichen. Stelle es in der GPU-Cloud von Clore.ai bereit, um 3D-Szenen aus deinen 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 bei der Darstellung ein Ray-Marching pro Pixel. Gaussian Splatting verfolgt einen grundsätzlich anderen Ansatz:

1. **Initialisierung:** Beginne mit einer spärlichen Punktwolke (von COLMAP)
2. **Repräsentation:** Erweitere jeden Punkt zu einer 3D-Gaussian mit Position, Skalierung, Rotation, Opazität und sphärischen Harmonischen als Farbe
3. **Optimierung:** Rendern von Gaussians mit Differenzierbarkeit und Optimierung anhand von Trainingsbildern
4. **Darstellung:** Projektiere Gaussians per Alpha-Komposition auf die Bildebene (extrem schnell)

**Wichtige Vorteile gegenüber NeRF:**

* Echtzeit-Rendering (100+ FPS bei 1080p)
* Bessere Rekonstruktion feiner Details
* Explizite 3D-Repräsentation (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        | 12.8+         | 12.8+           |

{% 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 — Miete eine GPU auf Clore.ai

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

***

## Schritt 2 — Dockerfile

Erstelle ein benutzerdefiniertes Docker-Image mit allen Abhängigkeiten:

```dockerfile
FROM pytorch/pytorch:2.11.0-cuda12.8-cudnn9-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/*

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

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

WORKDIR /workspace

# Klone das originale 3DGS-Repo
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/cu128 && \
    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 den 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
```

### Bauen und Pushen

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) stellt keines bereit — baue es mit dem obigen Dockerfile. Das Image muss mit den korrekten CUDA-Architektur-Flags gebaut werden, die zu deiner Ziel-GPU passen.
{% endhint %}

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

***

## Schritt 3 — Per SSH verbinden

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

Überprüfe den Build:

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

***

## Schritt 4 — Bereite deinen Datensatz vor

### Option A: Verwende den Tandt-(Tanks and Temples)-Datensatz

Klassischer Benchmark-Datensatz für schnelles Testen:

```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: Verarbeite deine eigenen Fotos

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

# COLMAP-Verarbeitungsskript ausführen (mit 3DGS bereitgestellt)
cd /workspace/gaussian-splatting

python convert.py \
    -s /workspace/data/my_photos \
    --no_gpu   # optional: falls der COLMAP-GPU-Solver in Konflikt gerät
```

{% hint style="info" %}
Der `convert.py` das Skript führt die vollständige COLMAP-Pipeline aus: Merkmalsextraktion, Matching, spärliche Rekonstruktion und Entzerrung. Dies dauert je nach Anzahl der Bilder 5–30 Minuten.
{% endhint %}

### Option C: Aus Video verarbeiten

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

# Dann COLMAP-Verarbeitung für die Frames ausführen
python convert.py -s /workspace/data/frames
```

***

## Schritt 5 — Gaussian Splat trainieren

### Standard-Training

```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-Datensatz

```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" %}
Das Training bis 7.000 Iterationen dauert auf einer RTX 4090 etwa 10 Minuten und liefert eine gute Qualitätsvorschau. Die vollen 30.000 Iterationen dauern etwa 30–40 Minuten und erzeugen die Endqualität.
{% endhint %}

### Trainingsfortschritt

Beobachte die Trainingsausgabe — du wirst Metriken sehen wie:

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

Ein PSNR über 30 dB weist auf eine hochwertige Rekonstruktion hin.

***

## Schritt 6 — Rendern und Visualisieren

### Aus dem trainierten Modell rendern

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

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

### Erstelle ein Flythrough-Video

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

### Mit 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 &
```

Dann öffne: `http://<clore-host>:<public-port-8080>`

### Alternative: SuperSplat verwenden (browserbasierter Viewer)

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

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

Ziehe dann die `.ply` im SuperSplat-Browser per Drag-and-drop hinein unter: `https://playcanvas.com/super-splat`

***

## Erweiterte Optionen

### Anzahl der Gaussians 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

```bash
# Opazitäts-Reset-Intervall für Außenaufnahmen erhöhen
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-Erweiterung-Build schlägt fehl

```
Fehler: Für die Ausführung auf dem Gerät ist kein Kernel-Image verfügbar
```

**Lösung:** Für deine spezifische GPU-Architektur neu bauen:

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

* Stelle ≥ 50 % Bildüberlappung sicher
* Verwende mehr Fotos (100+ empfohlen)
* Versuche sequentielles Matching für Videoframes: füge `--match sequential` zu convert.py hinzu

### Speicherfehler während des Trainings

```bash
# Maximale Anzahl der Gaussians reduzieren
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 Gaussian-Initialisierung:

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

***

## GPU-Empfehlungen für Clore.ai

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

| GPU           | VRAM  | Clore.ai-Preis                            | 30K-Iterationen-Training | Maximale Anzahl der Gaussians |
| ------------- | ----- | ----------------------------------------- | ------------------------ | ----------------------------- |
| RTX 3090      | 24 GB | ca. 0,07–0,21 $/h                         | \~45–55 Min.             | \~6M                          |
| RTX 4090      | 24 GB | ca. 0,14–0,42 $/h                         | \~30–35 Min.             | \~6M                          |
| A100 40GB     | 40 GB | [Bare Metal](https://clore.ai/bare-metal) | \~12–18 Min.             | \~10M+                        |
| RTX 3080 12GB | 12 GB | $0,05–0,19/Std.                           | \~70 Min.                | \~3M (begrenzt)               |

{% hint style="info" %}
**RTX 3090 für 0,07–0,21 $/Std. ist die beste Wahl** für Gaussian Splatting. Ein vollständiger Trainingslauf mit 30K Iterationen kostet etwa 0,09–0,11 $ an GPU-Zeit. Für mehrere Szenen in einer Sitzung sind die Kosten vernachlässigbar.

Für schnelle Experimente: zuerst auf 7.000 Iterationen trainieren (\~15 Min. auf RTX 3090, \~0,03 $). Prüfe die Qualität im Web-Viewer. Führe die vollen 30K Iterationen nur für die finale Ausgabe aus.
{% endhint %}

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

***

## Nützliche Ressourcen

* [3D-Gaussian-Splatting auf GitHub](https://github.com/graphdeco-inria/gaussian-splatting)
* [Originalpapier (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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/3d-generierung/gaussian-splatting.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.