💻 computer science

3DGBGS: 3D Granular Ball Gaussian Splatting for Compact Novel View Synthesis

The paper proposes 3DGBGS, a compact anchor-based framework for novel-view synthesis that adaptively partitions SfM point clouds into 3D granular balls to optimize anchor initialization and scale priors, thereby significantly reducing model storage and anchor counts while maintaining rendering quality.

Original authors: Meng Yang, Shuyin Xia, Dawei Dai, YiWang

Published 2026-07-30

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Meng Yang, Shuyin Xia, Dawei Dai, YiWang

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a perfect, photorealistic 3D replica of the world using only a pile of scattered digital dust. This is the heart of a field called "Novel View Synthesis," where computers learn to generate new pictures of a scene from angles the camera never actually saw. For a long time, the best tools for this were like trying to paint a masterpiece by placing millions of tiny, independent dots of paint one by one. While this worked, it was slow and required a massive amount of storage space, like trying to carry a library in your backpack just to show a friend a picture of a tree.

Then, a new technique arrived called "3D Gaussian Splatting." Instead of just dots, it used little fuzzy, 3D ellipsoids (think of them as soft, glowing jellybeans) that could be blended together to create smooth, real-time images. It was fast and beautiful, but it still had a problem: in big, empty spaces like a clear blue sky or a plain white wall, the computer kept adding way too many jellybeans, just to be safe. This made the digital files huge and clunky. The big question for researchers was: How can we keep the picture perfect without filling our hard drives with unnecessary jellybeans?

Enter 3DGBGS, a new method that acts like a smart organizer for this digital dust. The researchers behind this paper realized that the way computers currently build these 3D scenes is a bit like using a cookie cutter that's always the same size. If you try to cut a giant cookie and a tiny crumb with the same cutter, you end up with a mess of crumbs where you just needed a few big pieces. The paper proposes a smarter way to group the data before building the scene, using a concept called "Granular Ball Computing."

Think of the digital dust (the point cloud) as a crowd of people at a concert. In some areas, like the VIP section, the crowd is dense and chaotic; in other areas, like the back of the stadium, people are spread out and calm. The old method treated everyone the same, putting a small "anchor" (a support post) under every single person, even the ones standing in a wide-open field. This created a forest of support posts where only a few were needed.

The new 3DGBGS method acts like a wise crowd manager. It looks at the crowd and says, "In this smooth, empty area, we can cover a huge group of people with just one big, comfortable umbrella." But in the chaotic, detailed areas, it switches to "small, precise umbrellas" to make sure no one gets left out. These "umbrellas" are the 3D Granular Balls.

Here is how the magic happens:

Smart Grouping: Instead of forcing the data into a rigid grid, the computer groups the points into these flexible 3D balls. Big balls cover the boring, smooth parts of the scene (like walls or skies), and tiny balls hug the complex parts (like a tree branch or a face).
Fewer Anchors: Because one big ball can represent a whole smooth area, the computer needs far fewer "anchor" posts to hold the scene together. The paper found that this method reduced the number of starting anchors by about 37.1% and the final number of anchors by 10.0%.
Better Size Guessing: The size of these balls also tells the computer how big the "jellybeans" (Gaussians) should be. This helps the computer guess the right size immediately, rather than having to guess and check later.

The results are impressive. By using this "smart umbrella" strategy, the researchers showed that they could shrink the file size of the 3D model by an average of 9.8%. Even more importantly, they did this without making the pictures look worse. In fact, in some tests, the new method actually produced slightly sharper images while using less memory.

The paper explicitly argues against the idea that we must use a fixed, uniform grid (like a standard Lego brick size) to build these scenes. They demonstrate that this "one-size-fits-all" approach is inefficient for real-world scenes, which are naturally messy and uneven. Instead, they suggest that adapting the size of our building blocks to the shape of the object is the key to efficiency.

In short, 3DGBGS proves that you don't need a million tiny bricks to build a castle; sometimes, you just need a few giant ones for the walls and a few tiny ones for the turrets. It's a way to make 3D worlds smaller, faster, and just as beautiful, proving that sometimes, the best way to see the details is to stop looking at every single grain of sand and start seeing the shape of the beach.

Technical Summary: 3DGBGS: 3D Granular Ball Gaussian Splatting for Compact Novel View Synthesis

Problem Statement

Three-dimensional Gaussian Splatting (3DGS) has established a new standard for high-quality, real-time novel-view synthesis by utilizing explicit Gaussian primitives and differentiable rasterization. However, the efficiency of 3DGS relies on a coarse-to-fine refinement process that can lead to representation redundancy, particularly in large-scale scenes or regions with smooth textures.

To address storage and optimization overhead, recent "anchor-based" methods (e.g., Scaffold-GS) organize local Gaussian distributions around sparse anchors derived from Structure-from-Motion (SfM) point clouds. These methods typically construct anchors via fixed voxelization, quantizing the point cloud into a regular grid. While stable, this approach fails to adapt to the spatial non-uniformity of real-world SfM data. Specifically:

Over-segmentation: Smooth regions (e.g., walls, backgrounds) receive excessive spatial support units, increasing model size without adding detail.
Under-representation: Coarse voxelization may fail to capture complex geometry, occlusion boundaries, or fine local details in structurally intricate areas.

