Method, encoder, decoder, bitstream, and program for encoding and decoding 3D point clouds

Abstract

A method, encoder, and decoder for encoding and decoding a 3D point cloud into a bitstream, in which the geometry of the point cloud is defined by an octree structure having a plurality of nodes, the plurality of nodes having a parent-child relationship and representing three-dimensional positions of objects, the point cloud being located in a volume space of a three-dimensional coordinate system, the volume space being recursively divided into subvolumes and containing points of the point cloud, the volume being divided into a set of subvolumes, each subvolume being associated with one node of the octree structure, and occupancy information associated with each child subvolume of each subvolume indicating whether the respective child subvolume contains at least one of the points, the method comprising the steps of obtaining a node that contains at least a portion of the point cloud at a depth d in lexicographic order along each of axes X, Y, and Z of the coordinate system, and entropy encoding or entropy decoding the occupancy information of each node's child nodes into or from the bitstream based on the lexicographic order.

Description

[Technical Field]

[0001] The present invention relates to a method for encoding a 3D point cloud into a bitstream. It is a further object of the present invention to provide a method for decoding a 3D point cloud from a bitstream. It is also an object of the present invention to provide an encoder and decoder, a bitstream encoded according to the present invention, and software. In particular, it is an object of the present invention to provide a method that improves encoding efficiency and reduces processing latency. [Background technology]

[0002] Point clouds as a format for representing 3D data have recently gained attention due to their versatility in their ability to represent all types of 3D objects and scenes. Therefore, many use cases can be addressed by point clouds, among which are: Film post-production, Real-time 3D immersive telepresence or VR / AR applications, Free viewpoint video (e.g. for sports viewing), Geographic Information Systems (aka cartography), Cultural heritage (scans of rare objects stored in digital format), Autonomous driving involves 3D mapping of the environment and collecting real-time lidar data.

[0003] A point cloud is a set of points located in 3D space, each of which can have additional values attached to it. These additional values are commonly called point attributes. A point cloud is thus a combination of geometry (the 3D location of each point) and attributes.

[0004] These attributes may be, for example, three-component color, material properties such as reflectance, and / or two-component normal vectors of the surface associated with the point.

[0005] Point clouds can be captured by various types of devices such as camera arrays, depth sensors, lidar, scanners, or can be computer-generated (e.g., in film post-production). Depending on the use case, point clouds can have thousands to billions of points for mapping applications.

[0006] In the original representation of a point cloud, each point requires a very large number of bits, at least a dozen bits per spatial component X, Y, or Z, and optionally attributes require many more bits, e.g., color requires three times 10 bits. Practical deployment of point cloud-based applications requires compression techniques that allow the storage and distribution of point clouds over reasonable storage and transmission infrastructures.

[0007] Compression may be lossy (as in the case of video compression) for delivery to and visualization by the end user, e.g., on AR / VR glasses or other 3D-enabled devices. Other use cases, such as medical applications or autonomous driving, require lossless compression to avoid affecting the decisions made by analyzing the compressed and transmitted point cloud.

[0008] Until recently, point cloud compression (also known as PCC) was not available in the mass market and no standardized point cloud codecs were available. In 2017, the standardization working group ISO / JCT1 / SC29 / WG11, also known as the Moving Picture Experts Group or MPEG, started a work item on point cloud compression. This involved two standards: MPEG-I Part 5 (ISO / IEC 23090-5) or Video-Based Point Cloud Compression (V-PCC), and MPEG-I Part 9 (ISO / IEC23090-9) or Geometry-based Point Cloud Compression (G-PCC).

[0009] Both the V-PCC and G-PCC standards will soon be available on the market, with their first versions being completed in the second half of 2020.

[0010] The V-PCC coding method compresses point clouds by performing multiple projections of a 3D object to obtain 2D patches that are packed into an image (or video when dealing with moving point clouds). The obtained images or videos are then compressed using existing image / video codecs, allowing the utilization of already deployed image and video solutions. By its nature, V-PCC is only effective for dense and continuous point clouds, as image / video codecs are unable to compress non-smooth patches resulting from projections of sparse geometric data obtained, for example, by lidar.

[0011] The G-PCC coding method has two methods for compressing geometry.

[0012] The first method is based on an octree (octree / quadtree / binary tree) representation of the point cloud geometry. Occupied nodes are branched until a certain size is reached, and occupied leaf nodes provide the point locations, usually the centers of these nodes. High levels of compression can be obtained for dense point clouds by using a neighbor-based prediction technique. Sparse point clouds are also solved by directly encoding the positions of points in nodes with non-minimal size, stopping the tree construction if only isolated points exist in the node; this technique is known as direct coding mode (DCM).

[0013] The second method is based on prediction trees, where each node represents the 3D location of one point and the relationship between nodes is a spatial prediction from parent to child. This method can only resolve sparse point clouds and offers the advantages of lower latency and easier decoding than occupancy trees. However, compared to the first occupancy-based method, it only offers slightly better compression performance, is more complex to encode, and requires an intensive search for the best predictor (among a long list of potential predictors) when constructing the prediction tree.

[0014] In both schemes, attribute encoding (decoding) is performed after geometry encoding (decoding) is completed, resulting in two-pass encoding. Low latency is therefore achieved by using slices that decompose the 3D space into subvolumes that are coded independently, without prediction between the subvolumes. This can have a significant impact on compression performance when many slices are used.

[0015] An important use case is the transmission of dynamic AR / VR point clouds. Dynamic means that the point cloud evolves over time. Furthermore, AR / VR point clouds are typically locally 2D, since they represent the surface of an object most of the time. AR / VR point clouds are therefore highly correlated (or said to be dense), in the sense that points are rarely isolated but instead have many neighbors.

[0016] In GPCC, even though the neighborhood is reduced to the nearest neighboring nodes, the number of possible configurations is still too large to be directly used in selecting the context used to entropy code the occupancy information of the current node.

[0017] Several techniques are provided to further reduce the neighborhood configurations to a feasible number of reduced configurations.

[0018] First, some "physical" arguments are introduced, such as masking of an occupied neighbor node by another occupied neighbor node placed between the previous node and the current node, where the information of the former is considered weaker than the information of the latter and is therefore discarded.

[0019] Second, a learning-based reduction by look-up table (LUT) is provided. Reduced configuration = LUT[configuration] Here, the range of the LUT's output is smaller than the number of entries. The construction of the LUT depends heavily on the type of point cloud being trained. The LUT is used during the encoding of the occupancy of a child node. The LUT is a lookup table of coder indexes based on the occupancy information configuration of the currently encoded child node. The LUT maps the occupancy information configuration to select a coder index, and then encodes the current child node using the selected binary coder.

[0020] Third, a more flexible technique called optimal binary coder with immediate update (OBUF) is introduced. Use a limited number of adaptive entropy coders (e.g., 32), Associating a coder index (e.g., 0 to 31) with each neighborhood configuration; By updating the coder index associated with the current node's neighborhood configuration after each coding of the current node's occupancy. Reduced the number of contexts for entropy coders (such as CABAC).

[0021] The OBUF is combined with the first two reduction techniques applied before the OBUF to limit the number of coder indices depending on the reduction configuration.

