VoxelContext-Net: An Octree based Framework for Point Cloud Compression

Introduction

Due to the rapid population of 3D sensors such as LiDAR, there is an increasing research interest to compress tremendous amount of 3D point cloud data for a broad range of applications (e.g., autonomous driving). When compared with image and video compression , it is a more challenging task to compress a set of orderless 3D points from point clouds.

Recently, several deep learning methods were developed for point cloud compression. For example, Wang et al. transformed the point cloud data to the voxel representation in order to capture the spatial dependency, and then they employed the existing image compression method for point cloud compression. Other recent works and directly compressed the raw point cloud data by using the existing backbone networks (e.g., PointNet/PointNet++ ) for feature encoding. These voxel-based or point-based methods can take advantage of the existing image compression or point cloud analysis techniques. However, the voxel-based methods ignore the sparsity characteristic of point clouds and thus suffer from the relatively high computational complexity while the point based methods are inefficient when processing large point cloud data . In , Huang et al. used the octree to organize the point cloud data and proposed an entropy model to exploit the dependency between multiple parent nodes and each child node (see Figure 1(a)). Although their approach inherits the benefits for efficiently processing octree structured point cloud data, the strong dependency among the neighboring octree nodes at the same depth level is unfortunately ignored in their octree-based entropy model . Furthermore, the distortions are also introduced after converting the raw point cloud to the octree structured data, which further degrades the compression performance. Besides, their approach is only designed for static point cloud compression, which may limit the performance for dynamic point cloud compression.

To address these issues, we propose a new learning based point cloud compression method VoxelContext-Net by exploiting the voxel context in the octree based framework. Our approach takes advantage of the efficient data organization ability from the octree based methods and the spatial modeling capability from the voxel based methods, which can be applied to both static and dynamic point cloud geometry compression. Specifically, the input point cloud is first organized by using the octree structure, where the symbol of each non-leaf node represents the occupancy status of its eight children. In the entropy coding stage, we propose a new learning based entropy model to compress these symbols in a lossless way. To effectively produce context information for the entropy model, we exploit the local binary voxel representation for each node, where the entries of our voxel representation indicate the existence of neighbouring nodes at the same depth level (see Figure 1(b)). Furthermore, to reduce temporal redundancy for dynamic point cloud compression, we additionally include the co-located voxel representations from the previous and the subsequent point clouds to generate richer context information. In the reconstruction stage, we further propose a coordinate refinement method based on the local voxel representations at the decoder side to produce more accurate 3D coordinate for each leaf node in both static and dynamic point clouds.

We evaluate the performance of our newly proposed method on the large-scale 3D static and dynamic point cloud datasets (e.g., ScanNet and Semantic KITTI ). The comprehensive experiments demonstrate that our method outperforms both hand-crafted point cloud compression methods and the learning-based point cloud compression methods.

The contributions of our work are highlighted as follows:

By taking the advantage of both voxel based methods and octree based schemes, we introduce local voxel context in the deep entropy model for better compression of octree structured data. Our approach can be applied to both static and dynamic point cloud compression.

We develop a voxel context based coordinate refinement module to produce accurate coordinates of leaf nodes at the decoder side.

Our simple and effective approach achieves the state-of-the-art compression performance on several large-scale datasets for both static and dynamic point cloud geometry compression.

Related Work

In the past several years, a few point cloud compression methods have been proposed and most of them are based on the tree representations. For example, the MPEG group developed a standard point cloud compression method G-PCC (geometry based point cloud compression) for static point clouds, which includes an octree-structure based method for point cloud compression. However, they are all based on hand-crafted techniques and thus cannot be optimized in an end-to-end fashion by using large-scale data.

In addition, although some learning based image and video compression approaches have been proposed, it is still a non-trial task to employ the standard CNN operations for compressing point clouds consisting of a sparse set of orderless 3D points.

2 Deep Learning for Point Cloud Compression

Taking the point cloud data as the input, Yan et al. built an auto-encoder network by using PointNet, in which the latent representation is quantized and further compressed by using an entropy coding model. These point based methods may suffer from the huge memory usage issue and high computational costs. Wang et al. extended the existing image compression method for voxelized point cloud compression. Unfortunately, their approach ignores the sparsity characteristic of point clouds and thus the computational complexity is relatively high when compared with the octree based methods.

