GALA: Geometry-Aware Local Adaptive Grids for Detailed 3D Generation

## Abstract

Abstract We propose GALA, a novel representation of 3D shapes that (i) excels at capturing and reproducing complex geometry and surface details, (ii) is computationally efficient, and (iii) lends itself to 3D generative modelling with modern, diffusion-based schemes. The key idea of GALA is to exploit both the global sparsity of surfaces within a 3D volume and their local surface properties. Sparsity is promoted by covering only the 3D object boundaries, not empty space, with an ensemble of tree root voxels. Each voxel contains an octree to further limit storage and compute to regions that contain surfaces. Adaptivity is achieved by fitting one local and geometry-aware coordinate frame in each non-empty leaf node. Adjusting the orientation of the local grid, as well as the anisotropic scales of its axes, to the local surface shape greatly increases the amount of detail that can be stored in a given amount of memory, which in turn allows for quantization without loss of quality. With our optimized C++/CUDA implementation, GALA can be fitted to an object in less than 10 seconds. Moreover, the representation can efficiently be flattened and manipulated with transformer networks. We provide a cascaded generation pipeline capable of generating 3D shapes with great geometric detail.

## 1 Introduction

The generation of high-quality 3D assets remains a costly task in terms of processing time and resources involving human efforts or machine compute.
A continuing research pursuit is to develop efficient 3D representations to streamline the traditionally expensive 3D creation workflow  Gupta et al. (), Jun & Nichol (), Li et al. (), Nichol et al. (), Shue et al. (), with the ultimate goal of speeding up the generative process without compromising the diversity and quality of the generated assets as reflected by their structural and geometric details.

To date, a variety of 3D representations including voxel Li et al. () and tetrahedral grids Kalischek et al. (), meshes Liu et al. (), point clouds Luo & Hu (), Zhou et al. (), neural fields Jun & Nichol (), and triplanes Chan et al. (), Shue et al. (), Gupta et al. (), have been employed for 3D generation, often leveraging powerful diffusion-based generators.
However, as argued recently by Yariv et al. (), none of these representations fulfill all of the three critical criteria for high-quality and scalable 3D generation:
parameter efficiency for detail representation, preprocess efficiency for handling large datasets and
mesh conversion, as well as simplicity of a
tensorial form to suit modern-day neural processing.
In response to this, they proposed Mosaic-SDF which
encodes a signed distance function using a “mosaic” of aligned volumetric grids distributed over the shape surface, with different centers and different (still isotropic) scales.

In this paper, we accentuate that the key to 3D representation efficiency when using such an ensemble-of-tiles approach is adaptivity of the local coordinate grids to the geometry of the presented shapes. To this end, we propose to represent a 3D shape using a set of geometry-aware and local adaptive grids. Our novel representation, coined GALA, pushes the limit of adaptivity on three fronts:

- •
To exploit the global sparsity of typical object surfaces within a 3D volume, we place a forest of octrees, rather than uniform subdivisions, at the object boundaries, where a local grid is associated with each non-empty octree leaf node to store SDF values.
- •
Our local grids are not globally aligned. Instead, each grid may be differently oriented based on local PCA analysis of surface normals within the corresponding octree subdivision.
- •
Last but not least, we anisotropically scale each grid to better capture geometric details.

Our GALA representation can be implemented to yield sets of vectors that can be easily processed by transformer-based neural networks Vaswani et al. (), while the octree forest provides a hierarchical 3D representation with limited depths.
In  Table 1, we compare GALA with several state-of-the-art representative methods over several useful criteria.

The contributions of our work are threefold:

- 1.
Our geometry-aware, locally adaptive, and anisotropic grids enable more efficient (Table 1) and accurate sampling of shape structures, capturing geometric details, such as thin strings and plates, which may be missed by both regular grid-based methods Hui et al. (), Li et al. () and Mosaic-SDF, whose grid tiles are neither shape- nor detail-aware.
- 2.
We have developed an efficient implementation in pure CUDA and libtorch(^1^11https://pytorch.org/cppdocs/) for the entire GALA extraction process. This process costs about 10 seconds for each watertight input mesh on Nvidia A100 GPU, which is among the fastest ones of popular fitting methods, enabling fast data processing for large datasets.
- 3.
The hierarchical structure of the octree forest in GALA facilitates the development of a practical cascaded 3D generation scheme with improved efficiency and quality.

**Table 1: Properties of different representations for 3D generation. The representation precision is defined as the reconstruction errors with respect to input meshes. See subsection 4.3 for more.**
| Methods | Description of representation | Parameter<br>Count $\downarrow$ | Fitting<br>Time $\downarrow$ | Representation<br>Precision | Generation<br>Network |
| --- | --- | --- | --- | --- | --- |
| S2VS Zhang et al. () | Autoencoded vector set | $\leq$ 262k | - | Meidum/Low | Transformer |
| MeshDiffusion Liu et al. () | Deformable tetrahedral grid | $\geq$ 1.05M | 20m-30m | High/Medium | 3D UNet |
| Neural Wavelet Hui et al. () | Two levels of wavelet coefficients | 536k | 1s | Medium | 3D UNet |
| Mosaic-SDF Yariv et al. () | Grids on boundary | 355k | 2m | High | Transformer |
| GALA (ours) | Trees with adaptive grids on boundary | 277k | 10s | High | Transformer |
|  |  |  |  |  |  |

## 2 Related Work

### 2.1 3D Representation for Generation

We will first review the related work on 3D representation for generation, focusing on various methods characterized by shared features.

Grid-based Regular grid-based representations Hui et al. (; ), Li et al. () utilize a fixed-resolution grid for encoding various 3D quantities such as occupancy, signed distance function (SDF), color and etc. Such methods, however, may not capture extremely fine structures at the very initial stage of discretization. Additionally, regular grid-based representations allocate a substantial portion of their capacity to the empty spaces, leading to a potential cubic rate of parameter increase. In contrast, the adaptive local grids in GALA are able to capture thin structures and the octree forest allows for scaling the representation power with only a linear increase of parameters.
Deep Marching Tetrahedra Shen et al. () (DMTet) uses deformable tetrahedral grids to improve the representation efficiency compared with regular grids. However, the fitting time Liu et al. () of DMTet is about 10 times ours, the parameter count of DMTet is 3 times ours (See Table 1 for specific numbers.) while we represent geometry more accurately than it.

Triplane To mitigate the cubic complexity inherent in regular grid-based methods, triplane approaches Chan et al. (), Shue et al. (), Gupta et al. () employ three planes, each aligned with an axis in 3D space. Information at each 3D location is queried by first tri-linear interpolation from the three planes, followed by processing through various neural network architectures. Although triplane-based representations enhance parameter efficiency compared to regular grid-based methods, the tri-linear interpolation may result in oversmoothed outcomes and also missing geometric details.

Point Cloud Point cloud-based representations  Luo & Hu (), Zhou et al. (), Zeng et al. () describe 3D shapes by placing points on geometry boundaries. To accurately describe the shape, excessive number of points will be needed, which is not practical for the following generation task. Limited number of points will loss details of the shape. Moreover, post-processing methods Kazhdan et al. (), Peng et al. () are required to convert point clouds to meshes, which may introduce additional inductive bias.

Neural Implicit Neural implicit representations Park et al. (), Chen & Zhang () model 3D shapes by learning mappings between coordinates and desired 3D quantities. When combined with the autoencoding framework, latent codes Zhang et al. (), Chou et al. () are derived. A drawback of these methods is that the autoencoding may result in oversmoothed geometric features. Furthermore, mesh extraction from neural implicit representations requires querying numerous points in space, yielding expensive neural network evaluations. In contrast, GALA enables direct and efficient extraction of geometries without the involvement of any neural network.

Lastly, we would address the work of Mosaic-SDF Yariv et al. () individually. Different from our method, Mosaic-SDF only has a single level of voxels and each voxel has a isotropic scale for each axis. In this sense, it has limited adaptation in representing the geometry. Moreover, it has to model the whole distribution as a whole at once while previous researches Saharia et al. (), Pernias et al. () have shown hierarchical or cascaded generation may benefit the generation.

### 2.2 Graph and Tree Generation

General graph generation relies on the Graph Neural Network and message passing mechanism. Others like HGGT Jang et al. () use graph compression methods such as $K^{2}-$Tree and sequentially generate tree nodes in an autoregressive way. In our case, generating an arbitrary topology graph is unnecessary because we focus on generating octrees. OGN Tatarchenko et al. () uses recursive way of generating octree voxels and Octree Transformer Ibing et al. () uses autoregressive way of generating tree nodes by transformers. In contrast with their methods, we use the widely adopted and effective generation paradigm, the diffusion model. BrepGen Xu et al. () generates fixed topology face-edge-vertice trees hierarchically by diffusion. Since the topology is fixed, the corresponding relation can be easily injected when training the diffusion model. We plan to adopt similar cascaded generation scheme to BrepGen based on our GALA representation.

## 3 Method

We will introduce our methods in two parts: subsection 3.1 the construction of GALA from the input watertight meshes and subsection 3.2 the cascaded generation of GALA.

Figure: Figure 3: In our representation, GALA, tree root nodes, as voxels, are initialized over mesh surfaces (gray line), each with location $\mathbf{p}\in\mathbb{R}^{3}$ and scale $s\in\mathbb{R}$. Descendant node voxels are deduced recursively with each child voxel, with overlapping, and expanded at ratio $\alpha\in\mathbb{R}$ into depth $d$. Only at a non-empty leaf node subdivision (light green) would a local adaptive grid of resolution $m\in\mathbb{N^{+}}$ be extracted with location $\mathbf{p}_{g}\in\mathbb{R}^{3}$, orientation quaternion $\mathbf{q}\in\mathbb{R}^{4}$ , scales $\mathbf{s_{g}}\in\mathbb{R}^{3}$, and values $V\in\mathbb{R}^{m^{3}}$. $N_{o},\alpha,m,d$ are hyperparameters. In contrast, Mosaic-SDF Yariv et al. () (left) employs mosaic patches, each fully occupied by a single-level, axis-aligned, and isotropic grid.
Refer to caption: x3.png

### 3.1 Construction of GALA

We illustrate the overall GALA structure in 2D in Figure 3 and will dissect the construction process into: subsubsection 3.1.1 Octree forest initialization, subsubsection 3.1.2 Local adaptive grid extraction, subsubsection 3.1.3 Refinement and subsubsection 3.1.4 Fitting-aware Quantization.

#### 3.1.1 Octree Forest Initialization

Given the number of trees $N_{o}$, we find the centroids $\mathbf{p}$ of tree root node voxels by Farthest Point Sampling (FPS) Eldar et al. () of densely sampled points $\mathcal{X}$ on the mesh of the input object. Then, to determine the scale $s$ of each root voxel $i$, we assign each sampled point $\mathbf{x}\in\mathcal{X}$ to its nearest centroid and define the scale scalar as the infinity-norm radius of each cluster:

$$ $s_{i}=\max_{\mathbf{x}\in\mathcal{C}_{i}}\|\mathbf{x}-\mathbf{p}_{i}\|_{\infty },\quad\mathcal{C}_{i}=\left\{\mathbf{x}\in\mathcal{X}\ \bigg{|}\ i=\underset{ k\in\{0,\dots,N_{o}-1\}}{\arg\min}\|\mathbf{x}-\mathbf{p}_{k}\|_{2}\right\}$ (1) $$

In this way, we ensure that the forest will fully cover the shape boundaries. After setting the tree root voxels, we recursively deduce the further levels of tree nodes in an overlapping way where we slightly expand the divided spaces at each level by ratio $\alpha$. This expansion operation enables more voxels to contribute to the geometry modeling at early
tree levels. See 4.5 for the ablation study of $\alpha$.

#### 3.1.2 Local Adaptive Grid Extraction

Figure: Figure 4: Illustration of local adaptive grid extraction in 2D. Within each subdivision (blue square), (a) an OBBTree Gottschalk et al. () determines the orientation of the local bounding box according to the convex hull of the subdivided local geometry. (b) Different from OBBTree, we determine the orientation of the local adaptive grid using PCA on bounded normal vectors ($\overrightarrow{n}$). (c) Moreover, we rescale the grid anisotropically to better capture the local geometry, as informed by the histogram (d) of sampled points (small dark gray dots) on triangle meshes projected along each axis of the grid. The •/• are grid samples with negative/positive signs.
Refer to caption: x4.png

Properly placing the local adaptive grid within each subdivision is essential to our method. The OBBTree Gottschalk et al. () determines the orientation of the local bounding box using eigenvectors of the covariance matrix derived from points sampled on the convex hull faces of the subdivided geometry (Figure 4(a)). However, we take a different approach. Instead of only defining a bounding box, we use a grid designed to capture as much geometric information as possible. Because the orientation derived from convex hull sample points may not align with the actual geometric structure, we align the grid orientation with PCA of the local normal vectors $\overrightarrow{n}$ instead (Figure 4(b)).

Additionally, we rescale the grid so that at least one set of grid samples locates at the most geometrically dense spot and adjacent grid samples with different signs capture more zero isosurfaces (Figure 4(c)). To achieve this, we utilize the histogram $\mathcal{H}$ of sampled points projected along each grid axis $\mathbf{u}_{i}$ and move nearest and smaller grid samples to the histogram peak (Figure 4(d), Algorithm 1)

Figure: Algorithm 1 Rescaling the Grid with Histogram

We will show the effectiveness of our local adaptive grid extraction by ablation studies in subsection 4.5. After determining the locations, orientations and scales of anisotropic local grids, truncated ground truth SDF Hui et al. () values (truncated to $[-0.1,0.1]$) are used to initialize the grid values $V$. All the above initialization and extraction processes before refinement cost few seconds (as $2.56\pm 1.30$s in ShapeNet Airplane). More detailed information on the time measurement, see 4.7.

#### 3.1.3 Refinement

After extracting the local adaptive grids, we further refine the grid values $V$ by backpropagation to represent the input geometry more accurately. For each queried location $\mathbf{x}$, the queried value $v_{\mathbf{x}}$:

$$ $v_{\mathbf{x}}=\frac{1}{\sum_{i}w(\mathbf{x},i)}\sum_{i}w(\mathbf{x},i)\mathbf {I}(\mathbf{x},i),$ (2) $$

$$ $w(\mathbf{x},i)=\text{ReLU}\big{[}1-\|(\mathbf{x}-\mathbf{p}_{g}^{i})\mathbf{O }_{i}\cdot\mathbf{s}_{i}^{-1}\|_{\infty}\big{]},$ (3) $$

where $\mathbf{I}(\mathbf{x},i)$ (Equation 2) is the tri-linear interpolation of grid values $V$ within the anisotropic local grid $i$ that encapsulates the query $\mathbf{x}$ and $w(\mathbf{x},i)$ (Equation 3) is the weighting function which is defined by the infinity ball centered at the grid center $\mathbf{p}_{g}^{i}$ and rotation matrix $\mathbf{O}_{i}\in\mathbb{R}^{3\times 3}$. All grid values will be optimized by MSE loss $L_{\text{MSE}}=\mathbb{E}(\|v_{\mathbf{x}}-v_{\text{GT}}(\mathbf{x})\|_{2})$ using backpropagation, where $v_{\text{GT}}(\mathbf{x})$ is the truncated ground truth SDF value at location $\mathbf{x}$ directly computed from input meshes. We assign $v_{\mathbf{x}}=0.1$ if $\mathbf{x}$ does not lie in any local grid. We will flip these signs of interior parts to $-0.1$ via a DFS method detailed in A.1 when extracting meshes from GALA.

#### 3.1.4 Fitting-aware Quantization

To increase the storage (see more at B.3) and memory efficiency of GALA as well as lower the difficulty of aligning float values in space inspired by the discrezation step in MeshGPT Siddiqui et al. (), we quantize the local adaptive grid related quantities $\mathbf{q},\mathbf{p}_{g},\mathbf{s_{g}},V$ during the fitting process by Straight-Through Estimator (STE) Bengio et al. (), Han et al. (). We quantize the orientation in the unit of $\frac{\pi}{60}$ of Euler angles and $\mathbf{s}_{g},\mathbf{p}_{g},V$ in 8 bit of the range $[0,0.1],[-0.5,0.5],[-0.1,0.1]$.

### 3.2 Cascaded Generation of GALA

Motivated by previous cascaded generation works Saharia et al. (), Ho et al. (), Xu et al. (), Hui et al. (), Chen et al. () which successfully generate complicated 2D or 3D data in a coarse-to-fine manner, we generate sets of information $X_{o},X_{V},X_{\bar{V}}$ of GALA step by step where flattened vectors of root node $\mathbf{x}_{o}\in\mathbb{R}^{4}=\mathbb{R}^{3}$($\mathbf{p}$) $+\mathbb{R}$($s$), grid values
$\mathbf{x}_{V}\in\mathbb{R}^{m^{3}}$, and grid configuration $\mathbf{x}_{\bar{V}}\in\mathbb{R}^{10}=\mathbb{R}^{4}$($\mathbf{q}$)$+\mathbb{R}^{3}$($\mathbf{s}_{g}$)$+\mathbb{R}^{3}$($\mathbf{p}_{g}$) belong to one of the sets respectively (Refer to A.2 for more details on the data preparation). Specially, since the configurations of local adaptive grids $X_{\bar{V}}$ already encode rich local geometric information as articulated in subsubsection 3.1.2, we are able to directly regress $X_{V}$ from $X_{\bar{V}}$, which greatly alleviates the generation training burden.

Figure: Figure 5: GALA generates shapes in a cascaded manner by (1) Root voxel diffusion; (2) Local adaptive grid configuration diffusion; (3) Local adaptive grid value prediction by regression.
Refer to caption: x5.png

All sets of vectors are processed by transformer-based networks Vaswani et al. (), Peebles & Xie (). (1) The class label $y$ conditioned distribution of root voxels $P(X_{o}|y)$ is firstly modeled by diffusion model Song et al. (), Ho et al. (). (2) Configurations of anisotropic local grids $X_{\bar{V}}$ are generated following that via modeling $P(X_{\bar{V}}|X_{o},y)$ by diffusion model. (3) Lastly, grid values $V$ are predicated from grid configurations $\bar{V}$ via $X_{V}=F(X_{\bar{V}},y)$ and trained by L2 regression loss. More specifically speaking, as we can see in Figure 5.(2), siblings of padded leaves are grouped and folded once and previously generated root voxel information $x_{o,i}\in X_{o}$ is added directly to the nodes of its corresponding descendants together with local positional encodings (PE) of trees to differentiate siblings among them. In all, following the popular diffusion training paradigm Ho et al. (), Song et al. (), we update the diffusion network weights $\theta$ via the v-prediction Salimans & Ho ():

$$ $\nabla_{\theta}\|v-v_{\theta}\big{(}X^{t}_{\bar{V}},t,y,X_{o}\big{)}\|^{2}, \quad v=\alpha_{t}X^{0}_{\bar{V}}-\sigma_{t}\epsilon$ (4) $$

where $X^{t}_{\bar{V}}=\sqrt{\bar{\alpha_{t}}}X^{0}_{\bar{V}}+\sqrt{1-\bar{\alpha_{t}
}}\epsilon,X^{0}_{\bar{V}}\sim q(X_{\bar{V}}),\epsilon\sim\mathcal{N}(\mathbf{
0},\mathbf{I})$ is the diffusion forward process. $\bar{\alpha}_{t}$ is defined by $\bar{\alpha}_{t}=\prod^{t}\alpha_{t},\alpha_{t}=1-\beta_{t}$ where $\beta_{t}$ is the variance schedule. $\sigma_{t}=\sqrt{1-\bar{\alpha}_{t}}$ and cosine noise scheduling Nichol & Dhariwal () is used. The network weights $\phi$ for the first step are updated in a similar manner as described above. For more details, please refer to A.4.

## 4 Experiments and Results

### 4.1 Implementation Details

For the hyperparameter of GALA, we set tree root number $N_{o}=256$, child node expanding ratio $\alpha=0.2$, grid resolution $m=5$ and depth $d=1$. The number of histogram bins $\mathcal{H}$ is $2m$. For the refinement process, 8192 points are queried near surfaces on each run for 400 iterations. Details of the pure C++/CUDA implementation will be found at A.3.

For the cascaded generation, each network for every generation step is consisted of 24 transformer layers with model channel 1024. AdamW Loshchilov & Hutter () with $\text{lr}=8e^{-5},\beta_{1}=0.9,\beta_{2}=0.999$ is adopted. We test the reconstruction and generation ability of our methods on the whole ShapeNet Chang et al. () dataset. We follow the dataset split of previous works Zhang et al. (; ), Yariv et al. () and train conditional generation on the whole ShapeNet classes.

### 4.2 Metrics

We evaluate reconstruction results using Chamfer Distance (CD) between two sampled 3D objects and also report the Light Field Distance (LFD) Chen et al. (), a widely adopted Chen et al. (), Gao et al. (), Zuo et al. () visual similarity metric that is well-known from computer graphics. To evaluate the generation results, we adopt the metric of Maximum Mean Discrepancy (MMD), Coverage (COV), and 1-nearest neighbor accuracy (1-NNA) based on Chamfer Distance (CD) and Earth Mover Distance (EMD) Luo & Hu (), Zeng et al. ().

### 4.3 Reconstruction Results

We compare our reconstruction results with 3DShape2VecSet (S2VS) Zhang et al. (), Neural Wavelet (NW) Hui et al. () and MeshDiffusion (DMTet, $64^{3}\times 4$) Liu et al. (). We measure the reconstruction metrics on 50 objects of ShapeNet classes (airplane, car, char, basket, guitar), 10 objects per class. From Table 2, we can see that our reconstruction is more accurate than other baselines. $\mathcal{A}$ means local adaptive grids. Without $\mathcal{A}$, uniform grid samplings will be placed within tree voxels in the axis-aligned way. Visual comparisons on results w/o $\mathcal{A}$ are shown in B.1, where the local adaptive grid setting captures more accurate details on geometry surfaces. Qualitative comparison of reconstruction is shown in Figure 6. As we can see from Figure 6, we preserve the most geometric details with one of the fewest parameter numbers.

**Table 2: Reconstruction quality across 5 ShapeNet classes (airplane, basket, car, chair, guitar; 10 random objects per class).**
| Metric | S2VS | NW | MeshDiffusion | Ours, w/o $\mathcal{A}$ | Ours |
| --- | --- | --- | --- | --- | --- |
| LFD $\downarrow$ | 2429.92 | 1869.80 | 1301.14 | 1146.74 | 1109.36 |
| CD $\downarrow$ ($\times 10^{-3}$) | 4.32 | 4.17 | 2.61 | 1.52 | 1.18 |
| #Parameters | $\leq$ 262k | 536k | 1.05M | 263k | 277k |

Because we do not have the official code release from Mosaic-SDF Yariv et al. (), we requested the reconstruction results from the authors of Mosaic-SDF and compare the reconstruction of ours with them qualitatively in Figure 7. As we can see from Figure 7, the car is a challenging example shown in Mosaic-SDF and with complicated exterior and interior structures such as very thin and close surfaces. GALA can capture exterior and interior geometry structures at the same time. In contrast, the result of Mosaic-SDF fails to capture internal structures. As for the guitar example, GALA has the better connection of guitar strings and the thickness of strings is closer to the ground truth than it of Mosaic-SDF.

Figure: Figure 6: Qualitative comparison of reconstruction results between ours and other important baselines. S2VS^† Zhang et al. () is evaluated from the public checkpoint provided in the official repository and S2VS^‡ is our own implementation. All evaluated at resolution $256^{3}$. Zoom in to see more details.
Refer to caption: x6.png

Figure: Figure 7: Qualitative comparison of the reconstruction result with Mosaic-SDF Yariv et al. (). Mosaic-SDF results are provided by the author directly. We reveal the complicated internal structures of the input GT and the reconstructed results by slicing them based on Slice3D Wang et al. ().
Refer to caption: x7.png

### 4.4 Generation Results

**Table 3: Generation quality for ShapeNet classes of airplane and chair. By convention, MMD-CD has been multiplied by $10^{3}$ and MMD-EMD by $10^{2}$ for readability.**
|  | airplane | chair |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
|  | COV($\uparrow$,%) | MMD($\downarrow$) | 1-NNA($\downarrow$,%) | COV($\uparrow$,%) | MMD($\downarrow$) | 1-NNA($\downarrow$,%) |  |  |  |  |  |  |
|  | CD | EMD | CD | EMD | CD | EMD | CD | EMD | CD | EMD | CD | EMD |
| 3DIGL | 41.09 | 32.67 | 4.69 | 4.73 | 82.67 | 84.41 | 37.87 | 39.94 | 20.37 | 10.54 | 74.11 | 69.38 |
| NW | 51.98 | 45.05 | 3.36 | 4.19 | 68.32 | 73.76 | 43.79 | 47.04 | 16.53 | 9.47 | 59.47 | 64.20 |
| S2VS | 51.98 | 40.59 | 3.80 | 4.45 | 69.06 | 76.73 | 51.78 | 52.37 | 16.97 | 9.44 | 58.43 | 60.80 |
| Mosaic-SDF | 52.48 | 51.49 | 3.54 | 3.78 | 62.62 | 69.55 | 48.22 | 55.03 | 15.47 | 9.13 | 51.04 | 55.62 |
| Ours | 52.91 | 51.49 | 2.48 | 2.84 | 59.90 | 57.43 | 52.21 | 53.10 | 13.28 | 8.17 | 53.10 | 54.57 |

From Table 3, we show our cascaded generation on GALA produces shapes better than other baselines quantitatively. We also provide qualitative results on Figure 8 to show that our generation gives much geometry details in generation results. Please see the supplementary file for more generation results.

Figure: Figure 8: The qualitative comparison of generation results. Additional results of ShapeNet vessel and train are shown between S2VS and ours to demonstrate the detailed generation of ours.
Refer to caption: x8.png

### 4.5 Ablation Studies

##### Local Grid Extraction.

**Table 4: Ablating the anisotropic local grid extraction components ($\overrightarrow{n},\mathcal{H}$) on the same set of data of reconstruction test. ^†: without quantization.**
| Metrics | vanilla | + $\overrightarrow{n}$ | + $\overrightarrow{n},\mathcal{H}$ |
| --- | --- | --- | --- |
| CD $\downarrow$ ($\times 10^{-3}$) | 1.55 | 1.33 | 1.18 (1.08^†) |
| HD $\downarrow$ ($\times 10^{-2}$) | 1.46 | 1.19 | 1.06 (0.98^†) |
|  |  |  |  |

We conduct the ablation study on the components in local adaptive grid extraction, including determining orientation by bounded normals ($\overrightarrow{n}$) and rescaling with histogram ($\mathcal{H}$). Table 4 shows the effectiveness of our local adaptive grid extraction design and limited degradation by the quantization procedure. We further give some qualitative examples in Figure 9 to show that corresponding components help better capture the detailed geometries.

Figure: Figure 9: Qualitative examples of GALA fitting results on Left: rescaling the local grid with histogram or not; Right: determining the grid orientation with normals or not. Zoom in to see more.
Refer to caption: x10.png

##### More Tree Setting.

We examine the effect of varying tree counts $N_{o}$ (with depth $d=2$) on three examples, as shown in Figure 10. As we can see in Figure 10, using $N_{o}=32$ with fewer than 200k parameters already yields low-error reconstructions across the three distinct example objects. Furthermore, even at $N_{o}=16$ and fewer than 100k parameters, our method effectively captures significant geometric details, such as the missiles on the airplane’s rear and the lamp’s strings, demonstrating the method’s great adaptability.

Figure: Figure 10: Influence of tree count $N_{o}$ (with depth $d=2$) on three examples.
Refer to caption: x11.png

##### Overlapping Subdivision

Figure: Figure 11: Ablation of child overlap $\alpha$.
Refer to caption: x12.png

We show the reconstruction performance by presenting Chamfer Distance (CD) of different overlap ratios $\alpha$ of subdivision in Figure 11. To avoid making the tree too sparse at early levels while maintaining the tree structures, we expand the subdivision with ratio $\alpha$. However, expanding too much would decrease the granularity of each subdivision, we find a sweet spot $\alpha=0.2$ by scanning it on the reconstruction test set.

### 4.6 Compared With Self-Implemented MSDF

Figure: Figure 12: Compare GALA with our self-implemented Mosaic-SDF (MSDF^†).
Refer to caption: x13.png

Based on our own GALA implementation, we also implemented our own version of Mosaic-SDF (MSDF), where we tried to strictly follow its original setting, such as $m=7$ for each of the axis-aligned and isotropic grid sampling. Firstly, as we can see from the left part of Figure 12, with the same low parameter budget (82k) and even the additional quantization step, our GALA represents much more faithful geometric structures such as smooth lampshade and accurate strings than MSDF, CD ($\times 10^{-3}$) 1.3 vs. 1.7. Secondly, in the right part of Figure 12, our reimplemented MSDF shows a smoother internal structures than the officially provided one but have more uneven exterior surfaces.

### 4.7 Time Measurement of GALA Fitting

Figure: (a) ShapeNet Airplane: $\mathbf{2.56}\pm 1.30$, $\mathbf{5.60}\pm 1.86$
Refer to caption: extracted/5923691/figures/airplane_fitting_time.png

In this section, we present detailed time measurements of our GALA fitting process. The measurements were conducted under the configuration of 6 virtualized logical cores (hyper-thread) of AMD EPYC 7413 @2.65GHz and 1 Nvidia A100. We show the fitting time statistics plots as in Figure 13 of 250 objects from ShapeNet Airplane and ShapeNet Chair respectively. The extraction (blue) time includes all initialization and local adaptive grid extraction process, namely all the procedures other than the refinement. Based on the comprehensive statistics shown in Figure 13, we show that our implementation indeed achieves very fast fitting in less than 10 seconds overall, as stated previously. Additionally, the peak GPU memory usage during GALA fitting is recorded at less than 800MB.

### 4.8 Novelty of Generated Results

Figure: Figure 14: Two generated shapes and three visually closest (left to right) training shapes retrieved using LFD.
Refer to caption: x14.png

In Figure 14,
we show two shapes generated by our method and three closest training shapes retrieved via nearest neighbour search (NN) using LFD Chen et al. (). We can see that our generations have detailed and distinct geometric structures from those in the training set, demonstrating our method’s generative novelty.

### 4.9 Application: Autocompletion

Due to the hierarchical structure of GALA and the cascaded generation pipeline, we are able to roughly outline the objects to be generated using coarse and partial root voxels. Based on the work RePaint Lugmayr et al. (), we autocomplete the given root voxels by substituting intermediate results at timesteps with the given ones during denoising process. See Figure 15 for the results.

Figure: Figure 15: Given the partial root voxels (orange), we autocomplete the rest (blue) and generate geometries.
Refer to caption: x15.png

### 4.10 Texturing the Generated Mesh

Figure: Figure 16: Texturing generated meshes.
Refer to caption: x16.png

First carving the mesh and then adding textures is a standard workflow in 3D asset creation within the industry. It allows flexibility of creating various textures while reusing the fine meshes already crafted. Many previous works Zhang et al. (), Perla et al. (), Cao et al. (), Chen et al. (), Richardson et al. () in deep learning also adopt similar strategies. Therefore, to show our generated meshes can be easily textured, in  Figure 16, we use Easi-Tex Perla et al. () to texture examples of our generated meshes by reference images.

## 5 Conclusion and Future Work

We present GALA, geometry-aware local adaptive grids for detailed 3D generation. We demonstrate that GALA can represent detailed geometries efficiently with fewer parameters. Additionally, we propose a cascaded generation approach for GALA that produces detailed geometry. We also deliver an efficient C++/CUDA implementation of GALA that completes fitting in seconds, significantly enhancing the practical usage of our method. For future work, compact graph representations Bouritsas et al. (), Jo et al. (), Jang et al. () may facilitate tree compression within the forest and further ease the generation step. In addition, we show failure cases of imperfect root voxel generation in Appendix C, which we may improve that using better diffusion training scheme in the near future. Also of interests is to remove the watertight constraint on the input meshes and extend GALA and the ensuring generation to unsigned distance fields (UDFs).

## Appendix A Implementation Details

### A.1 Flipping Signs of the Interior Parts

Figure: Figure 17: Flip signs of 0.1 islands (connected components) surrounded by negatives.
Refer to caption: x17.png

We will flip the signs of connected components of 0.1 surrounded by negative values in a SDF slice $S\in\mathbb{R}^{\ell\times\ell}$ extracted from GALA, where $\ell$ is the extracted SDF grid resolution. It is a Depth-first Search (DFS) algorithm as described in Algorithm 2. This post-processing procedure will eliminate redundant geometry blobs in interior parts of objects as illustrated in Figure 17.

Figure: Algorithm 2 Flip Signs of the Interior Parts

### A.2 Data Preprocessing

For each root or non-empty leaf tree node, information will be saved as illustrated in Figure 18. The voxel position $\mathbf{p}$ and scale $s$ (Figure 18.Right) would only be recorded and generated at the root level. The $\mathbf{p},s$ of subsequent levels of tree nodes will be deduced deterministically from the root voxels. The parent index and sibling index (Figure 18.Left) is only recorded for recover the tree structure and will not be explicitly generated. Quaternion is used to represent the orientation of the local grid. Moreover, local grid locations and scales are stored and generated. All the quantities within the tree node vector will be normalized to [0,1] by $\min,\max$ statistics calculated within each data domain ($\mathbf{p},s,\mathbf{p}_{g}$,etc) of specific datasets.

Figure: Figure 18: Octree Node Information. Left: the Parent Index $\in[0,\dots,N_{0}\times 8^{l-1}-1]$ and Sibling Index$\in[0,\dots,7]$, $l$ is the tree level and $N_{0}$ is the tree root number. When $l=0$, placeholder values are put on the two indices; Middle: local adaptive grid related information, the scales $\mathbf{s}_{g}$ and position $\mathbf{p}_{g}$ of the grid are stored; Right: the values of root voxels $\mathbf{p},s$.
Refer to caption: x18.png

The GALA of each object will be flattened and stored as the format illustrated in Figure 19.

Figure: Figure 19: The data format of GALA to be flattened and stored.
Refer to caption: x19.png

### A.3 Details of the Pure C++/CUDA Implementation and Code Release

Figure: Figure 20: The algorithm flowchart of our GALA extraction.
Refer to caption: extracted/5923691/figures/OFALG_extract_flow.png

We show the algorithm flowchart Figure 20 of the initialization stage of GALA, which is built upon CUDA, Libtorch, a third-party R-Tree based SDF query library(^2^22https://github.com/sxyu/sdf) and few head only utility libraries such as C++ argparse(^3^33https://github.com/p-ranav/argparse). We will dig into the details of the implementation step by step as follows.

Normalize Vertices We shift the vertices by the center location ($(\frac{x_{\text{max}}+x_{\text{min}}}{2},\frac{y_{\text{max}}+y_{\text{min}}}{
2},\frac{z_{\text{max}}+z_{\text{min}}}{2})$) and then scale them by the diagonal distance ($\sqrt{(x_{\text{max}}-x_{\text{min}})^{2}+(y_{\text{max}}-y_{\text{min}})^{2}+
(z_{\text{max}}-z_{\text{min}})^{2}}$).

Construct Bounding Volume Hierarchy (BVH) In order to quickly search relevant mesh information in the space, we construct Bounding Volume Hierarchy (BVH) on GPU parallelly via radix tree according to Karras (). We encountered some bug when doing the GPU parallel bottom-up AABB (Axis-Aligned Bounding Box) construction of the radix tree where very few random items of AABB ($\sim$ 0.01%) at z-dimension were randomly corrupted for each run. To circumvent this, we copy the whole tree back to CPU, conduct a DFS post-order traverse to construct the AABB and copy the results back to GPU.

Densely Sampling Points On Meshes We sample $10\times N_{t}$ points on meshes where $N_{t}$ is the number of triangles of the input mesh. We randomly sample points on triangles using barycentric coordinates. The number of points sampled at each triangle is proportional to its surface area.

Initial Point of Farthest Point Sampling As described in the main text, in order to augment our representation, the extraction algorithm also accepts the index of the initial FPS point. This enables possible data augmentation of GALA representation by choosing different initial FPS points for the same input mesh.

Determining Orientation by Normals As detailed in the main text, we estimate the orientation of the local grid using the eigenvectors of the covariance matrix of the bounded normal vectors. We get the eigenvectors in each local grid in parallel on each GPU thread using Jacobi eigenvalue algorithm Golub & Van Loan (), where the maximum iteration is set as 50 and the tolerance for maximum off-diagonal value is $1e^{-10}$.

### A.4 More details on Cascaded Generation

Figure: Figure 21: The network details of the cascaded generation pipeline, composed by steps: (1) root voxel diffusion $P(X_{o}|y)$ by diffusion; (2) Local adaptive grid configuration generation $P(X_{\bar{V}}|X_{o},y)$ by diffusion; (3) Local adaptive grid value prediction $X_{V}=F(X_{\bar{V}},y)$ trained by regression.
Refer to caption: x20.png

As shown in Figure 21, our generation networks are based on transformer networks Vaswani et al. (). The root voxel conditions and local positional encodings of the tree are injected in an in-context manner through addition, while the timestep condition is injected using the adaLN-Zero block from DiT Peebles & Xie (), and the object class condition is injected via cross-attention. Additionally, noise augmentation is applied, as in previous works Ho et al. (), Xu et al. (), Saharia et al. (), to mitigate the impact of the training/inference discrepancy in cascaded generation. Furthermore, zero-terminal Lin et al. () is adopted to ensure the last timestep of diffusion starts from a zero signal-to-noise ratio (SNR). Classifier-free guidance Ho & Salimans () is used, with an additional null label trained as $y$ during diffusion training, and $w=0$ is applied during classifier-free guidance in diffusion inference.

## Appendix B Other Ablation Studies

### B.1 More Illustration on w/o 𝒜 𝒜 \mathcal{A} caligraphic_A

As we can see from Figure 22, since the anisotropic local grid setting ($\mathcal{A}$) enables close and adaptive sampling on object surfaces, the full setting of GALA captures much more accurate and artifact-free surfaces than w/o $\mathcal{A}$.

Figure: Figure 22: Qualitative comparison between GALA (ours, Middle) and GALA without anisotropic local grids (w/o $\mathcal{A}$, Right). The Left is the ground truth (GT).
Refer to caption: x21.png

### B.2 Mesh Extraction Efficiency

As in the Mosaic-SDF Yariv et al. () paper, we report the mesh extraction time at resolution $256^{3}$ and $512^{3}$ on NVIDIA A100 in Table 5. We show that with our implementation, the mesh extraction process of ours is very efficient. To further dissect the running time of our mesh extraction process, we show the flip-sign algorithm on CPU(^†) consists half of the time. Further improvement can be done by adopting GPU graph traversal algorithm like Merrill et al. (). The configuration is the same as stated in subsection 4.7.

**Table 5: Extraction efficiency comparison with Mosaic-SDF and other baselines on NVIDIA A100. ^† means the running time of the DFS-based flip-sign algorithm detailed in subsection A.1 on CPU. ^∗ means when measuring the inference time of S2VS, we conduct queries of $256^{2}$ or $512^{2}$ slice every time and loop for the whole grid in order to avoid OOM issue on GPU.**
| Method | Resolution | Time(s) | Method | Resolution | Time(s) |
| --- | --- | --- | --- | --- | --- |
| 3DIGL Zhang et al. () | $256^{3}$ | 18.44 | 3DIGL Zhang et al. () | $512^{3}$ | 159.56 |
| S2VS Zhang et al. () | $256^{3}$ | 5.62^∗ | S2VS Zhang et al. () | $512^{3}$ | 24.49^∗ |
| Mosaic-SDF Yariv et al. () | $256^{3}$ | 2.74 | Mosaic-SDF Yariv et al. () | $512^{3}$ | 21.84 |
| Ours | $256^{3}$ | 2.39<br>(1.26 + 1.23^†) | Ours | $512^{3}$ | 18.73<br>(8.79 + 9.94^†) |
|  |  |  |  |  |  |

### B.3 Storage Efficiency

Figure: Figure 23: Comparison of file sizes of each representation.
Refer to caption: x24.png

In Figure 23, we compare the file sizes of different representations in order to illusrate the high storage efficiency of our GALA. The representations to be compared in this figure, from the left to the right, are ours (GALA), S2VS Zhang et al. (), M-SDF Yariv et al. (), Neural Wavelet Hui et al. (), raw object mesh files, Mesh Diffusion (DMTet) Liu et al. (), Make-A-Shape (Packed wavelet coefficients) Hui et al. (). Raw object mesh sizes are measured on the converted water-tight meshes on ShapeNet Airplane. Each file of ours occupies only 0.28MB disk space, which is a practical benefit when processing large scale datasets.

## Appendix C Failure Cases

Figure: Figure 24: Examples of typical failure cases. Root voxels are visualized on the right.
Refer to caption: x25.png

At this section, we show examples of typical failure cases. As we can see from Figure 24, typical failure cases root in imperfect root voxel generation, which is the first step of our cascaded generation pipeline. Failed generation of properly connected root voxels would result in unconnected geometries. It will be beneficial to study how to enhance the root voxel generation, for example using more advanced diffusion training schemes. On the other hand, it is worth to note, although some of the root voxels are not properly connected, the final generated geometries are very well aligned, fine and reasonable, implying the power of GALA and our cascaded generation pipeline.

## Peer Reviews

confidence: 5
contribution: 3
initial_rating: 8
presentation: 4
questions: I found that the authors have currently created an anonymous repository, and I am curious whether the authors intend to make the code public in the future.
soundness: 3
strengths: (1) The proposed representation has a low number of parameters, fast fitting time, high precision, and quick mesh extraction time, implemented using pure CUDA and LibTorch.

(2) Initially, I think that the proposed representation is sensitive to the FPS results regarding the number of root tree nodes ($N_o$) and overlap ratios ($\alpha$), so I doubt whether it can effectively cover the thin parts of meshes. However, the authors conduct numerous ablation studies on design choices to achieve optimal performance for general meshes.

(3) The results show that the proposed method achieves SOTA performance on reconstruction and generation with a few number of parameters compared to existing baselines.

(4)  The paper has high writing quality which makes it easy to understand.
summary: The paper presents a storage-efficient new representation of 3D triangle surface meshes, GALA, which can be used for 3D generation trained by a transformer. To create the proposed representation, voxel tree root nodes are initialized over the surface of the mesh using FPS. In the local adaptive grid extraction step, the grid orientation is aligned with the geometric structure using PCA on the local normal vectors, and the grid is rescaled using a histogram. With this representation, the authors show that 3D reconstruction and generation can be performed using cascaded diffusion models. Experiments demonstrate the effectiveness of the proposed method in 3D reconstruction and generation, both quantitatively and qualitatively.
weaknesses: (1) As shown in the Sec. C. Failure Cases, the proposed representation cannot cover the long thin mesh parts.

---

confidence: 2
contribution: 3
initial_rating: 8
presentation: 2
questions: - How is each grid subdivided? As far as I can tell, the only explanation of this subdivision is “we recursively deduce the further levels of tree nodes in an overlapping way where we slightly expand the divided spaces at each level by ratio α.” Which is far from enough detail for a reader to replicate the results. Which cells are subdivided? According to which logic? Along which axis?
- How is a mesh extracted from this adaptive grid? Are the authors setting up some regular grid and interpolating values at grid cells using Eq. (2), and then using Marching Cubes or some other reconstruction algorithm? Or are they somehow extracting a mesh directly from the stored SDF data at the adaptive cells? The latter seems very non-trivial and would be an important contribution on its own.
- What does “the weighting function which is defined by the infinity ball centered at the grid center pig and rotation matrix Oi” mean? Isn’t \omega(x,i) just Eq. (3)?
- It was very hard for me to follow Sec. 3.2., I think partly because of the notation used: Are x_v (lowercase) and X_V (uppercase) the same thing? Am I right in understanding that in this cascading scheme, given an initial tree X_0, the grid configuration X_V and the SDF values at those points will not be affected by the conditioning? Since the class label is only involved in Step 1.
soundness: 4
strengths: I congratulate the authors for their submission. They build on existing work to propose a non-trivial, novel geometric representation that is particularly useful for detailed 3D generative tasks. While I am not an expert in 3D generative modeling, it seems clear that this work outperforms the state of the art in resolutive power, and outperforms its main competitor (Mosaic-SDF) on reconstruction tasks. There is little doubt in my mind that this work would be received positively in the neural geometric processing community.
summary: The authors propose a new geometric representation based on storing optimized SDF values of a shape on an adaptive, overlapping grid of optimally scaled and rotated cells. This representation can be very efficiently generated for any shape and enables diffusion-based generation tasks.
weaknesses: The main weaknesses of this work are in the magnitude of the contribution and the clarity of the writing:

Contribution. It could be argued this work is limited to being an adaptive version of Mosaic-SDF, and that most choices made in the algorithm are the same choices any researcher would made if attempting to extend M-SDF to an adaptive realm (the authors of M-SDF themselves even mention “adding local coordinate frames” as a potential future work avenue). The authors of this work address this and also mention the cascading generation strategy as a difference with M-SDF; however, the magnitude of this contribution is not particularly explored: what would have happened if they used an identical flow-matching strategy to the one in M-SDF?

Clarity of writing. Several key aspects of the work are missing or unclear, to the point in which I don’t believe I understand important sections of the algorithm (see “Questions” below). Additionally, perhaps due to LaTeX template changes, groups of citations that should be grouped in parentheses are not, making reading difficult (e.g., 053, 080). The code link also seems to be missing.

Nonetheless, I do not think these weaknesses justify rejecting this work, which undoubtedly outperforms the state of the art and will definitely save authors’ time if they wish to improve the M-SDF performance in the future.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 4
questions: 1. I noticed that the paper lacks a comparison with the reconstruction results of Mosaic-SDF, only comparing the generation results with it in Table 3. After reading the paper of Mosaic-SDF and I found that they also lack this experiment. However, my understanding is that "Ours w/o A" in Table 2 should be a structure similar to Mosaic-SDF. Are there any other differences?


2. In Figure 7, when comparing the results with Mosaic-SDF, I didn't notice much difference. Can you provide more representative examples in the revised version? Or is this the maximum performance gap compared with Mosaic-SDF?
soundness: 4
strengths: Originality:

1. This work's main contribution is to proposed a novel 3D shape representation which can preserve the local details by using local adaptive grids, while previous methods like Mosaic-SDF using regular grids.
2. The proposed representation is simple and efficient, achieving a good compression ratio with very little storage space and quantization operations.
3. Moreover, the authors also did comprehensive evaluation and application  like 3D shape diffusion to validate the effectiveness of the proposed representation.


Clarity:

1. This pipeline in this submission is technically sound and is largely clearly written and well organized.
2. For the comparison, the numerical results and the visual figures show a significant performance improvement over the baseline method in ShapeNet. But only a few subset with simple geometry (airplane and chair) is evaluated.
3. For the ablation study, the authors show the importance of some designs like determining orientation by bounded normals and rescaling with histogram.
summary: The paper proposed GALA, a novel method for representing 3D shapes using local adaptive grids.  GALA's core concept is to leverage the global sparsity of surfaces within a 3D volume and their local surface properties. The representation enhances the local details by covering only the boundaries of the 3D object with a set of tree root voxels, rather than the empty space, with each voxel containing an octree to limit storage and computation to regions containing surfaces. By adjusting the orientation of the local grid and the anisotropic scales of its axes to the local surface shape, GALA can store a greater amount of detail within a given memory budget compared with Mosaic-SDF and other representations. The advantages of GALA are: (1) it effectively captures and reproduces intricate geometric and surface details, (2) it is computationally efficient, and (3) it is compatible with modern 3D generative modeling techniques, particularly those based on diffusion schemes.

Furthermore, the authors provide a cascaded generation pipeline that is capable of generating 3D shapes with significant geometric detail, demonstrating the practical application and potential of GALA in the field of 3D generation.
weaknesses: 1. While this proposed expression can enhance the details of the reconstruction, I think it is very challenging for diffusion networks to generate the explicit parameters for the root node, grid values, and grid configuration step by step. If some parameter predictions are incorrect, it can greatly affect the quality of the geometry in the subsequent steps. According to the figures in the supplementary, some structures of the generated meshes are noisy. This also limits the practical application of this expression in generative models. It would be better to discuss in the conclusion, or analyze how the errors propagate in the steps and ultimately affect the geometry's quality.

2. I think the authors have omitted some relevant citations regarding XCube and OctTree. XCube employs sparse convolution to achieve high-quality reconstruction and geometric compression, and it has also demonstrated its applicability to generative models. It would be beneficial to include additional quantitative and qualitative experiments and discussions focused on reconstruction quality, compression efficiency, and the applicability to 3D generative models.

3. The authors only tested on some simple geometric details of ShapeNet; it would be better if they could show some more complex results, like objects in Objaverse or Thingiverse.

[1] Ren, Xuanchi, et al., XCube: Large-Scale 3D Generative Modeling using Sparse Voxel Hierarchies, CVPR 2024

[2] Bojun Xiong, et al., OctFusion: Octree-based Diffusion Models for 3D Shape Generation, Arxiv 2024

[3] Objaverse: https://objaverse.allenai.org/

[4] Thingi10K: https://ten-thousand-models.appspot.com/

---

confidence: 4
contribution: 3
initial_rating: 5
presentation: 3
questions: Please see the weakness section.
soundness: 2
strengths: The proposed representation is memory efficient thanks to the quantization. It cleverly exploits a combination of SDF and Octrees. Furthermore, thanks to its structure, it is possible to flatten it out and use generative models to encode it.
summary: This paper describes a 3D shape representation based on trees. The input shape is initially discretized into voxels, and the location of the voxel is decided through Furthest Point Sampling (FPS). Then, each voxel is further discretized into an octree which represents the surface details. Each octree uses a local adaptive grid, with adjusted orientation and scale, to encode the local surface.
To further compress the representation, the octree and voxel information ($X_0, X_\bar{v}, X_v$) is quantized.
Finally, $X_0, X_\bar{v}, X_v$ can be generated by a diffusion model in a coarse to fine manner (first $X_0$ for the voxels, then $X_\bar{v}$).
weaknesses: There are aspects of this method that do not convince me. I hope the authors can clarify them.
1. The main benchmark is Shape-Net, however, this dataset is known to be axis-oriented. It would be more convincing if the authors used additional datasets.
2. How well does this method scale with large shapes (e.g., shapes from the Stanford dataset)?
3. The authors claim to introduce a 3D representation, yet, they rely on a generative model to encode and decode shapes. The soundness of the representation is never evaluated. It seems that the representation is a convenient tool for model generation. If so, I would suggest the authors should reword the text.

Meta-review: In this paper, the authors propose a novel representation of 3D shapes called GALA, which is able to represent complex geometric details with efficient memory cost. The method leverages the global sparsity of surfaces within a 3D volume and their local surface properties, and builds a series of bounding boxes with local anisotropic SDFs. The paper provides both qualitative and quantitative results and compares them with several existing baseline methods. The paper is well-written and clearly presented.

However, the contribution of the paper is incremental, as each individual component is widely used in existing works. In addition, as mentioned by the authors, there are issues in representing certain shapes, such as long and thin structured shapes. Therefore, I recommend acceptance of the paper, but as a spotlight paper.

Decision: Accept (Poster)