[0022] It is also provided to enable a practical implementation of entropy coding the occupancy bits of the current geometry element by using the already coded occupancy information of neighboring nodes in the following way: · Reduce neighborhood occupancy configurations using low-memory reduction functions that are easy to compute. Using a reduced configuration as input to a LUT pointing to a small set of entropy coders, and updating this LUT after coding of occupied bits. This is the so-called OBUF process in the prior art. Entropy coding the occupied bits using an entropy coder pointed to by the entry of the LUT indicated by the reduced configuration.

[0023] This process is very efficient once a sufficiently large number of occupied bits are coded so that the LUT converges and is updated enough times to consistently point to an entropy coder with coding probabilities that correlate well with the reduced configuration.

[0024] However, when the point cloud is small or at the beginning of the encoding process for large point clouds, the OBUF LUT has not yet converged and is unable to select a suitable entropy coder, which results in poor compression for small point clouds and poor compression for large point clouds.

[0025] In a 3D octree representation of the point cloud geometry, the number of possible occupancy configurations of a neighborhood is 2N, where N is the number of nodes / voxels contained in the neighborhood. This number can become very large even when there are only a small number of N neighbors.

[0026] Therefore, an additional step of reduction is provided after the (optional) fixed reduction function: this new reduction is called "dynamic reduction" that is updated as the encoding of the point cloud progresses.

[0027] A typical example of the order of magnitude of the size of the relevant context information when dealing with neighborhoods in an octree representing the geometry of a point cloud is as follows:

[0028] There are 26 neighboring nodes that share a face, edge, or vertex with the parent of the current node for which the occupancy bits should be coded. When using a breadth-first traversal of the octree, the occupancy bits of all these 26 neighboring nodes are already coded and can be used as context information.

[0029] Depending on the scan order (Morton order of raster scan order), in most cases at least 7 of the 26 neighboring nodes will already have the occupied bits of their children coded. This gives us an additional 8 x 7 = 56 occupied bits that can be used as context information.

[0030] Finally, some of the sibling nodes of the current node may already be coded; there are up to 7 of them. Therefore, overall, by only considering the closest neighbors in contact with the current node, up to 26 + 56 + 7 = 89 already coded occupied bits can be used as context information. This leaves us with the following possible neighborhood configurations to be used as context information:

number

[0031] Not all of these configurations are visited when encoding the point cloud. However, they must be retained to cover a wide variety of point clouds. For example, encoding a dense point cloud for AR / VR will result in visits to some reduced context configurations, while encoding a sparse point cloud for lidar will result in visits to other reduced context configurations. This is the main goal of dynamic reduction: further reducing rarely or never visited configurations and giving full potential (i.e., no reduction or weak reduction) to frequently visited configurations. The dynamic nature comes from determining frequently visited configurations on the fly during encoding and updating the dynamic reduction function based on this determination.

[0032] So basically, the dynamic reduction function DR is the initial function DR with the maximum reduction of all configurations. 0 It is initialized with DR 1 , D.R. 2 , …, DR. n and so on. Each update depends on the configurations visited during encoding and is determined by relaxing the reduction for frequently visited configurations. This results in a tower of function DR with an image size increase equal to the number of dynamically reduced configurations of possible outputs. #ImDR 0 ≦#Im DR 1 ≦…≦#Im DR n ≦#Im DR n+1 <…

[0033] Furthermore, it is provided to construct a dynamic reduction function DR that operates by preserving specific bits of the context information CI. Assume that the context information CI is a word consisting of a sequence of K bits. CI = β1…βK

[0034] Then, the dynamic reduction function DR n The dynamically reduced context information CI' is CI'=β1…βk n (CI) so that the first k n This can be easily defined by preserving the (CI) bit.

[0035] Also, function DR n is the array k n (CI). The value of k0 can be initialized to zero. k n (CI)=0

[0036] Also, DR n From DR n+1 The update to array k n (CI) into a new array k n+1 (CI), which is done by increasing the number of bits that are kept. k n(CI)≦k n+1 (CI)

[0037] A set of dynamic reduction functions DR n The iterative construction of (over n) is provided based on the construction of binary trees. n = 0 corresponds to a tree with only a root node.

[0038] Example function DR n is shown in Figure 6. It is defined by a binary tree. The selection of each branch of the tree from the node at depth d depends on the value of the d-th bit βd (0 or 1) of the context information CI. The leaf nodes correspond to dynamically reduced configurations.

[0039] As can be seen in the example tree of Figure 6, there are three dynamically reduced configurations corresponding to context information CI' with binary formats 0xxxxxx, 10xxxxx, and 11xxxxx. These three configurations are accompanied by three numbers N(0xxxxxx), N(10xxxxx), and N(11xxxxx) that track the number of visits to each reduced configuration CI' during the encoding.

[0040] Function DR n The binary representation of k n Since (CI) is used, this function is executed on the array k as follows: n (CI). k n (0xxxxxx)=1 and k n (1xxxxxx)=2

[0041] Function DR n When the number N exceeds the threshold th, the updated function DR n+1 It evolves into.

[0042] Figure 7 shows the updated function DR when N(10xxxxx) exceeds the threshold th. n+1 Shows.

[0043] The tree is extended from the node corresponding to configuration 10xxxxx to two subnodes corresponding to configurations 100xxxx and 101xxxx. In the general case, when N(C) exceeds a threshold for configuration C, the node corresponding to configuration C is extended to two subnodes associated with two new configurations that replace configuration C. The two new configurations contain one more bit after the reduction.

[0044] After updating, function DR n+1 is the array k as follows: n It can be expressed as (CI). k n (0xxxxxx)=1,k n (11xxxxx)=2, and k n (10xxxxx)=3.

[0045] However, according to existing techniques, there is still room for improving the coding efficiency. In particular, the child occupancy of each node is coded in Morton order, and the coding order of the nodes is also Morton order.

[0046] Therefore, the prior art has at least two drawbacks, which are explained below.

[0047] First, in the prior art, when considering the encoding of the child occupancy of the current node, not all neighboring child volume occupancies have been encoded. Therefore, the occupancy information of some child volumes of neighboring nodes is missing, as will be explained below.

[0048] In the breadth-first Morton traversal order, the available adjacent child nodes are as shown in Figure 8. The child node occupancies of the seven adjacent nodes in the lower x, y, and z corners (a) are always available because they have already been coded. However, the child node occupancies of the seven adjacent nodes in the higher x, y, and z corners (b) are not available because they have not yet been coded. Meanwhile, the child node occupancies of the remaining 12 adjacent nodes may or may not have already been coded, and therefore may or may not be available.

[0049] The availability of these 12 neighbors depends on the position of the current node in the octree and the positions of their corresponding Morton codes. In particular, according to the first ordering, this depends on the position of the current node in its parent node.

[0050] Thus, one of the main drawbacks of using Morton order is that the neighborhood patterns used to determine the entropy context or make predictions can vary significantly for different child volume positions in the Morton order, which complicates the design of efficient entropy coding for occupancy trees and can result in suboptimal compression.

[0051] Second, one known advantage of using Morton order (or some other space-filling curve that is known to be similar) is that this order tends to allow for processing nodes that have close distances in 3D using close distances in the 1D Morton order (i.e., distances between Morton codes / indexes). Of course, this is just a tendency.

[0052] However, there are exceptions where two nodes at a given depth may be close in 3D but actually far apart in the 1D Morton order. This can occur, for example, when the nodes are close but on opposite sides of the center of a larger node. In one example, a first voxel belongs to the volume corresponding to b0 in Figure 1 in the root node, and this first voxel is close to the center of the root node. A second voxel belongs to the volume corresponding to b7, and is close to the center of the parent node. In extreme cases, both voxels may be so close that they share an edge, but after several depths in the octree traversal, the Morton codes associated with the refined nodes containing these voxels become separated in the 1D Morton order.