Recently, an octree-based method OctSqueeze was proposed. While the OctSqueeze method avoids the issues related to high memory usage and slow encoding/decoding speed, their approach still suffer from the following drawbacks. First, they only exploited context information from its ancestor nodes (as shown in Figure 1(a)) to predict the probability model in the entropy model, which ignores strong prior information between spatial neighbouring nodes at the same depth level. In addition, their work does not consider the distortion introduced in the octree construction procedure, and their method is only designed for static point cloud compression. Although there is a concurrent work for dynamic point cloud compression, it follows the existing framework from and thus suffers from similar limitations.

In contrast to these works , we propose to exploit context information between neighbouring nodes by using local voxel representation in our deep entropy model and our work also refines the 3D coordinate at the decoder side in order to achieve better reconstruction results. Besides, we further extend our approach by additionally exploit the local context representation from neighbour frames for dynamic point cloud compression.

Methodology

The overall architecture of the proposed point cloud compression method is shown in Fig 2. In this section, we first take the static point cloud compression as an example to illustrate our proposed method and then introduce how to extend the proposed method for dynamic point cloud compression.

Specifically, in the first stage, we organize the input static point cloud by using the octree structure, in which our approach aims to encode these symbols of non-leaf nodes in a lossless way. To improve the compression performance, we propose a voxel context based deep entropy model to accurately predict the probability distributions of these symbols. Furthermore, to compensate the distortion in the octree construction procedure, a local voxel context based coordinate refinement module is proposed to produce more accurate reconstructed point cloud at the decoder side.

2 Octree Construction

In Figure 3, we provide a toy example to illustrate the octree construction procedure. Specifically, an octree can be constructed from any 3D point cloud by first partitioning the 3D space into 8 cubes with the same size, and then recursively partitioning each non-empty cube in the same way until the maximum depth level is reached. The 3D coordinate of each node represents the cube center. For each non-leaf node, a 8-bit symbol is used to represent the occupancy status of its eight children, with each bit corresponding to one specific child.

In the octree construction procedure, the quality of the reconstructed point cloud depends on the maximum depth level in the octree structure. Therefore, the coordinate of the current leaf node (i.e., the cube center) is not always consistent with the original 3D coordinate of the corresponding point in the raw point cloud. For example, the coordinate of one input point $r_{i}$ is $(0.6,0.7,0.7)$, while the coordinate for the corresponding leaf node $n_{i}$ is quantized to $(0.625,0.625,0.625)$, thus inevitable distortion is introduced in the octree construction procedure. In this work, we will compress the symbols of octree nodes losslessly and recover the accurate decoded coordinates at the decoder side.

3 Local Voxel Context in Octree

In the octree structure, the parent node will generate 8 children nodes, which is equivalent to bisecting the 3D space along x-axis, y-axis and z-axis. Thus, the partition of the original space at the $k$th depth level in the octree is equivalent to dividing the corresponding 3D space $2^{k}$ times along x-axis, y-axis and z-axis, respectively. Then we produce a binary voxel representation with the shape of $2^{k}*2^{k}*2^{k}$ based on the existence of points in each cube. Here we assume the corresponding local voxel representations centered at the node $n_{i}$ is $\boldsymbol{V_{i}}\in\mathcal{R}^{M\times M\times M}$, where $M$ represents the size of the local voxel representation. $\boldsymbol{V_{i}}$ will be used in our approach as strong prior information to improve the compression performance.

In Figure 3(c), the purple region represents the local voxel context for the current node $n_{i}$ and the detailed binary values for the local voxel representation are depicted in Figure 3(d). In Figure 3(a), we also provide the 3D coordinate range of the corresponding local region in the 3D space(see the purple dash line). It is noted that the local voxel context $\boldsymbol{V_{i}}$ of the current node $n_{i}$ represents the distribution information of neighbouring nodes at the same depth level. In contrast, the previous method only exploit the information from its ancestor nodes without considering strong spatial neighbouring prior information(see Figure 1(a)).

4 Our Deep Entropy Model

Let $\boldsymbol{s}=[\boldsymbol{s_{1}},...,\boldsymbol{s_{i}},...]$ denote a sequence of 8-bit occupancy symbols from all non-leaf octree nodes where $\boldsymbol{s_{i}}$ represents the symbol for node $n_{i}$ in the octree. For example, when $\boldsymbol{s_{i}}=$, it means node $n_{i}$ has two children and the corresponding indexes of the two children are 4 and 8, respectively.

