Every piece is on the table: a camera that turns 3D points into pixels, a Gaussian's falloff-weighted opacity, depth-ordered alpha compositing. Nothing left to introduce — just wire them together and render an actual pixel, start to finish.
A small red Gaussian sits close to the camera, a bigger blue one sits farther back and slightly off to the side. Drag the query pixel across the scene: right where the red one projects, the pixel is almost pure red; drift toward the blue one's projected center and it shifts, tempered by however much red is still bleeding through in front of it.
The full pipeline, chained: project (ch. 2's camera, applied to each Gaussian's center, plus ch. 5's world-to-screen spread shrink), then composite (ch. 4's falloff-weighted opacity, ch. 5's nearest-first ordering) —
- — a Gaussian's world-space center; — where it projects to on screen.
- — a Gaussian's spread before and after projection.
- — transmittance remaining before Gaussian ; — what's left after every Gaussian, painted with the background.
- Project both Gaussians through the same pinhole camera as chapter 2
- The near, on-axis Gaussian () projects to the principal point with .
- The farther, off-axis one () projects to with .
- Composite at the near Gaussian's own projected center, (50, 50)
Weight is exactly 1 there, so the near Gaussian's contribution is just its opacity: . Transmittance remaining: .
- The far Gaussian and the background split what's left
3 units away in a spread-3 blob, the far Gaussian's weight is , giving alpha and contribution (all in blue, since the far Gaussian is pure blue). The remaining transmittance goes to the white background.
Summing each channel — near Gaussian's contribution, far Gaussian's contribution, background's contribution:
- Red:
- Green:
- Blue:
Final pixel — mostly red, tinted by blue, softened by background white.
Same scene, formula values spelled out live: watch shrink for the farther Gaussian (it's already smaller on screen despite being the physically larger one, vs. ) and watch each Gaussian's contribution bar move as the query pixel crosses between them.
Two more query pixels through the same rendered scene:
- Query pixel (53, 50) — the far Gaussian's own projected center
Now the far Gaussian's weight is 1 there instead: its raw alpha is , but it composites second (nearest-first), so its actual contribution depends on how much the near Gaussian (weaker here, off its own center) left behind.
- Query pixel (60, 50) — past both projected centers
Both Gaussians' weights have decayed further from their falloffs; the background's white starts to dominate the composited pixel, since neither Gaussian has much opacity left to contribute out there.
Drag the query pixel between the two Gaussians' projected centers until the rendered red channel reaches ≈ 0.5.
This is the entire Part, chained into one function: a camera projects Gaussians from 3D to 2D (ch. 2, 5), each Gaussian's opacity falls off from its projected center (ch. 4), depth order decides who paints first (ch. 5), and the whole pipeline is differentiable end to end so every parameter — position, spread, opacity, color — can be optimized directly against real photographs (ch. 5's gradient descent). Where the starting Gaussians come from — a real 3D scan, or conjured from a text prompt (ch. 6) — is a separate question from how, once you have them, you turn them into a pixel. That "how" is what this capstone just rendered.