[0053] For example, there are two points (x0,y0,z0) and (x1,y1,z1), and the points (x0,y0,z0)=(255,255,255) and (x1,y1,z1)=(256,256,255), which can be represented in binary as follows: (x0,y0,z0)=(255,255,255)=(011111111b,011111111b,011111111b) (x1,y1,z1)=(256,256,255)=(100000000b,100000000b,011111111b)

[0054] Combining the first bit values of the three coordinates, 000b for point (x0,y0,z0) and 110b for point (x1,y1,z1), we can obtain that at the root node, point (x0,y0,z0) belongs to node b0 and point (x1,y1,z1) belongs to node b6. As shown in Figure 1, they share the same edge.

[0055] And their Morton codes are as follows: m0=000111111111111111111111111b=16 777275 m1=110001001001001001001001001b=103 060 041

[0056] Next, the Euclidean distance in Cartesian coordinate space is:

number

[0057] Moreover, the Euclidean distance in the Morton code space is as follows:

number

[0058] Thus, the Morton codes associated with refined nodes containing two points are farther apart in the 1D Morton order. Summary of the Invention [Problem to be solved by the invention]

[0059] It is therefore an object of the present invention to provide a method for encoding a 3D point cloud into a bitstream and a method for decoding the geometry of the 3D point cloud from the bitstream, which has higher coding efficiency. [Means for solving the problem]

[0060] This problem is solved by a decoding method according to claim 1, an encoding method according to claim 2, an encoder according to claim 12, a decoder according to claim 13, a bitstream according to claim 14 and software according to claim 15.

[0061] In a first aspect of the present invention, there is provided a method for decoding a 3D point cloud from a bitstream, the method being implemented in a decoder, the geometry of the point cloud being defined by an octree structure having a plurality of nodes, the plurality of nodes having a parent-child relationship and representing three-dimensional positions of objects, the point cloud being located in a volume space of a three-dimensional coordinate system, the volume space being recursively divided into sub-volumes and containing points of the point cloud, a volume being divided into a set of sub-volumes, each of the volumes being associated with one node of the octree structure, and occupancy information associated with each child sub-volume of each of the sub-volumes indicating whether each of the child sub-volumes contains at least one of the points, the method comprising:

[0062] obtaining a node that includes at least a portion of the points at a depth d in lexicographic order along each of the axes X, Y, and Z of the coordinate system;

[0063] and entropy decoding the occupancy information of the child nodes of each node from the bitstream based on the lexicographical order.

[0064] In another aspect, there is provided a method, implemented in an encoder, for encoding a 3D point cloud into a bitstream, wherein the geometry of the point cloud is defined by an octree structure having a plurality of nodes, the plurality of nodes having a parent-child relationship and representing three-dimensional positions of objects, the point cloud is located in a volume space of a three-dimensional coordinate system, the volume space is recursively divided into sub-volumes and contains points of the point cloud, a volume is divided into a set of sub-volumes, each of the sub-volumes is associated with one node of the octree structure, and occupancy information associated with each child sub-volume of each of the sub-volumes indicates whether each of the child sub-volumes contains at least one of the points, the method comprising:

[0065] obtaining a node that includes at least a portion of the points at a depth d in lexicographic order along each of the axes X, Y, and Z of the coordinate system;

[0066] and entropy coding the occupancy information of each node's child nodes into a bitstream based on lexicographical order.

[0067] A point cloud is a set of points in a three-dimensional coordinate system. The points are often intended to represent the exterior surfaces of one or more objects. Each point has a position (location) in the three-dimensional coordinate system. The position can be represented by three coordinates (X, Y, Z), which can be in a Cartesian coordinate system or any other coordinate system. Thus, according to the invention, for a given depth d in the octree, the nodes are obtained in lexicographic order and the occupation of the child nodes is coded according to the lexicographic order for the full resolution. Preferably, the nodes are stored in a linked data structure (e.g., a linked list), where the linked data structure has elements related to each other such that the elements are arranged sequentially. Preferably, the list L dThe nodes can be stored using [mathematical formula - see original document] and the nodes can be retrieved iteratively from the list. With lexicographic ordering (regardless of the axis ordering used in the lexicographic ordering), the occupancy of any child volume with a lower z-position, lower y-position, or lower x-position can be used for contextualization. Thus, prediction is more stable at different child volume positions in the lexicographic order than prior art (e.g., Morton order). This improves coding efficiency and reduces processing latency.

[0068] Preferably, the method further comprises storing the occupied child nodes at depth d+1 in the lexicographic order. Thus, if the node at depth d is not a leaf node, it is possible to continue traversing the octree in lexicographic order. The child nodes at the next depth d+1 are already stored in the preferred order, thereby making the next iteration even easier.

[0069] Preferably, said lexicographic order of nodes at depth d and / or said lexicographic order of nodes at depth d+1 is a raster scan order.

[0070] Preferably, the entropy encoding or decoding of the occupancy information of the child nodes of each node at depth d into or from the bitstream is performed based on the lexicographic order of child nodes at depth d+1. Thus, the occupancy of any child node having a lower z-position, lower y-position, or lower x-position than the coded child node can be used for contextualization. A predetermined pattern of adjacent child nodes can then be defined and used to select a coding context for any coded occupancy bit.

[0071] Preferably, the entropy coding or decoding of the child node occupancy information of each node into or from the bitstream is further performed based on the same adjacent child node occupancy pattern that indicates the context for each child node. Therefore, the adjacent occupancy pattern used to construct the context of each child can be the same and predefined, and using the same adjacent child node occupancy pattern can simplify the construction of context information, thereby improving coding efficiency.

[0072] Preferably, the context for each child node is selected based on the child node occupation pattern and / or the occupation pattern of adjacent parent nodes. If the adjacent node occupation pattern is used to select the entropy coding context, the information provided by the occupation bits of the six adjacent nodes of a parent node does not have the same importance in selecting an appropriate entropy coding context for encoding a child volume / node. Therefore, the context selection can also depend on a child occupation index within the node, which indicates the position of the child node within the node. Therefore, by considering the child occupation index, i.e., the position of the child node within the parent node, the importance of each occupation bit of an adjacent node can be distinguished. Preferably, each index is associated with a weight indicating the importance of the adjacent node.

[0073] Preferably, storing the occupied child nodes at depth d+1 in lexicographic order is performed by processing each node in four passes. In this case, four tubes may be defined for each node at a depth. Each tube is formed by the corresponding tubes of all nodes that have fixed coordinate positions in a plane formed by two of the three coordinate axes. A detailed description of the tubes is provided, for example, with reference to Figures 9 and 10. To encode all child nodes of a node, each node is processed four times, and each time one of the node's four tubes is traversed.

[0074] Preferably, the occupancy information of the child nodes of each node is entropy coded into or decoded from the bitstream based on the lexicographic order of nodes at depth d and a fixed order of the child nodes for a given node. Thus, occupied nodes are processed in raster scan order, but the occupancy bits of all child volumes of a node are coded consecutively in a fixed order. Compared with the prior art with nodes coded in Morton order, the adoption of lexicographic order of scanning makes neighboring information more reliable and coding performance is better.