According to the information theory , when compressing the occupancy information, the lower bound of bitrates is the Shannon entropy. However, the actual distribution $P$ is unknown in the practical applications. Therefore, we use the deep neural network to estimate the probability distribution which can be employed to approximate the actual distribution $P$. Based on the learned deep entropy model, we can compress these occupancy symbols from the octree in a lossless manner. Specifically, the objective of our learning based entropy model is to minimize the cross-entropy loss $E_{\boldsymbol{s}\sim P}[-{\rm log}Q_{s}(\boldsymbol{s})]$, where $Q_{s}(\boldsymbol{s})$ is the estimated probability of $\boldsymbol{s}$.

It is noted that the children’s probability distribution $q_{s}(\boldsymbol{s_{i}})$ at the current node $n_{i}$ may rely on the previously decoded nodes as well as the neighbouring nodes at the current depth level, so it is very difficult to model this complex relationship. In this work, we assume the occupancy symbol $\boldsymbol{s_{i}}$ for the current node $n_{i}$ only depends on the node’s local voxel context $\boldsymbol{V_{i}}$ and the node feature $\boldsymbol{c_{i}}$ that includes the node’s 3D coordinate and the depth level of the node. Since $\boldsymbol{V_{i}}$ represents local context information at the same depth level, it is reasonable to infer the node $n_{i}$’s children distribution (i.e., $\boldsymbol{s_{i}}$) based on $\boldsymbol{V_{i}}$. Then we can simplify the complex dependence relationship for each original occupancy symbol $\boldsymbol{s}$ and further factorize $Q_{s}(\boldsymbol{s})$ into the following way,

where $q_{s}(\boldsymbol{s_{i}}|\boldsymbol{V_{i}},\boldsymbol{c_{i}})$ is the predicted probability of $\boldsymbol{s_{i}}$ when the local voxel context $\boldsymbol{V_{i}}$ and the node feature $\boldsymbol{c_{i}}$ are given at node $n_{i}$. Here, we use the same probability distribution model for each node.

4.2 Network Architecture

In this work, we use deep neural networks to parameterize the entropy model in Eq. (1). The whole network architecture is shown in Figure 4. Specifically, for the current node $n_{i}$, we first extract its local voxel context $\boldsymbol{V_{i}}$ based on the method described in Section 3.3. Then $\boldsymbol{V_{i}}$ is fed to a multi-layer convolutional neural networks (CNN) and the corresponding output is $\boldsymbol{f_{i}}$. In this procedure, we adopt the popular and off-shelf CNN structure to effectively exploit context information in the 3D space, which has not been exploited by the existing octree based point cloud compression methods. Then we concatenate the context feature $\boldsymbol{f_{i}}$ and the node feature $\boldsymbol{c_{i}}$. After that, a multi-layers perception (MLPs) is adopted to generate a 256-dimensional hidden feature, which fuses both local voxel contextual information and node information. Finally, a softmax layer is used to produce the probabilities $q_{s}(\boldsymbol{s_{i}}|\boldsymbol{V_{i}},\boldsymbol{c_{i}})$ of the 8-bit occupancy symbol for each given node $n_{i}$. Our approach takes advantage of both octree based methods and voxel based methods and achieves better point cloud compression performance.

5 Our Coordinate Refinement Method

To reduce the distortion in the octree construction procedure, we propose a local voxel context based coordinate refinement method to produce more accurate reconstructed point cloud at the decoder side. A key intuition behind our coordinate refinement method is that we can better predict the coordinate of the current node by exploiting local context information of its neighbouring voxels.

Given the decoded octree, for each leaf node $n_{i}$, the goal of our coordinate refinement method is to predict the refined output coordinate $(x_{i}^{r},y_{i}^{r},z_{i}^{r})$ in the following way,

where $\boldsymbol{V_{i}}$ is the local voxel context for the leaf node $n_{i}$ and $R(\cdot)$ is a learnable function for coordinate refinement. The decoded coordinate $(x_{i}^{d},y_{i}^{d},z_{i}^{d})$ represents the coordinate of node $n_{i}$ after octree decoding.

