1 Introduction↩︎

LiDAR is undergoing rapid development and becoming popular in robots and self-driving vehicles. As the eyes of those machines, LiDAR sensors can generate point clouds that provide accurate 3D geometry in diverse environments. However, the large number of point clouds incur a heavy burden on storage and bandwidth usage. For example, a single Velodyne HDL-64E can generate more than 450 gigabytes of data over 30 billion points in just eight hours of driving. Therefore, developing effective algorithms for 3D point cloud compression is imperative.

Unlike image and video compression, point cloud compression is technically challenging due to the sparseness of orderless point clouds. In the early years, researchers utilize different data structures such as octrees [1] and KD-trees [2] to organize unstructured data and ignore the sparsity of point clouds. However, these methods did not reduce the information redundancy hidden in the data structure representations. Therefore, the potential of reducing the bitrate of a point cloud is still not well explored.

Recent works have shown that learning-based methods have great potential in reducing information redundancy. By encoding point cloud information into an embedded representation, a neural network is used to further reduce the bitrate by predicting a better probability distribution in entropy coding [3], [4]. Their approaches can be summarized into three steps: (1) constructing an octree; (2) fusing different features such as ancestor information [3] or neighbor information [4] to construct a contextual feature map; (3) and training a shared weight entropy model to reduce the length of the bitstream. However, their approaches have three limitations. First, although previous approaches largely focus on the spatial dependencies such as ancestor information [3] or neighbor information [4], they do not utilize prior knowledge of decoded siblings’ children to reduce the information redundancy during the entropy coding. Second, they ignore local geometric information such as quadratic surface. Third, as illustrated in Fig. 3, since the distributions of occupancy symbols at different levels in an octree are very diverse, training a shared weight entropy model can overfit the octants at deeper levels and lead to low prediction accuracy on octants at shallower levels.

To address these issues, we propose a novel octree-based multi-level framework. Our framework encodes the point cloud data into the non-leaf octants as eight-bit occupancy symbols. The entropy model encodes each occupancy symbol into a more compact bitstream through entropy coding by accurately estimating symbol occurrence probabilities. Compared to the previous methods, our entropy model is the first to utilize the siblings’ children as strong priors when inferring the current octant’s symbol probabilities. Our entropy model also incorporates the context of the current octant’s neighbor and ancestor to explore the hierarchical contextual information of the octree fully. We also propose a quadratic surface fitting module to provide geometric priors, which is empirically proven to be beneficial in lowering the bitrate. In our compression framework, we train an independent entropy model for each octree level to capture resolution-specific context flow across different levels. At the decoding stage, we further improve the reconstructed point cloud quality by a two-step heuristic strategy that first predicts leaf octants’ occupancies to retrieve the missing points by a specific level of entropy model and then apply a refinement module on the aggregated point cloud.

The contributions of this work can be summarized as follows.

• We build a novel octree-based multi-level compression framework for the point cloud. Our approach is the first one that incorporates sibling context for point cloud compression.

• We introduce surface priors into our entropy model, which effectively reduces octree-structured data’s overall bitrate.

• In the decoding stage, we propose a two-step heuristic strategy by first predicting the missing points and then refining the aggregated point clouds to achieve a better reconstruction quality.

• Our proposed multi-level compression framework outperforms previous state-of-the-art methods on compression performance and reconstructs high-quality point clouds on two large-scale LiDAR point cloud datasets.

2 Related Work↩︎

2.1 Traditional Point Cloud Compression↩︎

Traditional point cloud methods usually utilize tree-based data structure to organize unstructured point cloud data, especially on KD-tree [2], [5] and Octree [6]–[12]. Meagher et al. [1] directly utilize octree to encode the point cloud without reducing the information redundancy. Huang et al. [8] utilize the neighbourhood information for better entropy encoding. To reduce spatial redundancy, Kammerl et al. [10] use XOR to encode sibling octants. In recent years, MPEG also developed an octree-based standard point cloud compression method G-PCC [7]. Moreover, Google utilizes KD-tree in its open-source point cloud compression software Draco [5]. Since all of the methods are hand-crafted, they cannot be implicitly optimized end-to-end. As such, the reduction of information redundancy is likely to be sub-optimal.

