3D Gaussian Splatting de la zero

O scenă este un nor de milioane de Gaussiene 3D. Fiecare are poziție, orientare, scală, opacitate și o culoare dependentă de direcția privirii. Rasterizați-le, propagați gradientul înapoi prin rasterizare, gata.

Tip: Construiți Limbaje: Python Cerințe prealabile: Faza 4 Lecția 13 (Viziune 3D și NeRF), Faza 1 Lecția 12 (Operații cu tensori), Faza 4 Lecția 10 (Bazele difuziei, opțional) Timp: ~90 de minute

Obiective de învățare

• Explicați de ce 3D Gaussian Splatting a înlocuit NeRF drept opțiunea implicită de producție pentru reconstrucția 3D fotorealistă în 2026
• Indicați cei șase parametri pentru fiecare Gaussiană (poziție, cuaternion de rotație, scală, opacitate, culoare prin armonici sferice, caracteristică opțională) și câte valori float contribuie fiecare
• Implementați de la zero un rasterizator 2D cu Gaussian splatting, folosind compunerea alpha, apoi arătați cum cazul 3D se proiectează în aceeași buclă
• Utilizați nerfstudio, gsplat sau SuperSplat pentru a reconstrui o scenă din 20–50 de fotografii și a o exporta în extensia glTF KHR_gaussian_splatting sau în schema OpenUSD 26.03 UsdVolParticleField3DGaussianSplat

Problema

Un NeRF stochează o scenă în ponderile unui MLP. Fiecare pixel redat înseamnă sute de interogări MLP de-a lungul unei raze. Antrenarea durează ore, redarea durează secunde, iar ponderile nu pot fi editate — dacă doriți să mutați un scaun din scenă, trebuie să reantrenați.

3D Gaussian Splatting (Kerbl, Kopanas, Leimkühler, Drettakis, SIGGRAPH 2023) a înlocuit toate acestea. O scenă este un set explicit de Gaussiene 3D. Redarea este rasterizare GPU la peste 100 fps. Antrenarea durează minute. Editarea este directă: translatați un subset de Gaussiene și ați mutat scaunul. Până în 2026, Khronos Group a ratificat o extensie glTF pentru Gaussian splats, OpenUSD 26.03 livrează o schemă Gaussian splat, Zillow și Apartments.com redau proprietăți imobiliare cu acestea, iar majoritatea lucrărilor noi despre reconstrucția 3D sunt variante ale ideii de bază 3DGS.

Notă tehnică a traducerii: 3DGS este o reprezentare explicită eficientă și importantă, nu un înlocuitor universal al NeRF pentru toate sarcinile. Viteza, calitatea, editabilitatea și costul depind de date, acoperirea camerelor, hardware, renderer și obiectiv. Documentația curentă KHR_gaussian_splatting îi declară statutul de Release Candidate, nu de extensie Khronos ratificată; pagina actuală OpenUSD 26.05 nu confirmă aici schema sau versiunea 26.03 invocată în original.

Modelul mental este simplu, însă matematica are suficiente părți mobile încât majoritatea introducerilor pornesc de la rasterizare și omit proiecțiile și armonicile sferice. Această lecție construiește întregul mecanism — mai întâi o versiune 2D, apoi extensia 3D.

Conceptul

Ce conține o Gaussiană

O Gaussiană 3D este o pată parametrică în spațiu, cu aceste atribute:

poziție          mu         (3,)    centru în coordonate globale
rotație          q          (4,)    cuaternion unitar care codifică orientarea
scală            s          (3,)    log-scări pe fiecare axă (exponențiate la redare)
opacitate        alpha      (1,)    opacitate după sigmoidă [0, 1]
coeficienți SH   c_lm       (3 * (L+1)^2,)   culoare dependentă de privire

Rotația + scala construiesc o covarianță 3x3: Sigma = R S S^T R^T. Aceasta este forma Gaussianei în 3D. Armonicile sferice permit culorii să se schimbe cu direcția privirii — reflexii speculative, luciu subtil, strălucire dependentă de privire — fără a stoca texturi pentru fiecare vedere. La gradul SH 3, obțineți 16 coeficienți pentru fiecare canal de culoare, adică 48 de valori float numai pentru culoare.