[0075] Preferably, storing the occupied child nodes at depth d+1 is performed by processing each node in a single pass for all nodes of the obtained node, preferably by ordering the child nodes in the lexicographic order, preferably raster scan order, using an intermediate storage. For example, an intermediate list can be used to order the child nodes within a node in a single pass, thereby avoiding the need to process each node four times to encode all child nodes. The encoding complexity is further reduced and does not affect the encoding performance.

[0076] Preferably, the entropy encoding or entropy decoding of each of the child nodes applies an optimal binary coder with dynamic on-the-fly update (OBUF), which is therefore more efficient when a sufficiently large number of occupied bits are coded, with the additional beneficial effect of a dynamic OBUF.

[0077] In another aspect of the present invention, there is provided an encoder for encoding a 3D point cloud into a bitstream, the encoder comprising a memory and a processor, the memory storing instructions that, when executed by the processor, perform the steps of the method for encoding described above.

[0078] In another aspect of the present invention, there is provided a decoder for decoding a 3D point cloud from a bitstream, said decoder comprising a memory and a processor, wherein the memory stores instructions that, when executed by the processor, perform the steps of the method for decoding described above.

[0079] In another aspect of the invention, there is provided a bitstream encoded by the steps of the method for encoding described above.

[0080] In another aspect of the invention, there is provided a computer readable storage medium comprising instructions for performing the steps of the method for encoding a 3D point cloud into a bitstream as described above.

[0081] In another aspect of the invention, there is provided a computer-readable storage medium comprising instructions for performing the steps of the method for decoding a 3D point cloud from a bitstream as described above. [Brief explanation of the drawings]

[0082] The invention will now be described in more detail with reference to the accompanying drawings.

[0083] The drawings show:

[0084] [Figure 1] The Morton order of the child nodes and occupied bits is shown.

[0085] [Figure 2] Indicates the neighborhood consisting of nodes at the same depth or higher than the current node.

[0086] [Figure 3] 1 shows an example of an occupied node in a neighborhood that includes neighboring nodes at a higher depth than the current depth.

[0087] [Figure 4]When encoding or decoding the occupied bits of a child node (striped cube) using Morton order, we show the occupancy map (white cubes) that is known from the previously encoded or decoded occupied bits.

[0088] [Figure 5] 1 shows a raster scan of voxels.

[0089] [Figure 6] We present a tree-based dynamic reduction function DRn.

[0090] [Figure 7] We show that a tree-based dynamic reduction function DRn evolves to DRn+1.

[0091] [Figure 8] When using Morton traversal order, the adjacent child nodes of the current node (gray) are shown, where (a) is always available, (b) is unavailable, and (c) is sometimes available.

[0092] [Figure 9] 1 illustrates the raster scan process of a parent node to raster scan encode the occupation of its child nodes.

[0093] [Figure 10] Indicates the coding order of slice 0 and slice 1 for occupied nodes with the same fixed x at the current depth.

[0094] [Figure 11] 1 is an embodiment of a decoder using the provided method;

[0095] [Figure 12] 1 is an embodiment of an encoder using the provided method;

[0096] [Figure 13]When encoding the occupied bits of a child node (striped cube) using raster scan order, we show the occupancy map (white cubes) known from previously encoded occupied bits.

[0097] [Figure 14] An example of a neighbor occupancy pattern shown in 3D (left) and 2D layers (right).

[0098] [Figure 15] An example of a neighbor occupancy pattern when encoding a child occupancy bit (striped cube) is shown.

[0099] [Figure 16] 1 shows a raster scan ordered parent node with 8 child occupied bit encodings and raster scan ordering of the child nodes.

[0100] [Figure 17] One embodiment (decoding using raster-scan ordered parent nodes with eight child-occupied bits coded together) is shown.

[0101] [Figure 18] 10 shows an example of an encoder according to the second embodiment (encoding method using raster scan ordering).

[0102] [Figure 19] The occupancy map (white cubes) is shown as it is known from the previously coded or decoded occupancy bits when encoding or decoding the occupancy bits of the child nodes (striped cubes) using the raster scan order of the nodes, but encoding all bits of the occupancy of the child nodes using Morton order.

[0103] [Figure 20] 1 shows a block diagram of an encoder for one embodiment in which child nodes are ordered in raster scan order by processing the nodes in a single pass.

[0104] [Figure 21]1 shows a block diagram of a decoder for one embodiment in which child nodes are ordered in raster scan order by processing the nodes in a single pass.

[0105] [Figure 22] The process of putting the occupied child nodes of node Nk into Ld+1 in raster scan order is shown.

[0106] [Figure 23] The configuration of buffer Ld+1 at depth d and buffer L0 of buffer Ld+1 is shown.

[0107] [Figure 24] 1 shows a schematic flow chart of a method for encoding.

[0108] [Figure 25] 1 shows a schematic flow chart of a method for decoding.

[0109] [Figure 26] 1 shows an encoder according to the present invention;

[0110] [Figure 27] 1 shows a decoder according to the invention; DETAILED DESCRIPTION OF THE INVENTION

[0111] In a G-PCC occupancy tree, each node in the tree represents an occupied cubic volume whose size / volume can be determined from its depth in the tree. The occupancy is depth-encoded for each depth in the tree, starting from the root node, which represents the complete volume of the point cloud. In other words, the occupancy tree is encoded and decoded using a breadth-first traversal of the tree. Limiting ourselves to an octree representation (direct encoding mode not enabled) for simplicity, each depth in the octree provides twice the precision in each of the three dimensions. At a given depth (d) in the tree, all nodes in the tree are processed according to Morton order on their coordinates. For each node, the occupancy of eight subvolumes at the next depth is encoded, representing a 2x2x2 child volume, and the child volume marked as occupied provides the child node at the next depth in the tree.

[0112] If quadtree partitioning is used at a given depth level (d), the occupancy of the sub-volumes at the next depth will be 2x2x1, 2x1x2, or 1x2x2 child volumes (i.e., 2D). The processing order of the child nodes at the next depth (d+1) will then be the encoding order used for their parent nodes (i.e., the nodes at depth d) refined by their Morton order in this 2D space (i.e., Z-traversal order along the two partition directions). If binary tree partitioning is used, the occupancy will be 2x1x1, 1x2x1, or 1x1x2 child volumes (i.e., 1D). The processing order of the child nodes at the next depth will then be the encoding order used for their parent nodes refined by their Morton order in this 1D space (i.e., lexicographic order along the partition directions).

[0113] Essentially, a node queue structure can be used to process nodes according to Morton order. The process starts with a queue containing a single node (the root node corresponding to the complete point cloud volume). Then, while the queue is not empty, the first (front) node in the queue is removed, the occupation of its child volumes is encoded, and if these child volumes are not leaf nodes, the child nodes of the occupied child volumes are added to the end (back) of the queue, following their respective Morton order. Thus, the queue structure behaves like a first-in-first-out (FIFO) buffer. The child nodes pushed first are encoded first when processing the next depth.

[0114] Figure 1 shows the eight possible child nodes of a parent node ordered in Morton order. The occupancy bits b0 through b7 indicate the presence or absence of a point in each of the corresponding subvolumes. These bits are encoded during processing of the parent node, and nodes corresponding to occupied child nodes are added to the processing queue.

[0115] In an octree representation of a point cloud, as shown in FIG. 2, if the nodes are processed in depth-first order as in MPEG GPCC, one can benefit from the occupation of nodes at known higher depths.

