NeRF vs 3D Gaussian Splatting : Le Comparatif Definitif 2026

# Installation de l'environnement comparatif
mamba create -n neural3d python=3.11 -y
mamba activate neural3d

# Nerfstudio (inclut Instant-NGP, Nerfacto, etc.)
pip install nerfstudio

# 3D Gaussian Splatting
pip install gsplat
git clone https://github.com/graphdeco-inria/gaussian-splatting.git
pip install plyfile tqdm

# COLMAP pour la reconstruction SfM prealable
mamba install colmap -c conda-forge

# Etape 1 : Preparation des donnees avec COLMAP
ns-process-data images --data ./photos/ --output-dir ./processed/

# Etape 2 : Entrainement Nerfacto (meilleur compromis qualite/vitesse)
ns-train nerfacto --data ./processed/ \
    --pipeline.model.num-proposal-samples-per-ray 64 \
    --pipeline.model.num-nerf-samples-per-ray 32 \
    --max-num-iterations 30000 \
    --viewer.quit-on-train-completion True

# Etape 3 : Export du rendu
ns-render camera-path --load-config outputs/processed/nerfacto/config.yml \
    --camera-path-filename camera_path.json \
    --output-path renders/

import torch
from nerfstudio.pipelines.base_pipeline import Pipeline

# Charger le modele entraine
pipeline = Pipeline.load("outputs/processed/nerfacto/")
model = pipeline.model.eval()

# Evaluation sur les vues de test
metrics = pipeline.get_average_eval_image_metrics()
print(f"PSNR  : {metrics['psnr']:.2f} dB")
print(f"SSIM  : {metrics['ssim']:.4f}")
print(f"LPIPS : {metrics['lpips']:.4f}")

# Entrainement 3DGS classique
python gaussian-splatting/train.py \
    -s ./processed/ \
    --iterations 30000 \
    --densify_until_iter 15000 \
    --densification_interval 100 \
    --opacity_reset_interval 3000 \
    --sh_degree 3

# Rendu temps reel
python gaussian-splatting/render.py \
    -m ./output/ \
    --skip_train

import torch
from gsplat import rasterization

def render_gaussians(means3d, scales, rotations, opacities, sh_coeffs, camera):
    """Rendu par rasterisation differentiable avec gsplat."""
    rendered_image, rendered_alpha, info = rasterization(
        means=means3d,           # (N, 3)
        quats=rotations,         # (N, 4)
        scales=scales,           # (N, 3)
        opacities=opacities,     # (N,)
        colors=sh_coeffs,        # (N, K, 3) harmoniques spheriques
        viewmats=camera.world_to_cam[None],
        Ks=camera.intrinsics[None],
        width=camera.width,
        height=camera.height,
        sh_degree=3,
    )
    return rendered_image, rendered_alpha

# Mesure des FPS
import time
start = time.time()
for _ in range(100):
    img, alpha = render_gaussians(means, scales, quats, opac, shs, cam)
    torch.cuda.synchronize()
fps = 100 / (time.time() - start)
print(f"Performance : {fps:.0f} FPS @ 1080p")

import json
from dataclasses import dataclass
from typing import Dict

@dataclass
class BenchmarkResult:
    method: str
    scene: str
    psnr: float
    ssim: float
    lpips: float
    train_time_min: float
    render_fps: float
    model_size_mb: float
    vram_peak_gb: float

def run_comparison(scenes: list, methods: list) -> Dict:
    """Execute le benchmark complet sur toutes les scenes."""
    results = []
    for scene in scenes:
        for method in methods:
            result = train_and_evaluate(scene, method)
            results.append(result)
            print(f"{method} | {scene} | PSNR: {result.psnr:.2f} | FPS: {result.render_fps:.0f}")
    return results

scenes = ["garden", "bicycle", "truck", "train", "playroom"]
methods = ["nerfacto", "instant-ngp", "3dgs", "3dgs-mcmc"]
results = run_comparison(scenes, methods)

def recommend_method(requirements):
    """Recommande NeRF ou 3DGS selon les contraintes projet."""
    score_nerf = 0
    score_3dgs = 0

    if requirements.get("realtime", False):
        score_3dgs += 3
    if requirements.get("edit_scene", False):
        score_3dgs += 2
    if requirements.get("specular_surfaces", False):
        score_nerf += 2
    if requirements.get("compact_model", False):
        score_nerf += 2
    if requirements.get("web_deployment", False):
        score_3dgs += 3  # WebGL splatting viewers
    if requirements.get("semantic_queries", False):
        score_nerf += 1  # LERF
        score_3dgs += 1  # LangSplat

    if score_3dgs > score_nerf:
        return "3D Gaussian Splatting"
    elif score_nerf > score_3dgs:
        return "NeRF (Nerfstudio)"
    else:
        return "Approche hybride recommandee"

result = recommend_method({
    "realtime": True,
    "edit_scene": True,
    "web_deployment": True
})
print(f"Recommandation : {result}")

import torch
import numpy as np

def compress_gaussians(model_path, output_path, target_ratio=0.2):
    """Compresse un modele 3DGS par pruning + quantization."""
    data = torch.load(model_path)
    means = data["means"]
    opacities = data["opacities"]
    n_original = len(means)

    # Etape 1 : Pruning par opacite
    opacity_threshold = torch.quantile(opacities, 1.0 - target_ratio)
    keep_mask = opacities > opacity_threshold

    # Etape 2 : Pruning par taille (supprimer les gaussiennes geantes)
    scales = data["scales"]
    size_mask = scales.max(dim=1).values < 0.5  # max 50cm
    final_mask = keep_mask & size_mask

    # Etape 3 : Quantization des SH (float32 -> float16)
    compressed = {}
    for key, val in data.items():
        if "sh" in key:
            compressed[key] = val[final_mask].half()
        else:
            compressed[key] = val[final_mask]

    n_compressed = final_mask.sum().item()
    ratio = n_compressed / n_original
    print(f"Gaussiennes : {n_original:,} -> {n_compressed:,} ({ratio:.1%})")

    torch.save(compressed, output_path)
    return compressed

compress_gaussians("model.pt", "model_compressed.pt", target_ratio=0.25)

# Architecture hybride conceptuelle : NeRF-guided Gaussian Splatting
class HybridRenderer:
    """Combine un NeRF leger pour la geometrie et des gaussiennes pour le rendu."""

    def __init__(self):
        self.geometry_net = TinyMLP(layers=4, hidden=64)  # SDF implicite
        self.gaussians = GaussianCloud()               # Rendu explicite

    def train_step(self, batch):
        # Phase 1 : Le NeRF guide le placement des gaussiennes
        sdf_values = self.geometry_net(batch.sample_points)
        surface_points = extract_surface(sdf_values)

        # Phase 2 : Les gaussiennes sont densifiees sur la surface
        self.gaussians.densify_on_surface(surface_points)

        # Phase 3 : Rendu par splatting (rapide)
        rendered = self.gaussians.render(batch.camera)
        loss = photometric_loss(rendered, batch.gt_image)
        return loss