2.2 Learning-based Point Cloud Compression↩︎

Since point cloud data are in \(n\times3\) unstructured floating points, it is almost impossible to directly apply convolutions to raw point cloud data. Thus, researchers proposed several kinds of methods to organize raw point clouds. Point-based methods [13], [14] are usually built based on PointNet framework [15], [16]. Some point based methods [17] directly downsample point cloud to small set of points, then use deconvolution to rebuild the point cloud. However, point-based methods usually suffer from the sparsity of point cloud data and incur high memory costs in processing. Therefore, it cannot handle extremely large LiDAR point cloud data. Range-image-based point cloud compression methods [18]–[24] first transfer point cloud into depth map or range image, then utilize state-of-the-art image compression methods such as  [25] for compression. However, such kinds of methods highly depend on the quality of image compression algorithms, and could not utilize spatial information. Voxel-based methods [3], [4], [26], [27] ignore the sparsity of the point cloud data, and can utilize diverse geometric and spatial information. However, Huang et al. [3] only utilize the ancestor contexts, Que et al. [4] only use the neighbor contexts, and Fu et al. [28] ignore the local geometric information.

Unlike previous methods, our model is the first to reduce the inter-voxel redundancy by utilizing the context of decoded siblings’ children octants. Moreover, local geometric information is also provided as the features for entropy model encoding. We also incorporate both ancestor and neighbor information into our entropy model to enrich the contextual information.

3 Methodology↩︎

3.1 Overview↩︎

Our compression framework is shown in Fig. 1. Given an input point cloud, we first organize it using an octree with occupancy symbols stored at each non-leaf octant. A corresponding deep entropy model takes the hierarchical contexts as input for each octant to predict its occupancy symbol probabilities with 256 classes. The hierarchical contexts consist of local neighbors, ancestors, and siblings’ children. The local neighbor context and sibling context are represented in binary voxel blocks. The ancestor information is an extracted feature map passed from the upper level. Moreover, we also incorporate our entropy model with surface priors by locally fitting quadratic surfaces among the local neighbors. Our entropy model can accurately predict symbol probabilities with these strong priors and further compress the symbols into a more compact bitstream by entropy coding.

In the decoding stage, we first reconstruct an octree with \(L\) levels from the compressed bitstream. We then propose a two-step heuristic strategy to produce a point cloud with better quality. As illustrated in Fig. 4, for each leaf octant, we first reuse our deep entropy model at level \(L+1\) to retrieve its missing points by decoding the top-1 prediction of the occupancy symbol. Finally, we apply a separately trained refinement module [4] to further refine the aggregated points by adding the predicted offsets.

3.2 Octree Construction↩︎

Due to the sparseness of the orderless point cloud data, we have to first organize it in a well-structured representation before subsequent processing. Unlike other popular structures such as voxel-based methods, an octree is more memory efficient as it only partitions the non-empty 3D space and ignores the empty space. Moreover, the tree structure can provide hierarchical spatial information for a better reduction of information redundancy during compression. Therefore, we utilize octree to organize the point clouds.

An octree is built by recursively partitioning the input space into eight non-empty subspaces of the same size until the predefined depth is reached. The octant represents a bounding subspace and uses its center as the point coordinate. Each non-leaf occupied octant consists of an 8-bit occupancy symbol, and each bit represents the existence of a corresponding child (one for existence and zero for the absence). With such representation, a point cloud can be expressed as a serialized 8-bit occupancy symbols stream level-by-level and facilitate further lossless compression by an entropy encoder.

3.3 Hierarchical Context Entropy Model↩︎