O scenă are de obicei 1–5 milioane de Gaussiene. Fiecare stochează aproximativ 60 de valori float (3 + 4 + 3 + 1 + 48 + diverse). Aceasta înseamnă 240 MB pentru o scenă cu cinci milioane de Gaussiene — mult mai puțin decât un nor de puncte echivalent cu textură pentru fiecare punct și cu un ordin de mărime mai puțin decât ponderile MLP ale unui NeRF re-redat la rezoluție mare.

Notă tehnică a traducerii: 60 de valori float32 pentru cinci milioane de Gaussiene ocupă aproximativ 1,2 GB înainte de metadate, gradienți, starea optimizatorului și structurile rendererului; 240 MB corespunde aproximativ unui milion de astfel de Gaussiene. Comparația universală cu un nor de puncte sau cu ponderile unui NeRF nu este justificată: ambele dimensiuni depind de reprezentare, cuantizare, checkpoint și implementare.

Rasterizare, nu ray marching

Cinci pași, toți prietenoși cu GPU-ul. Nicio interogare MLP pentru fiecare pixel. Un singur RTX 3080 Ti redă 6 milioane de splats la 147 fps.

Notă tehnică a traducerii: Valoarea de 147 fps este un rezultat măsurat într-o configurație concretă, nu o garanție pentru orice scenă, rezoluție, placă video sau viewer. Tilingul și sortarea sunt esențiale pentru performanță și pot domina timpul pentru scene, camere sau dimensiuni de tile diferite.

Pasul de proiecție

Gaussiana 3D aflată în poziția globală mu, cu covarianța 3D Sigma, se proiectează într-o Gaussiană 2D aflată în poziția de ecran mu', cu covarianța 2D Sigma':

mu' = project(mu)
Sigma' = J W Sigma W^T J^T          (2 x 2)

W = transformarea de vizualizare (rotația + translația camerei)
J = Jacobiana proiecției în perspectivă la mu'

Amprenta Gaussianei 2D este o elipsă ale cărei axe sunt vectorii proprii ai lui Sigma'. Fiecare pixel din acea elipsă primește contribuția Gaussianei, ponderată cu exp(-0.5 * (p - mu')^T Sigma'^-1 (p - mu')).

Notă tehnică a traducerii: În transformarea covarianței participă partea liniară, de rotație, a transformării de vizualizare; translația schimbă media, nu covarianța. Jacobiana proiecției se evaluează în coordonate ale camerei la media 3D proiectată. Dacă scările sunt păstrate în log-space, matricea S trebuie construită cu scări liniare, de pildă diag(exp(log_scale)), nu cu log-scalarele direct. Formula este o liniarizare locală; implementările trebuie să trateze și convențiile de cameră, near plane-ul, stabilitatea numerică și trunchierea elipsei în spațiul ecranului.

Notă tehnică a traducerii: O Gaussiană are suport matematic infinit, însă rasterizatoarele practice îi limitează amprenta la o regiune finită — de exemplu, printr-un prag de aproximativ 3σ. Acest prag este un compromis între cost și eroarea de trunchiere; nu este o proprietate intrinsecă unică a 3DGS.

Regula de compunere alpha

Pentru un pixel, Gaussienele care îl acoperă sunt sortate din spate spre față (sau, echivalent, din față spre spate cu formula inversată). Culoarea se compune cu aceeași ecuație ca în orice rasterizator semitransparent din anii 1980:

C_pixel = sum_i alpha_i * T_i * c_i