As shown in Figure 4(b), the network architecture of the proposed coordinate refinement method is similar to the deep entropy model. Specifically, for a decoded octree, we firstly transform the whole octree into a global binary voxel representation, from which we can readily produce the local voxel context for each leaf node. Given the binary voxel context $\boldsymbol{V_{i}}$ for node $n_{i}$, we firstly extract context information in the 3D space by using multi-layer CNNs, and then predict the offset by using a set of fully connected layers. We then calculate the decoded coordinate of the leaf node $n_{i}$ and the final reconstructed coordinate of $n_{i}$ is the sum of its decoded coordinate and the predicted offset (see Eq. (2)).

6 Training Strategy

In the proposed method, we separately train our local voxel context based deep entropy model and our coordinate refinement module. For the deep entropy model, based on the predicted distribution $q_{s}(\boldsymbol{s_{i}}|\boldsymbol{V_{i}},\boldsymbol{c_{i}})$ at each non-leaf node, we use the following loss function:

where $q_{s}(\boldsymbol{s_{i}}|\boldsymbol{V_{i}},\boldsymbol{c_{i}})$ is defined after Eq. (1).

For the coordinate refinement module, we aim to generate the precise coordinate of each point. Towards this goal, a MSE based loss is used as the distortion in the training procedure:

where $(x^{g}_{i},y^{g}_{i},z^{g}_{i})$ is the ground-truth coordinate of node $n_{i}$ before octree construction.

7 Dynamic Point Cloud Compression

The proposed point cloud compression framework is very general and can be readily extended for dynamic point cloud compression. Considering that each dynamic point cloud consists of a sequence of redundant point clouds that are captured at different time, it is necessary to exploit temporal information.

Specifically, given the point cloud $\mathcal{P}_{t}$ at time step $t$ and its neighbouring point clouds $\mathcal{P}_{t-1}$ and $\mathcal{P}_{t+1}$ at time step $t-1$ and $t+1$, we first align these point clouds to the same coordinate system based on their pose information of the sensor. It should be mentioned that we decode all point clouds from a sequence in a depth by depth fashion. Thus, when we decode the node $n_{i}$ at the $k$th depth level for the current point cloud $\mathcal{P}_{t}$, the voxel representation at the $k$th depth level from other two point clouds $\mathcal{P}_{t-1}$ and $\mathcal{P}_{t+1}$ is available. Meanwhile, the voxel representation at the $(k+1)$th depth level from the point cloud $\mathcal{P}_{t-1}$ is also available.

Here, as shown in Fig. 5, we assume the local voxel representation for node $n_{i}$ at the $k$th depth level in $\mathcal{P}_{t}$ is $\boldsymbol{V_{k,i}}$ and the corresponding co-located local voxel representations at the $k$th depth level in $\mathcal{P}_{t-1}$ and $\mathcal{P}_{t+1}$ are $\boldsymbol{V^{-}_{k,i}}$ and $\boldsymbol{V^{+}_{k,i}}$, respectively. Furthermore, the voxel representation at the $(k+1)$th depth level in the previous point cloud is denoted as $\boldsymbol{V^{-}_{k+1,i}}$. To exploit temporal information in the entropy model, we adopt a simple fusion strategy and use the similar network architecture as shown in Figure 4 to extract the features from each local voxel representation. Then we concatenate the features extracted from four different voxel representations (i.e., $\boldsymbol{V_{k,i}}$, $\boldsymbol{V^{-}_{k,i}}$, $\boldsymbol{V^{+}_{k,i}}$ and $\boldsymbol{V^{-}_{k+1,i}}$) and feed the aggregated feature to the Softmax layer to produce the final probability distribution. In our implementation, we set the size of $\boldsymbol{V_{k,i}}$, $\boldsymbol{V^{-}_{k,i}}$ and $\boldsymbol{V^{+}_{k,i}}$ as $9\times 9\times 9$, and set the size of $\boldsymbol{V^{-}_{k+1,i}}$ as $10\times 10\times 10$. Finally, the coordinates from the reconstructed octree are refined by using the voxel context based method discussed in Section 3.5. It is noted that we only use the voxel representation $\boldsymbol{V_{k,i}}$ as context information for coordinate refinement as it is sufficient to use this voxel representation to achieve promising results.

Experiments

ScanNet: ScanNet is a large-scale dataset with a few dense point cloud sequences from the indoor scenario. It consists of 1,513 scans. In our experiment, 50,000 points are sampled from each scan.

Semantic KITTI: Semantic KITTI is another large-scale dataset with several dense point cloud sequences captured from the self-driving scenario, which contains 23,311 scans with about 5 billion points. In our experiment, it is used for both static and dynamic point cloud compression.