Given an occupancy symbol stream \(\boldsymbol{\mathrm{s}}=[s_1,s_2,...,s_n]\) with the number of non-leaf octants as its length \(n\), the goal of our entropy model is to minimize the bitstream length. According to information theory, this goal can be reached by minimizing cross-entropy loss \(\mathop{\mathbb{E}}_{s\sim p}[-\log q(\boldsymbol{\mathrm{s}})]\), where \(q(s)\) is the estimated probability distribution of occupancy symbol \(s\) and \(p\) is the actual distribution.

The accuracy of the probability distribution \(q(s)\) determines the effectiveness of the entropy model. For example, if the actual probability distribution of \(s\) is known, no bit is needed to encode the whole point cloud. However, formulating the actual \(q(s)\) could be very difficult because it has many complex dependencies such as ancestor or neighbor context. A good formulation of \(q(s)\) can provide strong priors for the entropy model and therefore reduce the information redundancy in a bitstream. As illustrated in Fig. 1, our entropy model utilizes hierarchical dependencies from coarse to fine with ancestors, neighbors, and decoded siblings’ children. Moreover, we utilize surface information as geometric priors while estimating \(q(s)\). Therefore, the formulation of \(q(s)\) in our entropy model can be defined as \[q(\boldsymbol{\mathrm{s}})=\prod_i{q(s_i\mid h_{i}^{an}, h_{i}^{neigh}, h_{i}^{sib}, h_{i}^{geo}, c_i;\mathrm{\theta})},\] where \(h_{i}^{an}\) is the ancestral dependence, \(h_{i}^{neigh}\) is the neighbor dependence, \(h_{i}^{sib}\) is the siblings’ children dependence, \(h_{i}^{geo}\) is the surface priors, \(c_i\) is the octant information (located tree level and corresponding coordinates), and \(\theta\) is the parameters of our entropy model.

3.3.1 Neighbor Dependence↩︎

The octree at depth \(l\) (\(l\in[1,L]\)) can be considered as a discretization of the 3D space at the resolution of \(2^{l}\cdot2^{l}\cdot2^{l}\). Inspired by [4], we construct the neighbor context of an octant \(n_i\) by locally forming a \(K\times K\times K\) binary voxel block \(V_i\) centered at \(n_i\) and \(K\) is empirically set to 9 in experiments. Each binary value indicates the existence of its corresponding neighbors. The neighbor voxel \(V_{i}\) is transformed by a feature extraction function \(f_{neigh}\):

\[h^{neigh}_{i}=f_{neigh}(V_i),\] where \(h^{neigh}_i\) is the output feature vector that represents the neighbor contextual information. The feature vector \(h^{neigh}_i\) is provided as part of the prior knowledge for inferring the \(n_i\)’s children distribution.

3.3.2 Ancestral Dependence↩︎

The ancestral information brings coarser geometric information from a shallower level to the current octant [3], which can enlarge the entropy model’s receptive field. As illustrated in Fig. 2, since the entropy model is trained level-by-level, the neighbor context features \(h_{i}^{neigh}\) of current octant \(n_{i}\) can be further passed to its children as ancestral features.

To avoid ancestral features overwhelming the feature space of its children octants, we first concatenate the \(h_{i}^{neigh}\) with the octant information \(c_i\) and then apply an MLP denoted as \(\varphi\) to extract more condensed features \(h^{child}_{i}\). The processed features \(h^{child}_{i}\) will then be passed to its children as their ancestral dependence. A following linear projection layer \(\gamma\) is applied on \(h^{child}_{i}\) to scale back the features to the original dimension. Then the feature is added with \(h_{i}^{neigh}\) through skip connection to recover the original neighbor feature \(\hat{h}^{neigh}_{i}\) of the current octant:

\[h^{child}_{i}=\varphi({\rm{Concat}}(h^{neigh}_{i},c_i)),\hat{h}^{neigh}_{i}=\gamma(h^{child}_{i})+h^{neigh}_i.\]

Note that the ancestral features received from the upper level for the current octant is denoted as \(h^{an}_{i}\). For the root octant, we initialize its ancestral features with zero values.

