Is splatting the same as ordinary image blurring?

No. Splatting accumulates data into an intermediate representation; blurring is the next stage.

Why keep a weight channel?

It lets normalized filtering account for how much input support contributed to each result.

Must slicing use the original input positions?

No. Some applications query different positions, such as locations derived from a higher-resolution guide.

AI Glossary / Computer vision and multimodal AI / Intermediate

Splat, blur, slice

Definition

Splat, blur, slice is a three-stage pattern for efficient filtering in a space of features. Input values are accumulated onto a grid or lattice, the accumulated values are filtered there, and results are interpolated back at query locations. It is widely associated with fast bilateral and other high-dimensional Gaussian filtering methods.

What it means

A normal image blur mixes values according to nearby image positions. A bilateral filter also considers appearance: two neighboring pixels with very different colors should influence each other less.

One way to express this is to give each pixel a position in a larger space containing both its image coordinates and its color. Pixels across an image edge can be close in the image but far apart in that feature space. Blurring in the larger space can therefore mix similar pixels while reducing mixing across the edge.

Directly comparing many pairs of pixels can be expensive. Splat, blur, slice moves the work to a structured intermediate representation. It is a computational pattern, not a promise of exact filtering or a synonym for three-dimensional Gaussian-splatting scene rendering.

How it works

Splat: map each input to feature coordinates and distribute its value to nearby grid or lattice vertices with interpolation weights. Accumulate a normalization weight as well when the desired output is a normalized average.

Blur: filter both the value accumulations and normalization accumulations within the intermediate structure. The structure and blur kernel determine the approximation and computational cost.

Slice: interpolate the filtered accumulations at each query's feature coordinates, then divide the value sum by the corresponding weight when normalization is required. Handle locations with insufficient support explicitly.

Feature scaling controls similarity. Grayscale bilateral filtering can use scaled x, y, and intensity coordinates; color filtering can use x, y, and three color components. Grid and permutohedral-lattice implementations differ in how they store space and interpolate. For joint filtering, a separate guide supplies the feature coordinates while the values being filtered come from another aligned signal.

Three practical examples

1. Edge-aware denoising: a system smooths a noisy image using a representation that reduces interaction between pixels on opposite sides of strong appearance changes.

2. Guided upsampling: a low-resolution signal is accumulated into a guide-dependent space and queried using a higher-resolution guide, with checks for incorrect transfer of guide texture.

3. Interactive editing: an application accelerates a broad edge-aware adjustment by doing much of the filtering in a structured intermediate space instead of revisiting a large neighborhood for every output pixel.

Think of it this way

Think of sorting survey responses into nearby bins defined by location and another shared characteristic, averaging neighboring bins, then estimating a response for each participant from the bins around them.

The analogy depends on preserving counts. A bin containing many observations should not automatically count the same as one containing only a single observation. Feature-space filtering also uses continuous weights rather than necessarily assigning each input to just one bin.

Worked example

Here is a two-vertex arithmetic illustration, not a full bilateral-grid implementation. Suppose splatting places one value of two at vertex A and three values of ten at vertex B. Store value sums v = (2,30) and weight sums w = (1,3).

Use a toy blur that keeps three quarters of each vertex's accumulation and takes one quarter from the other. The blurred value sums are vA = 0.75×2 + 0.25×30 = 9 and vB = 0.25×2 + 0.75×30 = 23. The blurred weights are wA = 1.5 and wB = 2.5.

At A itself, the normalized answer is 9/1.5 = 6. At B, it is 23/2.5 = 9.2. Now slice halfway between the two vertices with equal interpolation weights. Interpolating the accumulations gives a numerator of (9 + 23)/2 = 16 and denominator of (1.5 + 2.5)/2 = 2. The normalized result is eight.

If we normalized at the vertices first and simply averaged six and 9.2, we would obtain 7.6 instead. This difference shows why the placement of normalization matters when following a specific splat - blur - slice formulation.

This bookkeeping example omits multidimensional coordinates, boundary rules, and a Gaussian kernel. Those choices affect actual filter accuracy.

Illustrative case study

Fictional case: a photo-editing team wants a responsive edge-aware smoothing control. It compares a direct reference filter with an accelerated grid implementation on faces, fabric, and strong boundaries.

The grid version shows faint banding under one coarse feature-space resolution. The team adjusts the representation and compares error against the reference rather than assuming every difference is desirable smoothing. It also tests sparse regions where normalization weights are small.

The configuration reflects a quality - cost tradeoff. This fictional case establishes no timing result or universally superior data structure.

Common misconceptions and mistakes

Do not confuse feature coordinates with values being filtered. They can come from different signals in a joint filter.

Do not discard normalization weights when implementing an average. Unequal sampling density can otherwise change the result in unintended ways.

Avoid assuming a coarse grid gives an exact bilateral filter. Quantization, interpolation, kernel design, and feature scaling affect the approximation. A guide edge can also be irrelevant to the target signal, causing incorrect structure transfer. Edge-aware does not mean object-aware or semantically correct.

Business use

Splat, blur, slice helps make some broad or high-dimensional filtering operations practical for interactive software and vision pipelines. Its usefulness comes from reorganizing computation while retaining a controlled approximation to the intended filter.

Benchmark both output error and runtime on representative inputs. Include difficult edges, color variation, sparse support, and large filter widths. Record feature scaling and normalization conventions so later optimizations can be evaluated against the same mathematical target instead of only a visually pleasing example.

Check your understanding

After slicing, the filtered value sum is sixteen and the weight sum is two. What is the normalized result?

Answer: Eight. Returning sixteen would leave the accumulation unnormalized and would make the output depend on the amount of contributing support.

Related terms

Bilateral grid
Feature space
Bilateral filter
joint bilateral filter
permutohedral lattice
interpolation
normalized convolution
guided upsampling

Learn next

Trace both a value channel and a weight channel through a tiny grid. Then compare image-space distance with combined position-and-color distance to see why a feature-space blur can behave differently near an image edge.

Feature space

Sources

Adams, Baek, and Davis, Fast High-Dimensional Filtering Using the Permutohedral Lattice: https://graphics.stanford.edu/papers/permutohedral/permutohedral.pdf The paper was read for the stages, feature space, and normalization. Calculations and scenarios are original.

Previous: SPL notation Next: Split-half reliability