[0116] Nodes with a higher depth than the current node are used to obtain geometry information in areas not yet coded at the current depth (where the y-values are greater than the y-value of the current node).

[0117] In MPEG G-PCC, the combination of neighboring nodes at the current depth and the current depth + 1 is used to define the neighborhood. However, to limit the number of possible neighborhood configurations, the neighborhood is restricted to a subset of the set of nodes that are neighbors of the current node.

[0118] FIG. 3 shows an example of a neighborhood where only occupied nodes are depicted, when neighboring nodes at a higher depth than the current depth are also included.

[0119] It should be understood that when using breadth-first traversal order, when encoding for child occupancies, the occupancies of all neighboring nodes at the same depth as the current node are always known, since they were encoded at the previous depth.

[0120] Figure 4 shows that when nodes are processed in Morton order and occupancy bits are also coded in Morton order, the volume of occupancy at a given depth (composed of white cubes) is known when coding occupancy bits for the current child node (striped cube). From this figure, we can also understand the nature of the different subvolumes that can be mapped into the occupancy atlas.

[0121] Raster scan order is typically used to encode attributes of dense content (e.g., gray levels or three-channel color) for which geometry does not need to be provided, i.e., the geometry covers the entire surface (in 2D) or volume (in 3D, e.g., in biomedical images or video content) of the image.

[0122] In some embodiments, a mask is provided that defines a region of interest to which the attribute encoding is restricted. The encoding of this mask can be assimilated as the encoding of the geometry occupancy in the point cloud. Preferably, the mask is simply encoded by sequentially encoding a bit for all possible voxel positions in the considered volume using raster scan order and context entropy encoding, with each bit indicating whether the corresponding voxel is occupied or not (and therefore whether an attribute is encoded for that voxel position or not).

[0123] In 2D, the raster scan order of pixels is simply a lexicographic ordering of pixels according to their 2D coordinates x and y. Lexicographic ordering in (y,x) is typically used for images. Pixel processing is ordered first by x, then by y, where pixels are ordered by increasing x coordinates and then by increasing y coordinates for a given y coordinate. 3D raster scan order is similar, but in three-dimensional space (i.e., 3D raster scan order is a lexicographic order on the arrangement of 3D coordinates). While the raster scan order of voxels follows only lexicographic ordering, lexicographic ordering in three dimensions x, y, z, e.g., (z,y,x), can be used for volumetric images (or t,y,x for a time series of images such as a video).

[0124] As shown in FIG. 5, in a voxel representation of the geometry of a point cloud, the voxels (=3D volume associated with a single point) may be scanned in a raster scan order as shown in FIG.

[0125] In Figure 5, the order shown follows a raster scan, first in y, then in x, and finally in z. This is the lexicographic order in xyz. Figure 5 also shows the causal neighborhood (already coded nodes / voxels: composed of white cubes) of the current node / voxel (hash cube) to be coded. The occupancies of the already coded neighborhoods are known and can be used to predict and code the occupancy of the current node / voxel. Already coded nodes / voxels are those whose lexicographic order is lower than that of the current node / voxel.

[0126] The provided method encodes / decodes child volume occupancy bits based on nodes in raster scan order at a given depth in the occupancy tree. In one embodiment of the provided method, the raster scan order of the child volumes is used to encode / decode their respective occupancy bits. In another embodiment of the provided method, the raster scan order of the nodes is used to encode / decode the occupancy bits of all their respective child volumes (together).

[0127] In one embodiment, the provided method is illustrated in Figure 9. For better understanding, the entire occupied volume is depicted in the figure to better see the raster scan order of processing. It should be understood that if an ancestor node is indicated as unoccupied, then part of the volume will not be coded / processed.

[0128] As shown in Figure 9, a lexicographical order in (x,y,z) (i.e., a colexicographical order in (z,y,x)) is used. For a given depth in the octree, the occupancy of child nodes is coded according to the raster scan order of the child nodes. To enable the raster scan order of the child nodes, four tubes (tube 0, tube 1, tube 2, tube 3) are defined for each node at the current depth, and each tube is made up of all nodes with the same x and y. Then, coding the occupancy bits of child nodes of tube 0 is performed by coding the occupancy bits b0, b1 of all occupied nodes with the same fixed x and y, and the nodes are ordered by increasing the z of all occupied nodes. Next, coding the occupancy tube 1 is performed by coding the occupancy bits b2, b3 of the same node, in the same order as tube 0.

[0129] The encoding process for encoding occupied tubes 0 of all occupied nodes with the same fixed x and y, and occupied tubes 1 of all occupied nodes with the same fixed x and y, is repeated for each y in ascending y order. This provides a raster scan encoding of slice 0, consisting of bits b0, b1, b2, and b3 of all occupied nodes with the same x. A diagram of the raster scan ordering of slice 0 of these nodes is shown in Figure 10(a), where each child node is represented in 2D for better illustration. After encoding slice 0 of nodes with a fixed x, this is followed by encoding slice 1 of these nodes with the same x. The encoding process for slice 0 is then repeated for slice 1 by sequentially encoding occupied bits b4 and b5 of the same nodes, followed by occupied tubes 2 and 3, consisting of occupied bits b6 and b7, in the same order. The encoding process of slice 1 for these nodes in raster scan ordering is then shown in Figure 10(b), where each child node is represented in 2D for better illustration. The encoding process of slice 0, then slice 1, is repeated for each x number of nodes at the current depth among all occupied nodes in ascending order.

[0130] An embodiment of a decoder using the provided method is shown as a block diagram in FIG. 11, where list L d is the node N at depth d in the octree. k (x k ,y k ,z k ), and the nodes are N0 to N last k is the list L ordered in raster scan order up to d is the ordering index of the node in Figure 12. A process for decoding the occupancy of the child node (sIdx, tIdx, i) at depth d+1 from the bitstream according to the raster scan ordering; and Raster scan of the next depth to generate an ordered node by listing the child nodes d+1 The process of putting

[0131] The variable sIdx represents the slice index of all occupied nodes with the same x, the variable tIdx represents the tube index of all occupied nodes with the same x and y, and the variable i represents the index of the child node within each tube.

[0132] In other words, the integer value obtained from the binary word formed by (sIdx,tIdx,i) is the child index of the node (a decimal value between 0 and 7).

[0133] The variable kSStart is used to store the ordering index of the first node of the slice of all occupied nodes with the same x, and the variable kTStart is used to store the ordering index of the first node of the tube of all occupied nodes with the same x and y.

[0134] The depth dMax is the maximum depth in the tree and can be determined from the bitstream.