3.3.3 Sibling Context↩︎

Sibiling octants are adjacent in the original 3D space. The decoded children of siblings are represented in a finer voxel size and are even closer to the encoding/decoding octant. Similar to successive pixels in 2D images and videos, siblings’ children are strongly correlated with the children of the current octant because the geometric structure of these siblings’ children and the current octant’s children can be quite similar. Therefore, conditioning on siblings’ children can reduce the information redundancy while predicting the probability distribution of the current octant.

As illustrated in Fig. 1, an occupied octant \(n_j\) is located at the octree level \(L-1\) and represents a space in the 3D world. Until the level of \(L+1\), this space is partitioned into \(4\times4\times4\) subspaces. We represent it as a binary voxel \(V_i^{sib}\). Since our entropy model encodes the occupancy symbols of \(n_j\)’s children sequentially, the previous siblings’ occupancy symbols are available while predicting the probability of the current octant \(n_i\). The available occupancy symbols are filled in \(V_i^{sib}\). Note that the first occupied child octant of \(n_t\) has no available sibling context, and it will take \(V_i^{sib}\) with zero values as input. We parameterize another feature transformation function, \(f_{sib}\), as a 3D convolution network to exploit the sibling context with \(V_i^{sib}\) as input. We formulate it as \[h^{sib}_{i}=f_{sib}(V^{sib}_i).\] The \(h^{sib}_{i}\) is the output feature vector that represents the sibling contextual information and will be further provided as a part of prior knowledge for entropy coding.

3.3.4 Geometric Priors↩︎

Since LiDAR is a time-of-flight device to estimate the round-trip time of the darting laser beams reflecting from a scene, most of the sampling LiDAR points are densely distributed at large surfaces, such as roads and vehicles. If an octant crosses the boundary of a surface, its children octants are more likely to be occupied. Therefore, geometric information such as the surface can be a strong prior for reducing the data redundancies.

The neighbor context of \(n_i\) is defined as a voxel representation \(V_i\) in Section 3.3.1. We first transform the neighbor context \(V_i\) into a point representation \(\left\{(x_i,y_i,z_i)\right\}^N_{i=1}\) with the coordinate of \(n_i\) as the origin. Then we train a module to locally fit a quadratic surface by minimizing the vertical distance from each point to the surface: \[\mathcal{L}_{sf}=\|\boldsymbol{\mathrm{z}}-\boldsymbol{\mathrm{\delta}}\left[\boldsymbol{\mathrm{x}}^2,\boldsymbol{\mathrm{y}}^2,\boldsymbol{\mathrm{x}}\boldsymbol{\mathrm{y}},\boldsymbol{\mathrm{x}},\boldsymbol{\mathrm{y}},\boldsymbol{\mathrm{1}}\right]^T\|^2_2,\] where \(\boldsymbol{\mathrm{\delta}}\in\mathbb{R}^6\) are six parameters of the quadratic surface. As illustrated in Fig. 2, the module that learns surface priors will take the low level features \(h_{i}^{feat}\) from the second layer of \(f_{neigh}\) as input. The surface estimation module \(f_{geo}\) extract the geometric features from \(h_{i}^{feat}\), followed by a MLP to estimate the parameters \(\boldsymbol{\mathrm{\delta}}\) for the quadratic surface. The transformation can be defined as

\[\begin{align} h_i^{geo}&=&f_{geo}(h^{feat}_{i}),\\ \boldsymbol{\mathrm{\delta}}&=&\boldsymbol{{\rm MLP}}(h_i^{geo}), \end{align}\] where \(h_i^{geo}\) represents the geometric priors provided to the entropy model to infer the probability distribution.

3.3.5 Entropy Model Header↩︎