The core challenge is to construct a flexible, multi-granularity spatial scaffold that adapts to local point-cloud complexity, thereby reducing anchor redundancy while preserving necessary structural support.

Methodology

The authors propose 3DGBGS (3D Granular Ball Gaussian Splatting), a framework that integrates Granular Ball Computing (GBC) into the anchor-based 3DGS pipeline. GBC, inspired by the human cognitive principle of "large-scale first," adaptively organizes data into granular balls of varying scales through a coarse-to-fine process.

The 3DGBGS pipeline consists of three primary stages:

1. Adaptive Granular Ball Construction

Instead of fixed voxelization, 3DGBGS recursively partitions the non-uniform SfM point cloud into a set of 3D granular balls ( $GB_j$ ).

Partitioning Strategy: The algorithm employs a PCA-based binary partitioning strategy. It calculates the spatial covariance of a point set and splits it along the principal eigenvector direction.
Stopping Criteria: Partitioning terminates when a point set satisfies specific conditions: the number of points falls below a minimum threshold ( $N_{min}$ ), the recursion depth reaches a maximum ( $D_{max}$ ), or the set is both spatially compact (small radius) and appearance-consistent (low variance in color/texture).
Result: This yields larger granular balls for smooth, redundant regions and smaller, finer balls for complex geometric or textural areas.

2. Granular Ball Anchor Initialization (GBAI)

The centers ( $\mu_j$ ) of the generated granular balls are used to initialize the positions of the anchor scaffold ( $A_{GB}$ ).

Mechanism: Unlike fixed voxel centers, GBAI produces an anchor layout that is adaptively determined by the local distribution of the SfM points.
Benefit: In smooth regions, fewer, larger anchors cover the area; in complex regions, denser, smaller anchors preserve detail. This significantly reduces the initial number of spatial support units.

3. Granular Ball Scale Prior (GBSP)

The radii ( $r_j$ ) of the granular balls are utilized to provide local scale priors for the Gaussian primitives generated from each anchor.

Scale Fusion: The initial scale is derived by fusing the nearest-neighbor distance between anchors (standard practice) with the granular ball radius. The radius-based prior is constrained by the nearest-neighbor scale to ensure stability.
Benefit: This ensures that the initial spatial extent of the generated Gaussians aligns with the local point-cloud coverage, preventing the generation of excessively small or large primitives that do not match the underlying geometry.

Following initialization, 3DGBGS follows the standard Scaffold-GS optimization pipeline, using lightweight MLPs to predict Gaussian attributes (opacity, color, scale, rotation) and differentiable splatting for rendering. The training objective remains identical to Scaffold-GS, utilizing $L_1$ , DSSIM, and volume regularization losses.

Key Contributions

3DGBGS Framework: A compact anchor-based 3D Gaussian splatting framework that replaces fixed voxelization with adaptive 3D granular ball partitioning. This provides structure-aware spatial supports adapted to local point-cloud distributions.
GBAI and GBSP Modules:
- GBAI: Uses granular ball centers to initialize compact anchor positions, reducing redundant spatial supports in smooth regions.
- GBSP: Exploits granular ball radii to provide local scale priors, enabling generated Gaussians to better conform to local spatial structures.
Performance Efficiency: The method achieves a favorable balance between model compactness and rendering quality, demonstrating that adaptive organization of SfM points can reduce storage and optimization costs without sacrificing visual fidelity.

Experimental Results

The authors evaluated 3DGBGS on 19 scenes across four real-world benchmarks: Mip-NeRF 360, Tanks&Temples, Deep Blending, and BungeeNeRF. The method was compared directly against Scaffold-GS, the baseline anchor-based approach.

Anchor Reduction: 3DGBGS reduced the number of initial anchors by 37.1% and final anchors by 10.0% on average compared to Scaffold-GS.
Storage Efficiency: The model storage size was reduced by 9.8% on average.
Rendering Quality: Despite the significant reduction in parameters, 3DGBGS maintained rendering quality comparable to Scaffold-GS. In specific benchmarks (e.g., BungeeNeRF), it even achieved slight improvements in PSNR and SSIM while using fewer anchors.
Computational Cost: Analysis of anchor growth schedules showed that 3DGBGS consistently maintained fewer final anchors and lower GFLOPs (up to ~29% reduction in specific cases) while preserving rendering quality.

Significance and Claims

The paper claims that the natural compatibility between 3DGS and Granular Ball Computing allows for a more efficient adaptive modeling process. By mimicking the "coarse-to-fine" and "on-demand" refinement principles of GBC, 3DGBGS addresses the limitations of uniform voxelization in handling spatially non-uniform data.

The authors assert that their work demonstrates the effectiveness of adaptive granular-ball organization for compact novel-view synthesis. They emphasize that the reduction in anchor count and storage is achieved not by compressing existing features, but by fundamentally reorganizing the spatial scaffold construction to match the intrinsic complexity of the scene. The method preserves the ability to render high-quality novel views while significantly lowering the memory footprint and computational overhead associated with anchor-based representations.

Future work, as noted by the authors, will explore anisotropic granular representations and learnable partitioning strategies to further refine the trade-off between compactness and quality in structurally complex scenes.