For the ScanNet dataset, we use the official training/testing split, which includes 1,201 point clouds for training and 312 point clouds for testing. For evaluating the static point cloud compression methods on the Semantic KITTI dataset, we follow the default setting, where 11 point cloud sequences are used for training and the other 11 sequences are used for testing. For dynamic point cloud compression, considering that the ground-truth pose information is not available in the official testing sequences, in this work, we only use 11 training sequences for training and performance evaluation, in which 8 sequences are used for training while 3 sequences are used for performance evaluation.

2 Experimental Details

Baseline Methods. In our experiments, the two most representative hand-crafted point cloud compression methods, MPEG’s standard point cloud compression method(‘G-PCC’) and Google’s KD-tree based method(‘Draco’) are used as the baseline algorithms. In addition, we also compare our method with the recent learning based static point cloud compression method OctSqueeze . Since the source code of OctSqueeze is not publicly available, we re-implemented it by ourselves.

Training and Testing Strategy. In our training procedure for static point cloud compression, the maximum depth levels on ScanNet and SemanticKITTI are empirically set as 9 and 12, respectively. And the entropy model is optimized by using all nodes from the complete 9-level/12-level octree. In the testing stage, we truncate the octree at different levels to evaluate our deep entropy models at different bitrates. It is noted that we train a coordinate refinement model at each depth level to reduce the distortion in the octree construction procedure. For dynamic point cloud compression, we adopt the same training procedure.

We perform the experiments on the machine with one NVIDIA 2080TI GPU. Our whole network is implemented based on PyTorch and it takes 3 days and 5 days to train the model, for the static and dynamic point cloud compression tasks, respectively. In the training procedure, we use the Adam optimizer and the learning rate is set as $1e-4$ for both entropy model and the coordinate refinement model.

Evaluation Metrics In our experiments, we use the Chamfer distance(CD) , point-to-point PSNR and point-to-plane PSNR , where $p$ is set as 1 to measure the quality of the reconstructed point cloud. We simply use bits per point(Bpp) as the compression ratio metric. To compare different compression algorithms, we also include the BDBR in our approach, which represents the average bitrate saving when the reconstructed quality (e.g., PSNR) of these methods are the same.

3 Experiment Results

Results for Static Point Cloud Compression. The quantitative experimental results are provided in Table 1 and we use BDBR to evaluate the compression performance of different codecs, where G-PCC is used as the anchor algorithm. It is observed that our approach (i.e., VoxelContext-Net) saves 43.66% bitrate on the ScanNet dataset when compared with G-PCC, while the corresponding bitrate saving for OctSqueeze is only 15.00%. Similar results are also observed on the Semantic KITTI dataset, where our approach achieves 31.15% bitrate saving, while OctSqueeze only saves 2.13% bitrates. These experimental results clearly demonstrate our approach outperforms the state-of-the-art learning based compression algorithm and the traditional codecs like G-PCC.

For static point cloud compression, the corresponding rate-distortion curves are provided in Figure 6. Our approach achieves better compression performance, especially at high bitrates. For example, our approach has more than 2dB improvement over OctSqueeze on the ScanNet dataset when the bpp is 4.

In Figure 8, we take the Semantic Kitti dataset as an example to provide the qualitative results. We observe that the errors between the ground-truth point clouds and our reconstructed point clouds are also smaller when compared with the baseline methods OctSqueeze and G-PCC. For example, the bpp of our approach is 0.36 and the corresponding PSNR is 55.51dB, while OctSqueeze achieves a lower PSNR(54.35dB) when using more bits(0.52bpp).

Results for Dynamic Point Cloud Compression. For dynamic point cloud compression, we provide the quantitative results in Table 2 and Figure 7. It is observed that our dynamic point cloud compression method (i.e., Ours(dynamic)) outperforms the baseline methods G-PCC and OctSqueeze by a large margin. For example, Ours(dynamic) saves 38.10% bitrates when compared with the anchor algorithm G-PCC while the corresponding saving is only 5.01% for the OctSqueeze method. Furthermore, when compared with Ours(static), Ours(dynamic) saves additional 11.11% bitrates (-26.99% vs. -38.10%) on Semantic KITTI. Considering that the only difference between Ours(static) and Ours(dynamic) is the additional temporal voxel context in the entropy model (see Section 3.7 and Figure 5), the results demonstrate it is effective to exploit the temporal information for dynamic point cloud compression.