Eventually, the neighbor feature \(h^{neigh}_i\), the ancestral feature \(h^{an}_i\), siblings’ children feature \(h^{sib}_i\), the geometric feature \(h_i^{geo}\), and the current octant’s information \(c_i\) are aggregated to a four-layer MLP followed by a softmax to predict a 256 channels probability \(q(s_i)\) for the 8-bit occupancy symbol. Then we minimize the cross-entropy loss on each octant: \[\mathcal{L}_{CE}= -\sum_i p(s_i)\log q(s_i),\] where \(p(s_{i})\) is the ground-truth probability distribution of the occupancy symbol \(s_{i}\).

3.4 Multi-level Learning Framework↩︎

From our statistics on 12-level octrees constructed from the KITTI Odometry [29] dataset, the last level of the non-leaf octants accounts for more than 50% of the total number of all the non-leaf octants. We calculate the occupancy symbols distribution by levels and compute the Jensen–Shannon (JS) divergence among them. As shown in Fig. 3, the greater JS divergence means the larger difference between the two distributions.

Based on these two observations, we separately train entropy models for each level instead of training a single shared-weight entropy model on the entire octree. This multi-level learning framework facilitates our entropy model to better reduce each octant’s spatial redundancies in different spatial resolution.

We use the same objective function for the entropy models at different levels: \[\mathcal{L}= \mathcal{L}_{CE}+\lambda\mathcal{L}_{sf},\] where \(\lambda\) is the weight of the loss and empirically set to 0.2 in experiments.

3.5 Two-step Reconstruction Strategy↩︎

The quantization error of our point cloud compression framework comes from the octree construction and depends on the octree level \(L\). Each leaf octant at level \(L\) represents a subspace in the large 3D space. Because of the quantization, we can only recover a single point from each leaf octant by taking the center coordinate of its corresponding subspace. VoxelContext [4] introduces a refinement module to reduce the quantization error by adding predicted offsets to these coordinates in the decoding stage. In contrast, we approach this problem by first retrieving missing points with the help of our trained entropy model at level \(L+1\) and then further refine the aggregated points. By this strategy, we can reconstruct point clouds with the precision near to level \(L+1\) while keeping the bitrate at level \(L\).

As illustrated in Fig. 4, considering a reconstructed octree with \(L\) levels, we denote the set of leaf octants as \(\mathcal{N}_L\). We first apply our entropy model at level \(L+1\) to estimate the occupancy symbol probabilities for each leaf octant in \(\mathcal{N}_L\). We take the predicted occupancy symbols \(\mathcal{S}_{L+1}\) with top-1 accuracy to form a new set of octants \(\mathcal{N}_{L+1}\) located at the predicted level \(L+1\). We denote the represented 3D coordinate of \(\mathcal{N}_{L+1}\) as \(\boldsymbol{\mathrm{x}}^p\in\mathbb{R}^{n\times3}\). In the second step, we apply the refinement module at level \(L+1\)  [4] that takes neighbor context \(V_i\) and octant information \(c_i\) of leaf as an input to predict offsets for the coordinates. Our refinement module is predefined to output offsets for every children octant of \(\mathcal{N}_{L}\), where the offsets are denoted as \(\boldsymbol{\mathrm{x}}^o\). Then we obtain the final output of the coordinate by \[\boldsymbol{\mathrm{x}}^r=\boldsymbol{\mathrm{x}}^p+\boldsymbol{\mathrm{I}}(\mathcal{S}_{L+1}, \boldsymbol{\mathrm{x}}^o),\] where \(\boldsymbol{\mathrm{I}}(a,b)\) denote the operation of indexing \(b\) according to \(a\). To be specifically, \(\boldsymbol{\mathrm{I}}(\mathcal{S}_{L+1}, \boldsymbol{\mathrm{x}}^o)\) means that for those octants whose occupancy codes are zeros, we ignore their offsets. We only add the offsets to the octants where their occupancy code are ones. \(\boldsymbol{\mathrm{x}}^r\in\mathbb{R}^{n\times3}\) is the resulting refined 3D coordinates.