[0135] The detailed process in the decoder can be described as follows: To initialize the algorithm, set the list L0 to contain only the root node of the occupancy tree and set the initial depth d to 0. Label 0: A (fifo) list L that stores the nodes at depth d in raster scan order d Get. Empty list L d+1 to generate a child node in the raster scan ordering for decoding the next depth. Set the node index k to 0 (initialize the variable k with the value 0). Label 1: Set the slice index sIdx to 0 (initialize the variable sIdx to the value 0). Set the first node index in the slice to k (initialize the variable kSStart with the value k). Label 2: Set the tube index tIdx to 0 (initialize the variable tIdx with the value 0). Set the first node index in the tube to k (initialize the variable kTStart with the value k). Label 3: List L d to node N k (x k ,y k ,z k ) to get the Set the child index in the tube to 0 (initialize the variable i with the value 0). Process 0:L d Node N in k Decode and generate ordered child nodes of the child nodes in tube tIdx of slice sIdx of . The occupied bits of the i-th child node of the tube tIdx of the slice sIdx from the bitstream (N k Decode the child node (sIdx, tIdx, i) of If the decoded bits indicate that the child node is occupied, create a new node (N k List L d+1 This new node is added to the end of the coordinates (2×x k +sIdx,2×y k +tIdx,2×z k +i). If i is not equal to 1, increment i and repeat process 0, else go to next step. N k is the last node of depth d (i.e., list L d Determine whether the node is the last node of the N k is not the last node at depth d, then the list L d to the next occupied node N k+1 (x k+1 ,y k+1 ,z k+1 ) and then xk ≠x k+1 or y k ≠y k+1 It is determined whether or not x k ≠x k+1 or y k ≠y k+1 If tIdx==1, it means that the next node does not belong to the same tube of occupied nodes with the same x and the same y (then determine whether tIdx==1). If tIdx==1, this means that the processing of the two tubes of the child nodes of the current slice of the child node (in the tubes of all occupied nodes with the same x and y) has been completed. k ≠x k+1 It is determined whether or not x k ≠x k+1 If so, it means that the next node does not belong to the same slice of the occupied node with the same x. Then, determine whether sIdx==1. If sIdx==1, this means that the processing of two slices of child nodes (in the slices of all occupied nodes with the same x) has finished. Therefore, N k+1 is the start of the next slice of occupied nodes and the next tube of occupied nodes to be processed. Increase k by 1 and loop to label 1 to start processing the tube of the first child node of the slice of the first child node of the slice of the next occupied node. Otherwise, sIdx==0, which means we can start processing the second slice of the occupied node. Label 4: · Increase the slice index sIdx by 1 and reset k to the index of the first node in the slice of all occupied nodes with the same x: k=kSStart. Loop to label 2 and start processing the third tube of child nodes. Otherwise, x k ==xk+1 This means that the next node belongs to the same slice of the occupied node, but to the next tube of the occupied node. k+1 is the start of the next tube to be processed. Increase k by 1, loop to label 2 and start processing the first tube of the child node of the next tube of the occupied node (belonging to the current slice sIdx of the child node). Otherwise, tIdx==0, which means we can start processing the second tube of the child node of the current slice of the child node. Label 5: · Increase the tube index tIdx by 1 and reset k to the index of the first node in the tube of all occupied nodes with the same x and y: k=kTStart. Loop to label 3 and start processing the second tube of child nodes. Otherwise, x k ==x k+1 and y k ==y k+1 This means that the next node belongs to the same tube of the occupied node. Increase k by 1 and loop to label 3 to continue processing the same tube of child nodes. Otherwise, N k ==N last and the node is the last node at depth d. Next, determine whether tIdx==1. If tIdx==1, this means that the last tube of the child node's current slice has finished processing, and the next slice of the child node (if any) can be processed. Next, determine whether tIdx==1. If sIdx==1, this means that the processing of the last slice of the child node of the last slice of the occupied node has finished. Then the next depth in the occupation tree (if any) can be processed. Then, determine whether d==dMax. ·When d == dMax, it means that the last depth of the occupancy tree has been decoded. After that, the occupancy tree is completed. ·Otherwise, d < dMax. This means that the next depth of the occupancy tree can be processed. Increase d by 1 and loop to label 0 to process the next depth in the occupancy tree. ·Otherwise, sIdx == 0. This means that the processing of the second slice of the child node of the last slice of the occupied node can be started. Proceed to label 4 to start it. ·Otherwise, tIdx == 0. This means that the processing of the last tube of the child node of the current slice of the child node can be started. Proceed to label 5 to start it.

[0136] In a preferred embodiment, list L d+1 can be omitted. When d == dMax, no further depth is processed so the list is not used and the child node is not added to the list.

[0137] The coordinates of the child node are those of its parent node refined to 1-bit accuracy. In other words, some physical space coordinates of the center of the node can be obtained by multiplying the coordinates of the center of the node by the physical dimensions of the volume of the node scaled according to the depth: ((x k , y k , z k ) + (0.5, 0.5, 0.5)) × (width, length, height) / 2 深度 .

[0138] In a preferred embodiment, when d == dMax and the child node is occupied, the point with coordinates ((2 × x k + sIdx, 2 × y k + tIdx, 2 × z k + i) + (0.5, 0.5, 0.5)) × (width, length, height) / 2 dMax is output (e.g., in a buffer). A raster scan order point geometry is generated.

[0139] From the above child node encoding process, each node N k It can be observed that needs to be accessed / processed four times: once to encode occupied tube 0, a second time to encode occupied tube 1, a third time to encode occupied tube 2, and finally a final time to encode occupied tube 3.

[0140] Node N required by this encoding process to construct the raster scan ordering of its child nodes k The mentioned ordering of is already obtained from the raster scan ordering of the processed nodes. Also, the raster scan ordering of the nodes is obtained directly from the raster scan ordering of the child node occupancy coding performed on the parent node (i.e., the depth period before the octree occupancy coding).

[0141] Similarly, one embodiment of an encoder using the provided method is shown as a block diagram in FIG.

[0142] The effect of the provided method is illustrated in FIG. 13, which shows the child volume occupancy map coverage already known when encoding the occupied bits of striped child volumes when the occupied bits are encoded according to the raster scan order of the child volumes of a node. FIG. 13 also makes it possible to see neighboring positions that can be used to build a context for entropy encoding of the occupied bits. Using the raster scan ordering (regardless of the axis ordering used in lexicographical ordering), the occupancy of any child volume with a lower z-position, lower y-position, or lower x-position can be used for contextualization. Thus, a predetermined pattern of neighboring child volumes can be defined and used to select the encoding context for any encoded occupied bit.

[0143] In some embodiments, when entropy coding each child node in raster scan order, the neighbor occupancy pattern used to construct a context for each child node may be the same. As an example of a neighbor occupancy pattern, FIG. 14 provides an example of a child neighbor occupancy pattern (occupancy of white subvolumes) that may be used to determine an entropy coding context for encoding the occupancy bits for a striped child volume when the child occupancy is coded in raster scan order. On the left, this neighborhood is represented in 3D, and on the right, it is represented as a 2D layer. In one example, each number on the right may be used to order the occupancy bits from most significant (position 0) to least significant (position 15) for use with the dynamic OBUF described above. This results in 65,536 entropy contexts. In some embodiments that do not use a dynamic OBUF, the number of neighbors may be limited to, for example, positions 0 through 11, reducing the number of contexts to 4,096.

[0144] 15 shows the neighboring pattern consisting of six direct neighbors (nodes that share a face) of a node when encoding different occupancy bits of the child volume of the current node. As in the prior art, in Morton ordering, the occupancy of adjacent parent nodes can provide useful information for improving compression efficiency.

[0145] Even when using raster scan coding of child volumes, the occupancy neighbors of the same child occupancy pattern can be used to code any one of the child volume occupancy bits, and it can be seen that, depending on the child volume's location, the information provided by the occupancy bits of the parent node's six neighboring volumes / nodes does not have the same importance in selecting the appropriate entropy coding context for coding the child volume. Thus, when neighbor node occupancy is used for entropy coding context selection, the context selection may also depend on the child occupancy index. This also applies to the use of other neighbor nodes; for example, the 36 neighbor nodes consisting of any neighbor node / volume that has a shared face, edge, or wedge with the current node are used in modeling the entropy coding context.

[0146] In some embodiments, the provided method encodes / decodes (together) the occupied bits of all respective child volumes at a given depth in the occupancy tree using a raster scan ordering of the nodes. Preferably, the occupied nodes are processed in raster scan order, as shown in Figure 16, but the occupied bits of all child volumes of a node are sequentially coded in a single pass at the node in an order that can use, for example, a Morton scan order of the child node occupied bits (which means that each node's child volumes are coded in a single pass using Morton ordering at the node). Then, to order the child nodes in raster scan order for the next depth, the same child node ordering method as in the 4-tube embodiment at each node at the current depth is used, as shown in Figure 11.

[0147] FIG. 17 shows an example of a child node occupation decoding process of a decoder in some embodiments, and FIG. 18 shows an example of an encoder in some embodiments, and the child node ordering process is not shown in both FIG. 17 and FIG. 18.

[0148] The detailed process in the encoder / decoder can be described as follows: A fifo list L that stores the nodes at depth d in raster scan order. d Get. FIFO list L d From node N at depth d k (x k ,y k ,z k ), starting with the first node N0(x0,y0,z0) at each depth. The bits occupied by its children are decoded from or encoded into the bitstream according to an ordering such as Morton's order. N k is a fifo list L d If it is not the last node in the fifo list L d Next node N in k+1 (x k+1 ,y k+1 ,z k+1 ) and it is L d Encode / decode until the last node in is reached. ·Encode the child node occupation at the next depth until the final depth is reached.

[0149] FIG. 19 shows the child node occupancy map already known when encoding the occupied bits of a striped child volume when using the alternative encoding ordering described in FIG. 16. Using the raster scan ordering of the nodes (regardless of the axis ordering used in lexicographic ordering), the occupancy of any child volume of a node with a lower z, lower y, or lower x position than the current node (parent node of the striped child volume) can be used to contextualize the entropy encoding of the striped child volume occupancy bit and any child volume occupancy bit previously encoded with respect to the current node. In this way, it can be clearly distinguished that for each position occupied by an encoded child volume, there is one different pattern for available neighboring nodes. Thus, in the case of octree occupancy, there are eight different patterns. Therefore, the entropy encoding of the occupied bits needs to be adjusted according to each pattern (i.e., for each occupied bit index) to be more optimal.

[0150] 11, but still outperforms the patterns in an octree with nodes coded in Morton order in the prior art. In the prior art, with Morton ordering of nodes, the patterns occupied by "unknown" (i.e., not yet coded) neighboring nodes further vary with position within the ancestor node (and thus with the Morton index); therefore, some neighbor information may not always be reliable when constructing the entropy context, which may introduce bias into the entropy coding probabilities constructed in the adaptive entropy coding context, thereby degrading coding performance.

[0151] It should be understood that in point cloud coding, occupied nodes and child nodes are rarely (and preferably never) dense like the examples in Figures 4, 9, 13, and 16. These figures are represented densely to provide a better view of the available causal child occupancy information and node / child node processing order. In a typical point cloud, some volumes are unoccupied, so the nodes for these volumes do not exist and are processed. The processing order for occupied nodes is the same as if the content were dense: for a given occupied node, the occupancies of all child volumes are always coded, but unoccupied nodes / volumes are not processed at all, since they do not exist in the tree structure. Compared to the processing order for dense content, the processing of these unoccupied nodes / volumes is skipped.

[0152] For example, in the embodiment shown in FIG. 16, the raster scan order of child nodes at depth d+1 is obtained by processing their parent nodes four times at depth d, which increases run-time complexity.

[0153] To reduce run-time complexity, the method preferably orders the child nodes in raster scan order rather than using four passes through each node. In some preferred embodiments, N nodes of depth d are ordered as shown in FIG. k The occupied child nodes of L are sorted by raster scan order. d+1 In the step of putting into, we use the intermediate list to order the children of the node in a single pass. The tube occupied by children 0 to 3 is L t0 , L t1 , L t2 and L t3 These lists are kept in four separate lists: s0 and L s1 Finally, the list L d+1 List L s0 and L s1 Constructed from

[0154] Specifically, N at depth d (k starts from 0) k (x k ,y k ,z k ), in this step, List L new nodes for each occupied child node of tube 0 t0 Put it in (add it to the end), List new nodes for each occupied child node of tube 1. t1 Put it in List new nodes for each occupied child node of tube 2. t2 Put it in List the new nodes for each occupied child node of tube 3. t3 Put it in. Here, the occupied child nodes of each tube are processed from bottom to top.

[0155] After iterating over all child nodes of the tubes of the (parent) node at the same x and y depth d, the tube list can be added to the slice list, L t0 L s0 is added to the end of t1 L s0 is added to the end of L t2 L s1 is added to the end of t3 L s1 This adds the slices to the end of each slice list L s0 and L s1 The child nodes are given in raster scan order at Then, an empty tube list is used to process the next tube of the (parent) node.

[0156] After iterating over all child nodes of the slice of the same (parent) node x at depth d, we add the slice list to the next depth list L. d+1 can be added to L s0 L d+1 is added to the end of s1 L d+1The empty slice list is used to process the next slice of the (parent) node, which results in the next slice at the next depth L d+1 The child nodes are provided in the list ordered in raster scan order. k The occupied child nodes of L in raster scan order. d+1 The detailed process of entering is shown in Figure 22.

[0157] If lists are implemented using memory blocks, appending a list from one to another can be expensive at runtime, requiring memory to be copied and memory to be allocated. To avoid this problem, in the preferred embodiment, lists L t0 , L t1 , L t2 , L t3 , L s0 , L s1 , L d and L d+1 are implemented using (dynamically) linked lists. Thus, appending one list to the other can have O(1) complexity. These intermediate buffers can hold a single-pass processing of nodes.

[0158] The obtained buffer L stores the child nodes in raster scan order for the next depth. d+1 are shown in Figures 23(a) and 23(b), and Figure 23(a) shows the buffer L d+1 , the buffer L for nodes with the same x x (L x0 From L x(2^d)-1 23(a) shows that the L t0 , L t1 , L t2 , L t3 Buffer L consisting of x0 The structure of the buffer L d+1 is configured as follows: Buffer L t0 and L t1 :L t0is for tube 0 (labeled in Figure 23(b)) of occupied nodes with the same x and the same y, and L t1 are for tube 1 (labeled in Figure 23(b)) of occupied nodes with the same x and the same y, and by increasing y order, they are s0 are continuously added to. Buffer L t2 and L t3 :L t2 is for tube 2 (labeled in Figure 23(b)) of occupied nodes with the same x and the same y, and L t3 are for tube 3 of occupied nodes with the same x and the same y (labeled in Figure 23(b)), and by increasing y order, they are s1 are continuously added to. Buffer L of occupied slice 0 of occupied node with the same x s0 is the buffer L of the occupied slice 1 of the occupied node with the same x. s1 is added to buffer L x This is, for example, in FIG. 23(a), x0 (when x=x1) and L x1 (when x=x0). Buffer L x-1 At the end of buffer L x At depth d, the buffer L is expanded by increasing x. x By successively adding d+1 The child nodes in raster scan order in are obtained.

[0159] Referring now to Figure 24, there is shown a schematic flow chart of a method for encoding a 3D point cloud into a bitstream according to the present invention.

[0160] The method includes the following steps.

[0161] In step S10, a node that includes at least a portion of the points at depth d in lexicographic order along each of the axes X, Y, and Z of the coordinate system is obtained.

[0162] In step S11, the occupancy information of the child nodes of each node is entropy coded into a bitstream based on the lexicographical order.

[0163] Referring now to Figure 25, there is shown a schematic flow chart of a method for decoding a 3D point cloud from a bitstream according to the present invention.

[0164] The method includes the following steps.

[0165] In step S20, a node that includes at least a portion of the point cloud at depth d in lexicographic order along each of the axes X, Y, and Z of the coordinate system is obtained.

[0166] In step S21, the occupancy information of the child nodes of each node is entropy decoded from the bitstream based on the lexicographical order.

[0167] Referring now to FIG. 26 , a simplified block diagram of an exemplary embodiment of an encoder 1100 is shown. The encoder 1100 includes a processor 1102 and a memory storage device 1104. The memory storage device 1104 can store a computer program or application containing instructions that, when executed, cause the processor 1102 to perform operations such as those described herein. For example, the instructions can encode and output an encoded bitstream according to the methods described herein. It should be understood that the instructions can be stored on a non-transitory computer-readable medium, such as a compact disc, a flash memory device, a random access memory, a hard drive, or the like. When the instructions are executed, the processor 1102 performs the operations and functions specified in the instructions, such that it operates as a dedicated processor implementing the described process. In some examples, such a processor may be referred to as a “processor circuit” or a “processor circuit system.”

[0168] Referring now to FIG. 27 , a simplified block diagram of an exemplary embodiment of a decoder 1200 is shown. The decoder 1200 includes a processor 1202 and a memory storage device 1204. The memory storage device 1204 may include a computer program or application containing instructions that, when executed, cause the processor 1202 to perform operations such as those described herein. It should be understood that the instructions may be stored on a computer-readable medium, such as a compact disc, a flash memory device, a random access memory, a hard drive, or the like. When the instructions are executed, the processor 1202 performs the operations and functions specified in the instructions, such that it operates as a special-purpose processor implementing the described processes and methods. In some examples, such a processor may be referred to as a “processor circuit” or a “processor circuit system.”

[0169] It should be understood that a decoder and / or encoder according to the present application may be implemented in several computing devices, including, but not limited to, a server, a suitably programmed general-purpose computer, a machine vision system, and a mobile device. The decoder or encoder may be implemented by software that includes instructions for configuring one or more processors to perform the functions described herein. The software instructions may be stored in any suitable non-transitory computer-readable memory, including a CD, RAM, ROM, flash memory, etc.

[0170] It should be understood that the modules, routines, processes, threads, or other software components implementing the decoders and / or encoders described herein, as well as the methods / processes for configuring the encoders or decoders, can be implemented using standard computer programming techniques and languages. The present application is not limited to any particular processor, computer language, computer programming conventions, data structures, or other such implementation details. Those skilled in the art will recognize that the described processes can be implemented as part of computer-executable code stored in volatile or non-volatile memory, as part of an application-specific integrated chip (ASIC), etc.

[0171] The present application also provides a computer readable signal encoding data produced by applying an encoding process according to the present application.

[0172] Certain adaptations and modifications of the described embodiments can be made. The above-described embodiments are therefore to be considered as illustrative and not restrictive. In particular, the embodiments can be freely combined with one another.

Claims

1. 1. A method for decoding a 3D point cloud from a bitstream, implemented in a decoder, comprising: the geometry of the point cloud is defined by an octree structure having a plurality of nodes, the plurality of nodes having a parent-child relationship and representing three-dimensional positions of objects; the point cloud is located within a volume space of a three-dimensional coordinate system, the volume space is recursively divided into sub-volumes and contains the points of the point cloud, the volume is divided into a set of sub-volumes, each of the sub-volumes is associated with a node of the octree structure, and occupancy information associated with each child sub-volume of each of the sub-volumes indicates whether each child sub-volume contains at least one of the points; The method comprises: obtaining a node that includes at least a portion of the points at a depth d in lexicographic order along each of the axes X, Y, and Z of the coordinate system; and entropy decoding the occupancy information of each node's child nodes from the bitstream based on the lexicographical order.

2. 1. A method for encoding a 3D point cloud into a bitstream, implemented in an encoder, comprising: the geometry of the point cloud is defined by an octree structure having a plurality of nodes, the plurality of nodes having a parent-child relationship and representing three-dimensional positions of objects; the point cloud is located within a volume space of a three-dimensional coordinate system, the volume space is recursively divided into sub-volumes and contains the points of the point cloud, the volume is divided into a set of sub-volumes, each of the sub-volumes is associated with a node of the octree structure, and occupancy information associated with each child sub-volume of each of the sub-volumes indicates whether each child sub-volume contains at least one of the points; The method comprises: obtaining a node that includes at least a portion of the points at a depth d in lexicographic order along each of the axes X, Y, and Z of the coordinate system; and entropy coding the occupancy information of each node's child nodes into a bitstream based on the lexicographical order.

3. The method of claim 1 or 2, wherein the method further comprises storing occupied child nodes at depth d+1 in the lexicographical order.

4. The method of claim 1 , wherein the lexicographic order of nodes at depth d and / or the lexicographic order of child nodes at depth d+1 is a raster scan order.

5. 5. The method of claim 3 or 4, wherein the entropy encoding or entropy decoding of the occupancy information of the child nodes of each node into or from the bitstream is performed based on the lexicographical order of child nodes at depth d+1.

6. 6. The method of claim 1, wherein the entropy encoding or entropy decoding of the child node occupancy information of each node into or from the bitstream is further performed based on the same adjacent child node occupancy pattern that indicates a context for each child node.

7. 7. The method of claim 6, wherein the context for each child node is selected based on the child node occupation pattern and / or the occupation pattern of an adjacent parent node, and preferably, when the occupation pattern of the adjacent parent node is used to select the entropy coding context, the context selection can also depend on a child occupation index within the parent node, the index indicating the position of the child node within the parent node.

8. 8. The method of claim 3, wherein storing the occupied child nodes at depth d+1 in lexicographic order is performed by processing each node in four passes.

9. 5. The method of claim 1, wherein entropy encoding or entropy decoding the occupancy information of the child nodes of each node into or from the bitstream is performed based on the lexicographical order of nodes at depth d and a fixed order of the child nodes for a given node.

10. 10. The method of claim 3, wherein storing the occupied child nodes at depth d+1 is performed by processing each node in a single pass for all nodes of the obtained node, preferably using intermediate storage and ordering the child nodes in the lexicographic order, preferably raster scan order.

11. The method according to claim 1 , wherein the entropy encoding or entropy decoding of each of the child nodes is performed using an optimal binary coder with dynamic on-the-fly update (OBUF).

12. 1. An encoder for encoding a 3D point cloud into a bitstream, comprising: An encoder comprising at least one processor and a memory, said memory storing instructions that, when executed by said processor, perform the steps of the method of any one of claims 2 to 11.

13. 1. A decoder for decoding a 3D point cloud from a bitstream, comprising: A decoder comprising at least one processor and a memory, said memory storing instructions that, when executed by said processor, perform the steps of the method of any one of claims 1, 3 to 11.

14. A bitstream encoded by the method of any one of claims 2 to 11.

15. A computer-readable storage medium comprising instructions which, when executed by a processor, perform the steps of the method of any one of claims 1 to 11.

Images