Since our approach requires the pose information of the sensor when performing point cloud alignment, we also provide the results on the KITTI dataset when our approach uses the estimated pose information , instead of the ground truth pose information. The experimental result in Table 2 demonstrates that our approach with the estimated pose information (i.e., Ours*(dynamic)), also saves 41.77% bitrate and still outperforms the existing baseline methods. It is noted that Ours*(dynamic) performs even better than Ours(dynamic). One possible explanation is that the ground-truth pose represents motion information of the sensors while the estimated pose information is calculated based on the motion between actual point clouds, which may be more useful for the compression task.

4 Ablation Study and Analysis

In this section, we take our VoxelContext-Net for static point cloud compression on the ScanNet dataset as an example to perform the ablation study.

Effectiveness of Our Proposed Components. To demonstrate the effectiveness of our proposed two components, we consider a simplified version of our approach by removing the coordinate refinement module, which is referred to as VoxelContext-Net (w/o CRM).

Based on the experimental results (see the purple curve) in Figure 9, we have the following two observations. First, when compared with the octree based entropy model in OctSqueeze , our approach using the local voxel context boosts the performance and saves an additional 14.81% bitrate in terms of BDBR. It shows it is more effective to use context information provided by the local voxel representation rather than that extracted from the parent and child nodes . Second, when comparing our full model (see the black curve) and the simplified model (see the purple curve), it is observed that the coordinate refinement procedure further improves the performance and saves 21.50% bitrates in terms of BDBR. Therefore, it is beneficial to reduce the distortion from the octree construction procedure by using our proposed coordinate refinement module.

Voxel Size. In our implementation, the size of local voxel representation for each node is empirically set as $9\times 9\times 9$. As shown in Table 3, we provide more experimental results when the size varies. It is noted that the performance can be boosted by increasing the resolution of the local voxel representations. For example, when compared with our entropy model with the voxel size as $5\times 5\times 5$, our proposed approach saves 2.5% bitrates when the voxel size becomes $9\times 9\times 9$ at the depth level 9. Considering that the computational complexity will also increase by using larger voxel sizes, we choose $9\times 9\times 9$ as the default size in our approach for better trade-off between compression performance and computational complexity.

Computational Complexity In Table 4, we provide the decoding time of different methods at various bitrates on two datasets. Our method is faster than G-PCC . While it is slower than OctSqueeze , we achieve better compression performance (see Fig. 6 and Table 1). The total number of parameters in our approach is 2.15M.

Experimental Results for the Downstream Tasks We evaluate the impact of different point cloud compression methods for two downstream tasks (i.e., object detection and semantic segmentation). Specifically, we use VoteNet as the object detection method and PointNet++ as the semantic segmentation method. We train these models based on the uncompressed point clouds from the official training dataset of ScanNet. In the evaluation stage, the reconstructed point clouds at different bitrates are fed into the detection or the segmentation method. For the object detection task, we employ mAP@0.25 to measure the detection accuracy. Following the setting in , for the semantic segmentation task, we adopt the intersection-over-union (IOU) score for performance evaluation, which is computed based on the ground truth labels for each voxel.

The experimental results are shown in Fig 10. Specifically, we provide the compression ratios (i.e., bpps) and the corresponding detection/segmentation accuracy (i.e., mAP/IOU) when using the decoded point clouds from our VoxelContext-Net and the baseline method OctSqueeze as the input to the detection/segmentation method. At any given bpp, it is obvious that the detection/segmentation results based on the decoded point clouds from our VoxelContext-Net are higher, especially at low-bitrates. It demonstrates that the reconstructed point clouds from our VoxelContext-Net are more useful for the downstream tasks, like object detection or semantic segmentation.

Conclusion

In this work, we have proposed a new learning based point cloud geometry compression framework by exploiting the local voxel representation for each node in the octree structured point cloud. Specifically, we propose a new deep entropy model to losslessly compress the symbols of octree nodes and a new coordinate refinement module for reconstructing high-quality point clouds at the decoder side. Our simple and effective approach is applied to both static and dynamic point cloud compression and our method has achieved the state-of-the-art compression performance on two benchmark datasets.

Acknowledgement This work was supported by the National Key Research and Development Project of China (No. 2018AAA0101900).

References