To obtain the ground-truth coordinate of \(N_{L+1}\) during the training of entropy model, We build octrees with \(L+1\) levels and calculate the coordinates \(\boldsymbol{\mathrm{x}}^{gt}\) from \(\mathcal{N}_{L+1}\) as the ground truth. Note that the sibling context at level \(L+1\) is not available during the encoding and decoding time, and we set \(V_i^{sib}\) as zeros voxel block to be the input of our entropy model. We train the refinement module \(\mathcal{R}\) by minimizing the Chamfer Distance [30] of the \(\boldsymbol{\mathrm{x}}^{gt}\) and \(\boldsymbol{\mathrm{x}}^r\):

\[\mathcal{L}_{CD}=\max\left\{\text{CD}(\boldsymbol{\mathrm{x}}^{r},\boldsymbol{\mathrm{x}}^{gt}),\text{CD}(\boldsymbol{\mathrm{x}}^{gt},\boldsymbol{\mathrm{x}}^{r})\right\},\] where \(\mathcal{L}_{CD}\) is the objective function for the refinement module.

4 Experiments↩︎

4.1 Experimental Setup↩︎

Dataset. We evaluate the compression performance and reconstruction quality on two real-world datasets with different densities: KITTI Odometry [29] and nuScenes [31], which are collected by a Velodyne HDL-64 sensor and a Velodyne HDL-32 sensor. We also use the KITTI detection dataset [29] for evaluating the 3D object detection as a downstream task using the reconstructed point cloud.

To ensure the diversity of the training and testing scene, we randomly sample 6000 frames from sequence 00 to 10 in the KITTI Odometry dataset for training and 550 frames from sequence 11 to 21 for testing. For nuScenes, we randomly sample 1200 frames from each of the first five data batches (total 6000) for training, and randomly sampled 100 frames from each of the last five data batches (total 500) for testing. Note that we compare our compression performance and reconstruction quality with the original raw point cloud without any pre-processing in the following sections.

Baselines. To evaluate the performance of our framework, we compare our method with three state-of-the-art baselines: hand-drafted Octree-based point cloud compression method MPEG G-PCC [12], KD-tree based method Google Draco [5], and also a learning-based method VoxelContext [4]. VoxelContext has been faithfully self-implemented as the official code has not been released.

Implementation details. We construct the octree with a maximum level of 13 on both KITTI Odometry and nuScenes datasets. Note that we construct level 13 of the octree only for generating the ground-truth labels for our training. In our experiment section, we evaluate the performance of our framework by truncating octree levels ranging from 9 to 12 on both datasets to vary the compression bitrates. The corresponding spatial quantization error ranges from 14.94 cm to 1.87 cm for KITTI Odometry and 18.29 cm to 2.29 cm for nuScenes.

We implement our framework in PyTorch and experiments on a machine with two NVIDIA 3090 GPUs. The total number of parameters in our deep entropy model is 1.77M. We use Adam optimizer [32] with a learning rate of 1e-4 to train our whole framework. The training epoch for the multi-level entropy model and the refinement module are 20 and 2, respectively. To be memory efficient, we do not backpropagate the gradients of an entropy model from the lower to the upper level during the training of multi-level entropy models. We freeze the weights of the entropy models while training the refinement module.

4.2 Evaluation Metrics↩︎

We evaluate our framework from two aspects, compression performance, and reconstruction quality. Bits per point (BPP) is the most commonly used metric for evaluating the compression performance. Since we only consider the geometric compression of a point cloud in this section, the size of the original point cloud data is calculated by \(96 \times N\), where \(N\) is the number of points in the raw point cloud, and 96 is the size of the coordinates: \(x\), \(y\) and \(z\), where each coordinate is represented in a 32-bit floating-point. BPP is defined as \(BPP=\lvert bit\rvert/N\), where the \(\lvert bit\rvert\) is the bitstream length.