T_i = prod_{j < i} (1 - alpha_j)       transmitanța până la i
alpha_i = opacity_i * exp(-0.5 * d^T Sigma'^-1 d)   contribuția locală
c_i = eval_SH(SH_i, view_direction)    culoare dependentă de privire

Aceasta este aceeași ecuație ca redarea volumetrică a NeRF, doar că operează pe un set explicit și rar de Gaussiene în locul eșantioanelor dense de-a lungul unei raze. Această identitate explică de ce calitatea redată se potrivește cu NeRF — ambele integrează aceeași ecuație a câmpului de radianță.

Notă tehnică a traducerii: Formula cu T_i = prod_{j < i} este forma de compunere din față spre spate atunci când indicele crește cu adâncimea. Rasterizarea 3DGS și integrarea volumetrică NeRF au relații conceptuale, dar nu sunt aceeași ecuație discretizată: folosesc primitive, kerneluri, eșantionare și aproximații diferite. Prin urmare, calitatea nu este garantată ca echivalentă; ea se compară experimental pentru datele și protocolul concrete.

De ce este diferențiabil

Fiecare pas — proiecție, alocare pe tile-uri, compunere alpha, evaluare SH — este diferențiabil în raport cu parametrii Gaussianei. Având o imagine de adevăr de referință, calculați pierderea pixelilor redați, propagați gradientul înapoi prin rasterizator și actualizați prin coborâre de gradient toți (mu, q, s, alpha, c_lm). În aproximativ 30.000 de iterații, Gaussienele își găsesc pozițiile, scările și culorile corecte.

Notă tehnică a traducerii: Gradientele sunt calculate pentru operațiile continue folosite de rasterizator, însă sortarea după adâncime, inclusiv torch.argsort din exemplul de mai jos, alocarea discretă pe tile-uri și schimbările de vizibilitate nu sunt diferențiabile în sens strict față de permutare. Rendererele diferențiabile folosesc convenții și aproximații pentru aceste discontinuități. Numărul de iterații și convergența depind de scenă, inițializare, optimizator, pierderi și hardware.

Densificare și pruning

Un set fix de Gaussiene nu poate acoperi o scenă complexă. Antrenarea include două mecanisme adaptive:

• Clonați o Gaussiană în poziția sa curentă când magnitudinea gradientului este mare, dar scala sa este mică — reconstrucția are nevoie de mai multe detalii aici.
• Divideți o Gaussiană cu scală mare în două mai mici când gradientul său este mare — o Gaussiană mare este prea netedă pentru a potrivi regiunea.
• Eliminați Gaussienele a căror opacitate scade sub un prag — ele nu contribuie.

Densificarea rulează la fiecare N iterații. O scenă crește de obicei de la aproximativ 100k Gaussiene inițiale (inițializate din puncte SfM) la 1–5M la finalul antrenării.

Notă tehnică a traducerii: Pragurile, programul de densificare, regulile de clonare/divizare și numărul final de Gaussiene sunt hiperparametri, nu proprietăți fixe ale 3DGS. Inițializarea din puncte SfM este frecventă și este susținută de Splatfacto pentru anumite tipuri de date, dar alte fluxuri pot inițializa diferit.

Armonicile sferice într-un paragraf

Culoarea dependentă de privire este o funcție c(direction) pe sfera unitară. Armonicile sferice sunt baza Fourier a sferei. Trunchiați la gradul L și obțineți (L+1)^2 funcții de bază pentru fiecare canal. Evaluarea culorii pentru o vedere nouă este un produs scalar între coeficienții SH învățați și baza evaluată în direcția privirii. Gradul 0 = un coeficient = culoare constantă. Gradul 3 = 16 coeficienți = suficient pentru a surprinde iluminare Lambertiană, reflexii speculative și reflexii ușoare. Lucrările SD Gaussian Splatting folosesc gradul 3 implicit.

Notă tehnică a traducerii: Ordinea SH, convenția de bază, normalizarea și activarea culorii sunt alegeri de implementare. Un grad 3 poate aproxima variații dependente de direcție cu frecvență joasă, dar nu garantează modelarea fidelă a reflexiilor complexe; „lucrările SD” nu identifică o sursă tehnică verificabilă.

Stackul de producție din 2026

1. Captură          smartphone / dronă DJI / scaner portabil
2. SfM / MVS        COLMAP sau GLOMAP deduce pozițiile camerelor + puncte rare
3. Antrenați 3DGS   nerfstudio / gsplat / inria official / PostShot (~10-30 min pe RTX 4090)
4. Editați          SuperSplat / SplatForge (curățați floaters, segmentați)
5. Exportați        .ply -> glTF KHR_gaussian_splatting sau .usd (OpenUSD 26.03)
6. Vizualizați      Cesium / Unreal / Babylon.js / Three.js / Vision Pro

Notă tehnică a traducerii: SfM estimează în mod tipic poziții ale camerelor și geometrie rară; MVS este o etapă separată pentru geometrie densă. Durata de 10–30 de minute, instrumentele de editare și compatibilitatea export–viewer trebuie verificate pentru versiunea, hardware-ul și datele concrete. La data verificării, KHR_gaussian_splatting este Release Candidate, iar documentația Splatfacto confirmă exportul .ply, nu un export nativ glTF din fluxul descris aici.

Variante 4D și generative

• 4D Gaussian Splatting — Gaussienele sunt funcții de timp; folosit pentru video volumetric (Superman 2026, „Helicopter” al lui A$AP Rocky).
• Splats generative — modele text-la-splat (Marble de la World Labs) care halucinează scene întregi.
• 3D Gaussian Unscented Transform — varianta NuRec de la NVIDIA pentru simularea conducerii autonome.

Notă tehnică a traducerii: Modelele dinamice 4D extind 3DGS prin deformări sau atribute dependente de timp, dar arhitecturile nu se reduc în general la variația mediilor și opacităților. 3DGUT (3D Gaussian Unscented Transform) vizează proiecții de cameră neliniare, inclusiv distorsiune fisheye și rolling shutter; numele său nu stabilește singur o soluție generală de simulare pentru conducere autonomă. Afirmațiile despre produse, clipuri și exemple comerciale sunt dependente de versiune și nu stabilesc capabilități standard ale 3DGS.

Construiți

Pasul 1: o Gaussiană 2D

Mai întâi construim un rasterizator 2D. Cazul 3D se reduce la el după proiecție.

import torch
import torch.nn as nn
import torch.nn.functional as F


def eval_2d_gaussian(means, covs, points):
    """
    means:  (G, 2)      centres
    covs:   (G, 2, 2)   covariance matrices
    points: (H, W, 2)   pixel coordinates
    returns: (G, H, W)  density at every pixel for every Gaussian
    """
    G = means.size(0)
    H, W, _ = points.shape
    flat = points.view(-1, 2)
    inv = torch.linalg.inv(covs)
    diff = flat[None, :, :] - means[:, None, :]
    d = torch.einsum("gpi,gij,gpj->gp", diff, inv, diff)
    density = torch.exp(-0.5 * d)
    return density.view(G, H, W)

einsum efectuează forma pătratică diff^T Sigma^-1 diff pentru fiecare pereche (Gaussiană, pixel).

Pasul 2: rasterizator 2D cu splatting

Compunere alpha din față spre spate. Adâncimea în 2D nu are sens, așa că folosim un scalar învățat pentru fiecare Gaussiană drept ordine.

def rasterise_2d(means, covs, colours, opacities, depths, image_size):
    """
    means:     (G, 2)
    covs:      (G, 2, 2)
    colours:   (G, 3)
    opacities: (G,)     in [0, 1]
    depths:    (G,)     per-Gaussian scalar used for ordering
    image_size: (H, W)
    returns:   (H, W, 3) rendered image
    """
    H, W = image_size
    yy, xx = torch.meshgrid(
        torch.arange(H, dtype=torch.float32, device=means.device),
        torch.arange(W, dtype=torch.float32, device=means.device),
        indexing="ij",
    )
    points = torch.stack([xx, yy], dim=-1)

    densities = eval_2d_gaussian(means, covs, points)
    alphas = opacities[:, None, None] * densities
    alphas = alphas.clamp(0.0, 0.99)

    order = torch.argsort(depths)
    alphas = alphas[order]
    colours_sorted = colours[order]

    T = torch.ones(H, W, device=means.device)
    out = torch.zeros(H, W, 3, device=means.device)
    for i in range(means.size(0)):
        a = alphas[i]
        out += (T * a)[..., None] * colours_sorted[i][None, None, :]
        T = T * (1.0 - a)
    return out

Nu este rapid — o implementare reală folosește kerneluri CUDA bazate pe tile-uri — însă matematica este exact cea potrivită și complet diferențiabilă.

Pasul 3: o scenă 2D cu splats antrenabile

class Splats2D(nn.Module):
    def __init__(self, num_splats=128, image_size=64, seed=0):
        super().__init__()
        g = torch.Generator().manual_seed(seed)
        H, W = image_size, image_size
        self.means = nn.Parameter(torch.rand(num_splats, 2, generator=g) * torch.tensor([W, H]))
        self.log_scale = nn.Parameter(torch.ones(num_splats, 2) * math.log(2.0))
        self.rot = nn.Parameter(torch.zeros(num_splats))  # single angle in 2D
        self.colour_logits = nn.Parameter(torch.randn(num_splats, 3, generator=g) * 0.5)
        self.opacity_logit = nn.Parameter(torch.zeros(num_splats))
        self.depth = nn.Parameter(torch.rand(num_splats, generator=g))

    def covs(self):
        s = torch.exp(self.log_scale)
        c, si = torch.cos(self.rot), torch.sin(self.rot)
        R = torch.stack([
            torch.stack([c, -si], dim=-1),
            torch.stack([si, c], dim=-1),
        ], dim=-2)
        S = torch.diag_embed(s ** 2)
        return R @ S @ R.transpose(-1, -2)

    def forward(self, image_size):
        covs = self.covs()
        colours = torch.sigmoid(self.colour_logits)
        opacities = torch.sigmoid(self.opacity_logit)
        return rasterise_2d(self.means, covs, colours, opacities, self.depth, image_size)

log_scale, opacity_logit și colour_logits sunt toți parametri neconstrânși, mapați prin activarea potrivită în momentul redării. Acesta este tiparul standard pentru fiecare implementare 3DGS.

Notă tehnică a traducerii: Parametrizarea neconstrânsă urmată de activări este des întâlnită, dar nu este obligatorie pentru fiecare implementare 3DGS. În exemplu, exp(log_scale) păstrează covarianța pozitiv definită, iar sigmoid limitează opacitatea; o implementare de producție trebuie să trateze și stabilitatea covarianțelor, regulile de densificare și convențiile de culoare.

Pasul 4: potriviți Gaussiene 2D unei imagini-țintă

import math
import numpy as np

def make_target(size=64):
    yy, xx = np.meshgrid(np.arange(size), np.arange(size), indexing="ij")
    img = np.zeros((size, size, 3), dtype=np.float32)
    # Red circle
    mask = (xx - 20) ** 2 + (yy - 20) ** 2 < 10 ** 2
    img[mask] = [1.0, 0.2, 0.2]
    # Blue square
    mask = (np.abs(xx - 45) < 8) & (np.abs(yy - 40) < 8)
    img[mask] = [0.2, 0.3, 1.0]
    return torch.from_numpy(img)


target = make_target(64)
model = Splats2D(num_splats=64, image_size=64)
opt = torch.optim.Adam(model.parameters(), lr=0.05)

for step in range(200):
    pred = model((64, 64))
    loss = F.mse_loss(pred, target)
    opt.zero_grad(); loss.backward(); opt.step()
    if step % 40 == 0:
        print(f"step {step:3d}  mse {loss.item():.4f}")

În 200 de pași, cele 64 de Gaussiene se așază în cele două forme. Aceasta este întreaga idee — coborâre de gradient pe primitive geometrice explicite.

Notă tehnică a traducerii: Cele 200 de iterații și numărul de 64 de Gaussiene sunt alegeri demonstrative, nu un rezultat reproductibil garantat. Convergența depinde de inițializare, ordinarea adâncimii, rata de învățare, pierdere și versiunea PyTorch.

Pasul 5: de la 2D la 3D

Extensia 3D păstrează aceeași buclă. Completările sunt:

1. Rotația pentru fiecare Gaussiană este un cuaternion în locul unui singur unghi.
2. Covarianța este R S S^T R^T, cu R construit din cuaternion și S = diag(exp(log_scale)).
3. Proiecția (mu, Sigma) -> (mu', Sigma') folosește extrinsecele camerei și Jacobiana proiecției în perspectivă la mu.
4. Culoarea devine o dezvoltare în armonici sferice; evaluați-o în direcția privirii.
5. Sortarea după adâncime provine din z-ul real în spațiul camerei în locul unui scalar învățat.

Fiecare implementare de producție (gsplat, inria/gaussian-splatting, nerfstudio) face exact aceasta pe GPU cu kerneluri CUDA bazate pe tile-uri.

Notă tehnică a traducerii: Implementările enumerate împărtășesc principiile 3DGS, însă nu execută „exact” aceeași buclă: pot diferi prin camera modelată, densificare, randare, scheduler, regularizare, precizie și extensii dinamice. Validați contractul și versiunea pachetului selectat.

Pasul 6: evaluarea armonicilor sferice

Baza SH până la gradul 3 are 16 termeni pentru fiecare canal. Evaluare:

def eval_sh_degree_3(sh_coeffs, dirs):
    """
    sh_coeffs: (..., 16, 3)   last dim is RGB channels
    dirs:      (..., 3)       unit vectors
    returns:   (..., 3)
    """
    C0 = 0.282094791773878
    C1 = 0.488602511902920
    C2 = [1.092548430592079, 1.092548430592079,
          0.315391565252520, 1.092548430592079,
          0.546274215296039]
    x, y, z = dirs[..., 0], dirs[..., 1], dirs[..., 2]
    x2, y2, z2 = x * x, y * y, z * z
    xy, yz, xz = x * y, y * z, x * z

    result = C0 * sh_coeffs[..., 0, :]
    result = result - C1 * y[..., None] * sh_coeffs[..., 1, :]
    result = result + C1 * z[..., None] * sh_coeffs[..., 2, :]
    result = result - C1 * x[..., None] * sh_coeffs[..., 3, :]

    result = result + C2[0] * xy[..., None] * sh_coeffs[..., 4, :]
    result = result + C2[1] * yz[..., None] * sh_coeffs[..., 5, :]
    result = result + C2[2] * (2.0 * z2 - x2 - y2)[..., None] * sh_coeffs[..., 6, :]
    result = result + C2[3] * xz[..., None] * sh_coeffs[..., 7, :]
    result = result + C2[4] * (x2 - y2)[..., None] * sh_coeffs[..., 8, :]

    # degree 3 terms omitted here for brevity; full 16-coefficient version in the code file
    return result

sh_coeffs învățați stochează „culoarea în fiecare direcție” pentru acea Gaussiană. La redare evaluați față de direcția curentă a privirii și obțineți un vector RGB cu 3 componente.

Notă tehnică a traducerii: În ciuda numelui funcției și a formei cu 16 coeficienți, fragmentul implementează numai gradele 0–2 (coeficienții 0–8). Comentariul precizează omisiunea termenilor de grad 3; nu utilizați funcția ca evaluator complet de grad 3 fără cei șapte termeni rămași și fără a confirma convenția SH folosită.

Utilizați

Pentru lucru 3DGS real, utilizați gsplat (Meta) sau nerfstudio:

pip install nerfstudio gsplat
ns-download-data example
ns-train splatfacto --data path/to/data

splatfacto este antrenorul 3DGS al nerfstudio. Rularea durează 10–30 de minute pe un RTX 4090 pentru o scenă tipică.

Opțiuni de export importante în 2026:

• .ply — nor Gaussian brut (portabil, fișierul cel mai mare).
• .splat — format cuantizat PlayCanvas / SuperSplat.
• glTF KHR_gaussian_splatting — standard Khronos, portabil între viewere (RC în februarie 2026).
• OpenUSD UsdVolParticleField3DGaussianSplat — nativ USD, pentru fluxuri NVIDIA Omniverse și Vision Pro.

Pentru scene 4D / dinamice, 4DGS și Deformable-3DGS extind același mecanism cu medii și opacități variabile în timp.

Notă tehnică a traducerii: gsplat este un proiect open-source al comunității nerfstudio, nu un produs Meta. Documentația nerfstudio confirmă comanda ns-train splatfacto --data <data> și exportul .ply. În CLI-ul curent, ns-download-data example din blocul păstrat fidel nu este o comandă validă: pentru un set inclus, o formă validă este ns-download-data nerfstudio --capture-name=poster; pentru fotografii proprii, preprocesați-le cu ns-process-data images --data <imagini> --output-dir <date> înainte de antrenare. Verificați separat durata, memoria și formatul de export pentru versiunea instalată. Extensia glTF era încă Release Candidate la verificare, iar .splat nu este un format unic standardizat. Nu presupuneți compatibilitate directă cu schema USD sau cu toate viewerele din listă.

Livrați

Această lecție produce:

• outputs/prompt-3dgs-capture-planner.md — un prompt care planifică o sesiune de captură (număr de fotografii, traseu al camerei, iluminare) pentru un tip de scenă dat.
• outputs/skill-3dgs-export-router.md — o competență care alege formatul potrivit de export (.ply / .splat / glTF / USD) în funcție de viewerul sau motorul din aval.

Exerciții

1. (Ușor) Rulați antrenorul 2D cu splats de mai sus pe o imagine sintetică diferită. Variați num_splats în [16, 64, 256] și reprezentați MSE în funcție de pas pentru fiecare. Identificați punctul randamentelor descrescătoare.
2. (Mediu) Extindeți rasterizatorul 2D pentru a susține culori RGB pentru fiecare Gaussiană, dependente de un scalar „unghi de privire” printr-o armonică de gradul 2. Antrenați pe o pereche de imagini-țintă și verificați că modelul le reconstruiește pe amândouă.
3. (Dificil) Clonați nerfstudio și antrenați splatfacto pe o captură cu 20 de fotografii a oricărei scene disponibile (birou, plantă, față, cameră). Exportați în glTF KHR_gaussian_splatting și deschideți-l într-un viewer (Three.js GaussianSplats3D, SuperSplat, Babylon.js V9). Raportați timpul de antrenare, numărul de Gaussiene și fps-ul redat.

Termeni-cheie

Termen	Ce spun oamenii	Ce înseamnă de fapt
3DGS	„Gaussian splats”	Reprezentare explicită a scenei ca milioane de Gaussiene 3D cu poziție, rotație, scală, opacitate și culoare SH pentru fiecare Gaussiană
Covarianță	„Forma Gaussianei”	Sigma = R S S^T R^T; orientarea și scala anizotropă ale unei Gaussiene
Compunere alpha	„Amestecare din spate spre față”	Ecuație înrudită cu redarea volumetrică NeRF, aplicată acum peste un set explicit și rar
Densificare	„Clonați și divizați”	Adăugare adaptivă de Gaussiene noi acolo unde reconstrucția este subajustată
Pruning	„Ștergeți opacitatea mică”	Eliminați Gaussienele care au colapsat spre opacitate aproape zero în timpul antrenării
Armonici sferice	„Culoare dependentă de privire”	Bază Fourier pe sferă; stochează culoarea ca funcție de direcția privirii
Splatfacto	„3DGS-ul nerfstudio”	Implementarea nerfstudio pentru antrenarea Gaussian splatting, cu propriile extensii
KHR_gaussian_splatting	„Standard glTF”	Extensie Khronos în stadiul Release Candidate pentru stocarea 3DGS în glTF

Lecturi suplimentare

• 3D Gaussian Splatting for Real-Time Radiance Field Rendering (Kerbl et al., SIGGRAPH 2023) — lucrarea originală
• gsplat (Meta/nerfstudio) — rasterizator CUDA de calitate pentru producție
• nerfstudio Splatfacto — rețeta de antrenare de referință
• Extensia Khronos KHR_gaussian_splatting — formatul portabil din 2026
• Notele de lansare OpenUSD 26.03 — schema UsdVolParticleField3DGaussianSplat
• THE FUTURE 3D State of Gaussian Splatting 2026 — prezentare de ansamblu a industriei

Sursă: Originalul în limba engleză

Navigare: ← Lecția 04.21 — Detectarea punctelor-cheie și estimarea poziției · Faza 4 — Viziune computerizată · Lecția 04.23 — Transformere de difuzie și flux rectificat → · Catalog complet