We utilize four metrics to evaluate the reconstruction quality of the point cloud: point-to-point and point-to-plane PSNR  [33], [34], F1 score, and maximum Chamfer Distance [30], [34]. Same as the evaluation metrics defined in  [26], for original input point cloud \(P\) and reconstruction point cloud \(\hat{P}\), we use \(\text{PSNR} = 10\log_{10}\frac{3r^{2}}{\max\{\text{MSE}(P, \hat{P}), \text{MSE}(\hat{P}, P)\}}\), \(\text{F1} = \frac{TP}{TP+FP+FN}\), \(\text{CD}_{max} = \max\{\text{CD}(P, \hat{P}),\) \(\text{CD}(\hat{P}, P)\}\), where the peak constant value of \(r\) is 59.70 m, and the distance threshold of the F1 score is 2 cm.

4.3 Results↩︎

Quantitative results. To quantitatively evaluate our method, we report BPP versus four reconstruction quality metrics. As illustrated in Fig. 5, our method saves more bitrate and achieves higher reconstruction quality compared with all the state-of-the-art methods on both 64 channel KITTI Odometry dataset and 32 channel nuScenes dataset.

Since we use the same octree construction strategy as VoxelContext, we have the same reconstruction quality at the same octree level without applying any refinement module. As illustrated in Table ¿tbl:table:voxel?, our method saves 11%-16% bitrate on the KITTI Odometry dataset and 12%-14% on the nuScenes dataset compared to VoxelContext. Our method reaches higher reconstruction quality than VoxelContext at the same octree level despite using the same refinement module, clearly demonstrating the benefit of our newly proposed two-step refinement strategy.

Qualitative results. We evaluate our method qualitatively by comparing the reconstruction error with state-of-the-art methods on two datasets. As illustrated in Fig. 6, the error between the original point cloud and our reconstructed point cloud is much smaller at a even lower bit rate as compared to all three baseline methods.

Downstream tasks. The performance on downstream tasks of the reconstructed point cloud is also a crucial evaluation metric for point cloud compression. We evaluate the 3D object detection method proposed in [35] on reconstructed point cloud data of different compression methods. We report the bitrate versus average precision (AP) at 0.5 IOU as threshold for pedestrians and 0.7 IOU for cars. As illustrated in Fig. 7, our method outperforms all three baselines on different categories.

Cross-dataset results. To better show our model’s generalization ability, we evaluate the cross-dataset performance on the Apollo-DaoxiangLake dataset with our model trained on the KITTI Odometry dataset. The Apollo-DaoxiangLake dataset captures point clouds in different driving scenes with the same type of LiDAR as the KITTI Odometry dataset. As shown in Fig. 8, the evaluation results show our models still have competitive compression performance over the baselines with better reconstruction quality. In terms of bitrates, our method saves 11.2-13.7% compared to VoxelContext, 56.91-137.35% to Draco, and 68.83-125.08% to G-PCC, respectively.

4.4 Ablation Study↩︎

We perform an ablation study on our deep entropy model to demonstrate the effectiveness of different contextual features. We ablate over the contextual features by training the model without exploiting features from siblings’ children, ancestors, or surfaces. The models for ablation studies are trained on the KITTI Odometry dataset with the same training configurations. We evaluate the models at a level ranging from 8 to 12. From the quantitative results shown in Table ¿tbl:table:Ablation?, we observe that the bitrate increases when not incorporating any dependencies into the entropy model. Moreover, the result also demonstrates that the sibling features are crucial to the compression performance of our entropy model.

5 Conclusion↩︎

We have presented a novel octree-based point cloud compression method. Our method uses the hierarchical contexts of octree structures and surface priors to reduce the information redundancies in the bitstream. On the decoding side, our method utilizes a two-step heuristic strategy for reconstructing point cloud with better quality. We have evaluated our method against three state-of-the-art baselines on two datasets. The result demonstrates that our method outperforms previous methods on compression performance, reconstruction quality, and downstream tasks. We hope our work can inspire researchers to further reduce the compression rate and improve the reconstruction quality in future work.

References↩︎