System and method for geometric point cloud coding

Abstract

According to one aspect of the present disclosure, there is provided a method for decoding a point cloud represented in a one-dimensional (1D) array comprising a set of points. The method may include determining, by at least one processor, a maximum number of transform coefficients for predicting attribute values for points in the set of points. The method may include decoding, by at least one processor, the bitstream to determine a maximum number of transform coefficients based on a logarithmic format subtracting a fixed integer.

Description

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application claims the benefit of priority to U.S. Provisional Application No. 63 / 366,904, filed on June 23, 2022, entitled “Geometric Point Cloud Coding,” which is incorporated herein by reference in its entirety. Background Art

[0003] Embodiments of the present disclosure relate to point cloud coding.

[0004] Point clouds are one of the main three-dimensional (3D) data representations that provide attributes associated with points in the 3D world in addition to spatial coordinates. Point clouds in their raw format require a lot of memory for storage or a lot of bandwidth for transmission. In addition, the emergence of higher resolution point cloud capture technologies has put forward higher requirements on the size of point clouds. In order to make point clouds usable, compression is necessary. Two compression techniques have been proposed for point cloud compression / coding (PCC) standardization activities: video-based PCC (V-PCC) and geometry-based PCC (G-PCC). The V-PCC method is based on 3D to two-dimensional (2D) projection, while G-PCC, on the contrary, encodes the content directly in 3D space. To achieve this, G-PCC utilizes data structures such as octrees that describe the positions of points in 3D space. Summary of the invention

[0005] According to one aspect of the present disclosure, a method for decoding a point cloud is provided, the point cloud being represented by a one-dimensional (1D) array including a set of points. The method may include determining, by at least one processor, a maximum number of transform coefficients for predicting attribute values ​​of points in the set of points. The method may include decoding, by at least one processor, a bitstream to determine the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

[0006] According to another aspect of the present disclosure, a system for decoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The system may include at least one processor and a memory storing instructions. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: determine a maximum number of transform coefficients for predicting attribute values ​​of points in the set of points. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: decode a bitstream to determine the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

[0007] According to another aspect of the present disclosure, a method for encoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The method may include determining, by at least one processor, a maximum number of transform coefficients for predicting attribute values ​​of points in the set of points. The method may include encoding, by at least one processor, a bitstream to indicate the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

[0008] According to another aspect of the present disclosure, a system for encoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The system may include at least one processor and a memory storing instructions. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: determine a maximum number of transform coefficients for predicting attribute values ​​of points in the set of points. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: encode a bitstream to indicate the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

[0009] According to another aspect of the present disclosure, a method for decoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The method may include: determining, by at least one processor, a maximum zero run length associated with a plurality of attribute values ​​associated with one or more points in the set of points. The method may include: decoding, by at least one processor, a bitstream in a single-loop process based on the zero run length in response to the encoded zero run length being less than or equal to the maximum zero run length. The method may include: decoding, by at least one processor, a bitstream in a multi-loop process based on the maximum zero run length and the encoded zero run length in response to the encoded zero run length being greater than the maximum zero run length.

[0010] According to another aspect of the present disclosure, a system for decoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The system may include at least one processor and a memory storing instructions. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: determine a maximum zero run length associated with multiple attribute values ​​associated with one or more points in the set of points. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: in response to an encoded zero run length being less than or equal to the maximum zero run length, decode a bitstream in a single-cycle process based on the zero run length. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: in response to an encoded zero run length being greater than the maximum zero run length, decode a bitstream in a multi-cycle process based on the maximum zero run length and the encoded zero run length.

[0011] According to another aspect of the present disclosure, a method for encoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The method may include: determining, by at least one processor, a maximum zero run length associated with a plurality of attribute values ​​associated with one or more points in the set of points. The method may include: encoding a bitstream in a single-cycle process based on the zero run length in response to the encoded zero run length being less than or equal to the maximum zero run length by at least one processor. The method encodes the bitstream in a multi-cycle process based on the maximum zero run length and the encoded zero run length in response to the encoded zero run length being greater than the maximum zero run length by at least one processor.

[0012] According to another aspect of the present disclosure, a system for encoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The system may include at least one processor and a memory storing instructions. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: determine a maximum zero run length associated with multiple attribute values ​​associated with one or more points in the set of points. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: in response to the encoded zero run length being less than or equal to the maximum zero run length, encode a bitstream in a single-cycle process based on the zero run length. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: in response to the encoded zero run length being greater than the maximum zero run length, encode the bitstream in a multi-cycle process based on the maximum zero run length and the encoded zero run length.

[0013] These illustrative embodiments are not mentioned to limit or define the present disclosure, but to provide examples to aid understanding of the present disclosure. Additional embodiments are described in the detailed description, and further description is provided in these additional embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0014] The accompanying drawings, which are incorporated herein and constitute a part of the specification, illustrate embodiments of the present disclosure and, together with the description, further serve to explain the principles of the present disclosure and enable those skilled in the relevant art to make and use the present disclosure.

[0015] Figure 1 A block diagram of an exemplary encoding system according to some embodiments of the present disclosure is shown.

[0016] Figure 2 A block diagram of an exemplary decoding system according to some embodiments of the present disclosure is shown.

[0017] Figure 3 According to some embodiments of the present disclosure Figure 1 Detailed block diagram of an exemplary encoder in the encoding system in.

[0018] Figure 4 According to some embodiments of the present disclosure Figure 2 Detailed block diagram of an exemplary decoder in a decoding system in .

[0019] Figure 5A and Figure 5B An exemplary octree structure and a corresponding digital representation of a G-PCC according to some embodiments of the present disclosure are respectively shown.

[0020] Figure 6 An exemplary structure of a cube in an octree structure of a G-PCC and a relationship with adjacent cubes according to some embodiments of the present disclosure are shown.

[0021] Figure 7 An exemplary one-dimensional (1D) point array representing a point cloud, a set of candidate points, and a set of predicted points according to some embodiments of the present disclosure is shown.

[0022] Figure 8 An exemplary hierarchy of parameter sets for a G-PCC according to some embodiments of the present disclosure is shown.

[0023] Fig. 9 A flowchart of an exemplary method for encoding a point cloud according to some embodiments of the present disclosure is shown.

[0024] Fig.10 A flowchart of an exemplary method for decoding a point cloud according to some embodiments of the present disclosure is shown.

[0025] Fig.11 A flowchart of another exemplary method for encoding a point cloud according to some embodiments of the present disclosure is shown.

[0026] Fig.12 A flowchart of another exemplary method for decoding a point cloud according to some embodiments of the present disclosure is shown.

[0027] Embodiments of the present disclosure will be described with reference to the accompanying drawings. DETAILED DESCRIPTION

[0028] Although some configurations and arrangements are discussed, it should be understood that this is for illustrative purposes only. Those skilled in the relevant art will recognize that other configurations and arrangements may be used without departing from the spirit and scope of the present disclosure. It is apparent to those skilled in the relevant art that the present disclosure may also be used for various other applications.

[0029] It is worth noting that references in the specification to "one embodiment", "an embodiment", "example embodiment", "some embodiments", "certain embodiments", etc. indicate that the described embodiment may include a particular feature, structure, or characteristic, but not every embodiment necessarily includes the particular feature, structure, or characteristic. Furthermore, such expressions do not necessarily refer to the same embodiment. Furthermore, when a particular feature, structure, or characteristic is described in conjunction with an embodiment, it is within the knowledge of a technician in the relevant field to implement the feature, structure, or characteristic in conjunction with other embodiments, whether or not explicitly described.

[0030] In general, terms can be understood at least in part based on the context of use. For example, the term "one or more" as used herein, which depends at least in part on the context, can be used to describe any feature, structure or characteristic in a singular sense, or can be used to describe a combination of features, structures or characteristics in a plural sense. Similarly, terms such as "one", "an" or "the" can also be understood to express singular usage or to express plural usage, which depends at least in part on the context. In addition, the term "based on" can be understood to not necessarily be intended to express a set of exclusive factors, but can allow for the presence of additional factors that are not necessarily explicitly described, again, which depends at least in part on the context.

[0031] Various aspects of the point cloud coding system will now be described with reference to various devices and methods. These devices and methods will be described in the specific embodiments below and illustrated in the accompanying drawings by various modules, components, circuits, steps, operations, processes, algorithms, etc. (collectively referred to as "elements"). These elements can be implemented using electronic hardware, firmware, computer software, or any combination thereof. Whether these elements are implemented as hardware, firmware, or software depends on the specific application and the design constraints imposed on the entire system. The techniques described herein can be used in a variety of point cloud coding applications. As described herein, point cloud coding includes encoding and decoding a point cloud.

[0032] A point cloud consists of a series of points in a 3D space. Each point in the 3D space is associated with a geometric position and associated attribute information (e.g., color, reflectivity, intensity, classification, etc.). In order to effectively compress point cloud data, the geometry of the point cloud can be compressed first, and then the corresponding attributes, including color or reflectivity, can be compressed based on the geometric information according to point cloud coding technology (e.g., G-PCC). G-PCC has been widely used in virtual reality / augmented reality (VR / AR), telecommunications, self-driving cars, etc. for entertainment and industrial applications, such as light detection and ranging (LiDAR) scanning compression for cars or robots and high-definition (HD) maps for navigation. The Moving Picture Experts Group (MPEG) released the first version of the G-PCC standard, and the Audio Video Coding Standard (AVS) is also developing the G-PCC standard.

[0033] However, the existing G-PCC standard is not well suited for various PCC inputs for many different applications. For example, in addition to the representation of levels (or coefficients in some cases), the representation of other information (e.g., parameters) for G-PCC can also be encoded in the form of syntax elements in the bitstream. Since G-PCC is organized into different levels by dividing a series of points into different fragments (e.g., sequences, slices, etc.) associated with different properties (e.g., geometry, attributes, etc.), parameter sets are also arranged at different levels (e.g., sequence level, property level, slice level, etc.) in different headers, for example. In addition, in G-PCC, multiple conditional checks may be required to parse some syntax elements, which further increases the complexity of organizing and parsing the representation of syntax elements.

[0034] In order to improve the flexibility and versatility of point cloud coding, the present disclosure provides various novel syntax element representation and organization schemes, which are compatible with any suitable G-PCC standard, including but not limited to the AVS G-PCC standard and the MPEG G-PCC standard.

[0035] Figure 1 A block diagram of an exemplary encoding system 100 according to some embodiments of the present disclosure is shown. Figure 2 A block diagram of an exemplary decoding system 200 according to some embodiments of the present disclosure is shown. Each system 100 or 200 can be applied or integrated into various systems and devices capable of data processing, such as computers and wireless communication devices. For example, system 100 or 200 can be all or part of the following items: a mobile phone, a desktop computer, a laptop computer, a tablet computer, a car computer, a game console, a printer, a positioning device, a wearable electronic device, a smart sensor, a virtual reality (VR) device, an augmented reality (AR) device, or any other suitable electronic device with data processing capabilities. Figure 1 and Figure 2 As shown, system 100 or 200 may include processor 102, memory 104, and interface 106. These components are shown as being interconnected via a bus, but other connection types are also allowed. It should be understood that system 100 or 200 may include any other suitable components for performing the functions described herein.

[0036] The processor 102 may include a microprocessor, such as a graphics processing unit (GPU), an image signal processor (ISP), a central processing unit (CPU), a digital signal processor (DSP), a tensor processing unit (TPU), a vision processing unit (VPU), a neural processing unit (NPU), a synergistic processing unit (SPU) or a physical processing unit (PPU), a microcontroller unit (MCU), an application-specific integrated circuit (ASIC), a field-programmable gate array (FPGA), a programmable logic device (PLD), a state machine, gated logic, discrete hardware circuits, and other suitable hardware configured to perform various functions described throughout the present disclosure. Although in Figure 1 and Figure 2 Only one processor is shown, but it should be understood that multiple processors may be included. Processor 102 may be a hardware device having one or more processing cores. Processor 102 may execute software. Software, whether referred to as software, firmware, middleware, microcode, hardware description language, or otherwise, should be broadly interpreted to mean: instructions, instruction sets, codes, code segments, program codes, programs, subroutines, software modules, applications, software applications, software packages, routines, subroutines, objects, executable files, execution threads, processes, functions, and the like. Software may include computer instructions written in an interpreted language, a compiled language, or machine code. Under the general category of software, other techniques for directing hardware are also permitted.

[0037] The memory 104 may broadly include memory (also known as main memory / system memory) and storage (also known as auxiliary memory). For example, the memory 104 may include random-access memory (RAM), read-only memory (ROM), static RAM (SRAM), dynamic RAM (DRAM), ferroelectric RAM (FRAM), electrically erasable programmable ROM (EEPROM), compact disc read-only memory (CD-ROM) or other optical disk storage, hard disk drive (HDD) (such as magnetic disk storage or other magnetic storage device), flash drive, solid-state drive (SSD), or any other medium that can be used to carry or store the required program code in the form of instructions that can be accessed and executed by the processor 102. In a broad sense, the memory 104 can be embodied by any computer-readable medium (such as a non-transitory computer-readable medium). Although in Figure 1 and Figure 2 Only one memory is shown, but it should be understood that multiple memories may be included.

[0038] The interface 106 may broadly include a data interface and a communication interface, wherein the communication interface is configured to receive and send signals in the process of receiving and sending information with other external network elements. For example, the interface 106 may include an input / output (I / O) device and a wired transceiver or a wireless transceiver. Figure 1 and Figure 2 Only one memory is shown, but it should be understood that multiple interfaces may be included.

[0039] The processor 102, memory 104, and interface 106 can be implemented in various forms in the system 100 or 200 for performing point cloud coding functions. In some embodiments, the processor 102, memory 104, and interface 106 of the system 100 or 200 are implemented (e.g., integrated) on one or more system-on-chips (SoCs). In one example, the processor 102, memory 104, and interface 106 can be integrated on an application processor (AP) SoC that operates application processing in an operating system (OS) environment, including running point cloud encoding and decoding applications. In another example, the processor 102, memory 104, and interface 106 can be integrated on a dedicated processor chip for point cloud coding, such as a GPU or ISP chip dedicated to graphics processing in a real-time operating system (RTOS).

[0040] like Figure 1 As shown, in the encoding system 100, the processor 102 may include one or more modules, such as an encoder 101. Figure 1 The encoder 101 is shown as being located within one processor 102, but it should be understood that the encoder 101 may include one or more submodules that may be implemented on different processors that are close to or far from each other. The encoder 101 (and any corresponding submodules or subunits) may be multiple hardware units (e.g., multiple parts of an integrated circuit) of the processor 102, which are designed to be used with other components or software units implemented by the processor 102 by executing at least a portion of a program (i.e., instructions). The instructions of the program may be stored on a computer-readable medium (e.g., a memory 104), which, when executed by the processor 102, may perform a process having one or more functions related to point cloud encoding (e.g., voxelization, transformation, quantization, arithmetic coding, etc.) as described in detail below.

[0041] Similarly, if Figure 2 As shown, in the decoding system 200, the processor 102 may include one or more modules, such as a decoder 201. Figure 2The decoder 201 is shown as being located within one processor 102, but it should be understood that the decoder 201 may include one or more submodules that may be implemented on different processors that are close to or far from each other. The decoder 201 (and any corresponding submodules or subunits) may be multiple hardware units (e.g., multiple parts of an integrated circuit) of the processor 102, which are designed to be used with other components or software units implemented by the processor 102 by executing at least a portion of a program (i.e., instructions). The instructions of the program may be stored on a computer-readable medium (e.g., memory 104), which, when executed by the processor 102, may perform a process having one or more functions related to point cloud decoding (e.g., arithmetic decoding, inverse quantization, inverse transformation, reconstruction, synthesis) as described in detail below.

[0042] Figure 3 According to some embodiments of the present disclosure Figure 1 Detailed block diagram of an exemplary encoder 101 in the encoding system 100 in FIG. Figure 3 As shown, the encoder 101 may include a coordinate transformation module 302, a voxelization module 304, a geometry analysis module 306, and an arithmetic coding module 308, which are configured together to encode positions associated with points of a point cloud into a geometry bitstream (ie, geometry encoding). Figure 3 As shown, the encoder 101 may further include a color transformation module 310, an attribute transformation module 312, a quantization module 314, and an arithmetic coding module 316, which are configured together to encode the attributes associated with the points of the point cloud into an attribute bitstream (ie, attribute encoding). It should be understood that Figure 3 Each of the multiple elements shown in is shown independently to represent the characteristic functions that are different from each other in the point cloud encoder, and this does not mean that the various components are formed by separate hardware or single software configuration units. That is, for ease of explanation, each element is included to be listed as an element, and at least two of these elements can be combined to form a single element, or an element can be divided into multiple elements to perform a function. It should also be understood that some of these elements are not necessary elements for performing the functions described in the present disclosure, but may be optional elements for improving performance. It should also be understood that these elements can be implemented using electronic hardware, firmware, computer software, or any combination thereof. Whether these elements are implemented as hardware, firmware, or software depends on the specific application and the design constraints imposed on the encoder 101. It should also be understood that, Figure 3 The modules shown in are for illustration purposes only, and in some examples, the encoder 101 may include different modules for point cloud encoding.

[0043] like Figure 3As shown, the geometric positions and attributes associated with a point can be encoded separately. A point cloud can be a series of points with the following positions and attributes: Position X k =(x k ,y k ,z k ), k = 1, ..., K, where K is the number of points in the point cloud; attribute A k =(A 1k ,A 2k ,…,A Dk ), k=1,…,K, where D is the number of attributes for each point. In some embodiments, the attribute encoding depends on the decoded geometry. Therefore, the point cloud position can be encoded first. Since the geometric position can be represented by a floating point number in the original coordinate system, the coordinate transformation module 302 and the voxelization module 304 can be configured to perform a coordinate transformation, and then voxelize, voxelize quantize and delete duplicate points. The process of position quantization, duplicate point deletion and assigning attributes to the remaining points is called voxelization. The voxelized point cloud can be represented in a lossless manner using, for example, an octree structure. The geometric analysis module 306 can be configured to perform geometric analysis using, for example, an octree or a trisoup scheme. The arithmetic coding module 308 can be configured to arithmetically encode the resulting structure from the geometric analysis module 306 into a geometric bitstream.

[0044] In some embodiments, the geometry analysis module 306 is configured to perform geometry analysis using an octree scheme. Under the octree scheme, the cube axis-aligned bounding box B can be composed of two extreme points (0, 0, 0) and (2 d ,2 d ,2 d ) definition, where d is the maximum size of a given point cloud along the x, y or z direction. All point cloud points can be included in this defined cube. Figure 5A As shown in , a cube can be divided into eight sub-cubes (which results in an octree structure that allows a parent cube to have eight sub-cubes), and then the octree structure can be constructed by recursively subdividing the sub-cubes. Figure 5BAs shown, an 8-bit code can be generated by associating a 1-bit value with each sub-cube to indicate whether it contains a point (i.e., full and has a value of 1) or does not contain a point (i.e., empty and has a value of 0). Only full sub-cubes (i.e., non-voxels) with a size greater than 1 can be further subdivided. The geometric information (x, y, z) of a location can be represented using this defined octree structure. Since points may be repeated, multiple points may be mapped to the same sub-cube of size 1 (i.e., the same voxel). To handle this situation, the number of points in each sub-cube of size 1 is also arithmetically encoded. By constructing the octree, the current cube associated with the current node can be surrounded by six cubes of the same depth that share a face with it. As shown Figure 6 As shown, depending on the position of the current cube, a cube may have up to six cubes of the same size sharing a face. In addition, the current cube may also have some adjacent cubes that share lines or points with the current cube.

[0045] Return to reference Figure 3 Regarding attribute encoding, optionally, if the attribute includes color, the color conversion module 310 can be configured to convert the red / green / blue (RGB) color attribute of each point into a YCbCr color attribute. The attribute conversion module 312 can be configured to perform attribute conversion based on the result from the geometric analysis module 306 (e.g., using an octree scheme), and the attribute conversion includes but is not limited to a region adaptive hierarchical transform (RAHT), a hierarchical nearest neighbor prediction based on interpolation (prediction transform), and a hierarchical nearest neighbor prediction based on interpolation (lifting transform) with an update / lifting step. Optionally, the quantization module 314 can be configured to quantize the transformed attribute coefficients from the attribute conversion module 312 to generate a quantization level of the attribute associated with each point, thereby reducing the dynamic range. The arithmetic coding module 316 can be configured to arithmetic encode the obtained transformed attribute coefficients or the quantization level of the attribute associated with each point into the attribute bitstream.

[0046] In some embodiments, for example, when the attribute transformation module 312 performs the prediction transformation and the lifting transformation, a prediction may be formed based on the adjacent encoded attributes. Then, the difference between the current attribute and the prediction may be encoded. According to some aspects of the present disclosure, in the AVS G-PCC standard, after encoding the geometric position, a point cloud (e.g., a point cloud cube) in a 3D space may be converted into a 1D array using a Morton code or a Hilbert code, such as Figure 7As shown. Each position in the cube will have a corresponding Morton code or Hilbert code, but some positions may not have any corresponding point cloud attributes. In other words, some positions may be empty. Attribute encoding can follow a predefined Morton order or Hilbert order. Predictors can be generated from previously encoded points in a 1D array in accordance with the Morton order or the Hilbert order. The attribute difference between the current point and its predicted point can be encoded into the bitstream. In some embodiments, a point cloud in 3D space (e.g., a point cloud cube) is converted to a 1D array in its original input order (e.g., the order in which the point cloud data is collected) rather than in any predefined order. That is, in some examples, attribute encoding can follow the original input order of the point cloud, rather than the predefined Morton order or Hilbert order. In other words, the order followed by the points in the 1D array can be either the Morton order, the Hilbert order, or the original input order.

[0047] like Figure 7 As shown, in order to reduce memory usage, some predefined numbers can be specified to limit the number of neighboring points that can be used to generate predictions. For example, at most only M points out of the previously at most N consecutively encoded points can be used to encode the current attribute. That is, in attribute encoding, a group of n candidate points can be used as candidates to select a group of m prediction points (m≤n) to predict the current point. The number of candidate points n in a group is equal to or less than the maximum number of candidate points N (n≤N), and the number of prediction points m in a group is equal to or less than the maximum number of prediction points M (m≤M). As Figure 7 As shown, if the number of neighboring points before the current point in the 1D array following the Morton order, Hilbert order or the original input order is greater than the maximum number of candidate points N, then the number of candidate points n in a set of candidate points for the current point (grey shading) is equal to the maximum number N; if the number of neighboring points before the current point in the 1D array following the Morton order, Hilbert order or the original input order is greater than or equal to the maximum number of candidate points N, then the number of candidate points n in a set of candidate points for the current point (grey shading) is less than the maximum number of candidate points N, then all neighboring points before the current point are used as the set of candidate points for the current point. Figure 7 , the maximum number of prediction points M is set to 3, and a set of 3 prediction points ( P , bold and underlined).

[0048] In some embodiments, M and N are set to fixed numbers 3 and 128, respectively. If more than 128 points have been encoded before the current point, only 3 neighboring points of the previous 128 neighboring points can be used to form an attribute predictor (prediction point) according to a predefined order. If there are less than 128 encoded points before the current point, all encoded points before the current point will be used as candidate points to find the prediction point. Among the previous up to 128 candidate points, at most 3 prediction points are selected, and these 3 prediction points have the closest "distance" (e.g., Euclidean distance) between these candidate points and the current point. As an example, the Euclidean distance d can be defined as follows, and other distance metrics can also be used in other examples:

[0049] d=|x1-x2|+|y1-y2|+|z1-z2| (1),

[0050] Where (x1, y1, z1) and (x2, y2, z2) are the coordinates of the current point and the candidate point along the Morton order, Hilbert order, or the original input order, respectively. According to some embodiments, once m prediction points are selected (e.g., the 3 nearest candidate points), the weighted attribute average from these m points can be formed as a predictor to encode the attributes of the current point. It should be understood that in some examples, the prediction point can be selected from candidate points in a cube that shares the same face / line / point as the current point cloud.

[0051] Since a set of n candidate points needs to be stored in memory and traversed to select a set of m prediction points to encode the attributes associated with the current position, a maximum number of candidate points M is introduced to limit the memory size and computing resources that may be occupied by candidate point storage and search.

[0052] According to some aspects of the present disclosure, the difference in property values ​​between the current point and its predictor may be referred to as a "residual". Depending on the application, the PCC may be either lossless or lossy. Therefore, the residual may or may not be further transformed, and the residual may or may not be quantized using a predefined quantization process. According to the present disclosure, the unquantized or quantized residual may be referred to as a "level", which is a signed integer (e.g., a positive integer value or a negative integer value) encoded into the bitstream.

[0053] Each point has three color attributes, which come from the three color components. If the levels of all three color components are zero, the point is called a zero-level point. Otherwise, if at least one of the color components of the point has a non-zero level, the point is called a non-zero-level point. The number of consecutive zero-level points is called the "zero run length". The zero run length value and level of the non-zero level point are encoded into the bitstream. More specifically, before encoding the first point, the encoder 101 can set the zero run length counter to zero.

[0054] Starting from the first point along the predefined coding order, the residuals between the three color predictors of the current point and their corresponding color attributes can be obtained. Then, the corresponding levels of the three components of the current point can also be obtained. If the current point is a zero level point, the encoder 101 can increase the zero run length value by one, and the process continues to the next point. If the current point is a non-zero level point, the zero run length value will be encoded first, and then the three color levels of the non-zero level point will be encoded. After the non-zero level point is level-encoded, the zero run length value is reset to zero, and the process continues to the next point until all points are completed. On the decoding side, the decoder 201 can decode the zero run length value and set the three color levels corresponding to the number of zero run length points to zero. Then, the level of the non-zero level point is decoded, and then the next zero run length value is decoded. The process continues until all points are decoded. Table 1 and Table 2 show example syntax elements for color residual encoding and color level encoding, respectively.

[0055]

[0056]

[0057] Table 1: Syntax elements for color residual coding

[0058]

[0059] Table 2: Color-coded syntax elements

[0060] For non-zero level points, at least one of the three components has a non-zero level. The values ​​of the three color components are encoded in the color_residual_coding() syntax element. Several one-bit flags plus the remainder of the absolute level can be encoded to represent the levels of the three color components. The absolute level or the absolute level minus one of the color residual can be encoded in the coded_level_coding() function, which is also referred to as the "coded level" hereinafter.

[0061] According to some aspects of the present disclosure, a first flag (color_first_comp_zero) is encoded to indicate whether the first component of the color is zero; if the first color component is zero, a second flag (color_second_comp_zero) is encoded to indicate whether the second color component of the color is zero; if the second component of the color is zero, the absolute level minus one and the sign of the third component are encoded according to the following encoding level technique.

[0062] For example, a first flag is encoded to indicate whether the first color component of the color is zero; if the first color component is zero, a second flag can be encoded to indicate whether the second color component is zero; if the second color component is not zero, the absolute level minus one and sign of the second color component, and the absolute level and sign of the third color component will be encoded according to the following encoding level technique.

[0063] According to another aspect of the present disclosure, a first flag can be encoded to indicate whether the first component of the color is zero; if the first color component is not zero, the absolute level minus one and sign of the first color component, the absolute level and sign of the second color component, and the absolute level and sign of the third color component will be encoded according to the following encoding level technology.

[0064] For example, a first flag (coded_level_equal_zero) is encoded to indicate whether the coded level is zero; if the coded level is the absolute level of a color component minus one, that is, for example, when the isComponentNoneZero flag is set to "true", the sign of the level of the color component (coded_level_sign) is encoded. On the other hand, if the first flag indicates that the coded level is not zero, and if the coded level is the absolute level of a color component, for example, when the isComponentNoneZero flag is set to "false", the sign of the level of the color component is encoded. A second flag (coded_level_gt1) is encoded to indicate whether the coded level is greater than one; if the coded level is greater than one, the parity of the coded level minus two is encoded, and a third flag (coded_level_minus2_div2_gt0) is encoded to indicate whether the coded level minus two divided by two is greater than zero; if the coded level minus two divided by two is greater than zero, the coded level minus two divided by two minus one is encoded.

[0065] Referring to Tables 1 and 2, a color_first_comp_zero value equal to 0 specifies that the absolute coded level of the first component of the color is non-zero. A color_first_comp_zero value equal to 1 specifies that the absolute coded level of the first component is zero.

[0066] A color_second_comp_zero value equal to 0 specifies that the absolute coded level of the second component of the color is non-zero. A color_second_comp_zero value equal to 1 specifies that the absolute coded level of the second component is zero.

[0067] A coded_level_equal_zero value equal to 0 specifies that the absolute coded level of this component is not zero. A coded_level_equal_zero value equal to 1 specifies that the absolute coded level of this component is zero.

[0068] A coded_level_gt1 value equal to 0 specifies that the coding level of the component is one. A coded_level_gt1 value equal to 1 specifies that the coding level of the component is greater than one. When a coded_level_gt1 value is not included in the bitstream, the decoder 201 may infer that the coded_level_gt1 value is equal to zero.

[0069] coded_level_minus2_parity specifies the parity of the coded level minus two of the current color component. A coded_level_minus2_parity value equal to 0 specifies that the current coded level minus two is an even number. A coded_level_minus2_parity value equal to 1 specifies that the current coded level minus two is an odd number. When a coded_level_minus2_parity value is not present in the bitstream, the decoder 201 may infer that the coded_level_minus2_parity value is equal to 0.

[0070] A coded_level_minus2_div2_gt0 value equal to 0 specifies that the coded level minus two divided by two is zero. A coded_level_minus2_div2_gt0 value equal to 1 specifies that the coded level minus two divided by two is greater than zero. When a coded_level_minus2_div2_gt0 value is not present in the bitstream, the decoder 201 may infer that the coded_level_minus2_div2_gt0 value is equal to zero.

[0071] The coded_level_minu2_div2_minus1 syntax element specifies the value of the coded level minus two divided by two minus 1. When the coded_level_minu2_div2_minus1 syntax element is not present in the bitstream, the decoder 201 may infer that the coded_level_minu2_div2_minus1 syntax element is equal to zero.

[0072] coded_level and coded_level_sign are the return values ​​of the function coded_level_coding(isComponentminusOne), which represent the coded level. The coded level may include the absolute level of the color residual or the absolute level of the color residual minus one, and the sign of the non-zero color residual, as shown below according to expression (2).

[0073] coded_level=(2*coded_level_sign-1)*(coded_level_equal_zero?0:1+(coded_level_gt1+coded_level_minus2_parity+(coded_level_minus2_div2_gt0+coded_level_minu2_div2_minus1)<<1) (2).

[0074] The residual levels of the three color components (eg, color_component[idx], where idx is an index from 0 to 2) are calculated according to color_residual_coding().

[0075] In addition, the zero run length of the reflectivity level and the non-zero reflectivity level can be encoded into the bitstream. More specifically, before encoding the first point, the encoder 101 can set the zero run length counter to zero. Starting from the first point, along the predefined coding order, the residual between the predictor and the corresponding original point is obtained. Then, the corresponding reflectivity level can be obtained. If the current reflectivity level is zero, the encoder 101 increases the value of the zero run length counter by one, and the process continues to the next point. If the reflectivity level is not zero, the encoder 101 can encode the zero run length, and then encode the non-zero reflectivity level. After encoding the non-zero reflectivity level, the encoder 101 can reset the zero run length counter to zero, and the process continues to the next point. On the decoding side, the decoder 201 can decode the zero run length and set the reflectivity level corresponding to the number of zero run length points to zero. Then, the decoder 201 can decode the non-zero reflectivity level, and then decode the next zero run length. This process can continue until all points are decoded.

[0076] For non-zero reflectivity level, if the current point is not a repeated point, the sign of the reflectivity level is encoded using the "residual_sign" syntax element.The encoder 101 may then encode an "abs_level_minus1_parity" syntax element indicating the parity of the absolute level minus one. Another syntax element "abs_level_minus1_div2_gt0" can be encoded to indicate whether the value of the absolute level minus one divided by two is greater than zero; if abs_level_minus1_div2_gt0 is greater than zero, the encoder 101 can encode the "abs_level_minus1_div2_gt1" syntax element to indicate whether the value of the absolute level minus one divided by two is greater than one; if the abs_level_minus1_div2_gt1 syntax element is greater than 1, the encoder 101 can encode the "abs_level_minu1_div2_minus2" syntax element to indicate the value of the absolute level minus one divided by two minus two.

[0077] Table 3 shown below shows an example of reflectivity level coding syntax elements.

[0078]

[0079] Table 3: Syntax elements for reflectivity level coding

[0080] Referring to Table 3, the abs_level_minus1_parity syntax element specifies the parity of the absolute reflectivity level minus one. An abs_level_minus1_parity value equal to 0 may indicate that the absolute reflectivity level minus one is an even number; on the other hand, an abs_level_minus1_parity value equal to 1 may indicate that the absolute reflectivity level minus one is an odd number.

[0081] The abs_level_minus1_div2_gt0 value equal to 0 may indicate that the value of the absolute reflectivity level minus one divided by two is zero. The abs_level_minus1_div2_gt0 value equal to 1 may indicate that the value of the absolute reflectivity level minus one divided by two is greater than zero. When there is no abs_level_minus1_div2_got0 value, the decoder 201 may infer that the abs_level_minus1_div2_got0 value is equal to 0.

[0082] An abs_level_minus1_div2_gt1 value equal to 0 may indicate that the value of the absolute reflectivity level minus one divided by two is one. An abs_level_minus1_div2_gt1 value equal to 1 may indicate that the value of the absolute reflectivity level minus one divided by two is greater than one. When the value of abs_level_minus1_div2_gt1 is not present in the bitstream, the decoder 201 may infer that the value of abs_level_minus1_div2_gt1 is equal to 0.

[0083] The abs_level_minu1_div2_minus2 syntax value may indicate a value of the absolute reflectivity level minus one divided by two minus two. When the value of abs_level_minu1_div2_minus2 is not present, the decoder 201 may infer that the value of abs_level_minu1_div2_minus2 is equal to zero.

[0084] A residual_sign value equal to 0 may indicate that the sign of the reflectivity level is negative; on the other hand, a residual_sign value equal to 1 may indicate that the sign of the reflectivity level is positive. When there is no residual_sign value in the bitstream, the decoder 201 may infer that the residual_sign value is equal to 1. The reflectivity may be calculated according to expression (3).

[0085] Reflectance=(2*residual_sign-1)*(1+abs_level_minus1_parity+(abs_level_minus1_div2_gt0+abs_level_minus1_div2_gt1+abs_level_minu1_div2_minus2)<<1)(3).

[0086] Furthermore, the encoder 101 may encode the value of the zero run length into the bitstream. For example, the encoder 101 may encode a first syntax element zero_run_length_level_equal_zero (e.g., a first syntax element) into the bitstream to indicate whether the zero run length is equal to zero; if it is not zero, the encoder 101 may encode a zero_run_length_level_equal_one syntax element (e.g., a second syntax element) to indicate whether the zero run length is equal to one; if it is not one, the encoder 101 may encode a zero_run_length_level_equal_two syntax element (e.g., a third syntax element) into the bitstream to indicate whether the zero run length is equal to two; if it is not two, the encoder 101 may encode a zero_run_length_level_minus3_parity syntax element (e.g., a fourth syntax element) and a zero_run_length_level_minus3_div2 syntax element (e.g., a fifth syntax element) into the bitstream to indicate the parity of the zero run length minus three and the value of the zero run length minus three divided by two, respectively. Examples of syntax elements for zero run length coding are provided in Table 4 below.

[0087]

[0088] Table 4: Zero run length syntax elements

[0089] Referring to Table 4, zero_run_length_level_minus3_parity specifies the parity of the zero run length level minus three. zero_run_length_level_minus3_parity equal to 0 specifies that the zero run length level minus three is an even number. zero_run_length_level_minus3_parity equal to 1 specifies that the zero run length level minus three is an odd number. When a value for zero_run_length_level_minus3_parity is not present, the value of zero_run_length_level_minus3_parity is inferred to be equal to 0.

[0090] A zero_run_length_level_equal_zero value equal to 0 may indicate that the zero run length level is not zero; on the other hand, a zero_run_length_level_equal_zero value equal to 1 specifies that the zero run length level is zero.

[0091] A zero_run_length_level_equal_one value equal to 0 may indicate that the zero run length level is not one; on the other hand, a zero_run_length_level_equal_one value equal to 1 specifies that the zero run length level is one.

[0092] A zero_run_length_level_equal_two value equal to 0 may indicate that the zero run length level is not two; on the other hand, a zero_run_length_level_equal_two value equal to 1 may indicate that the zero run length level is two.

[0093] The zero_run_length_level_minus3_div2 syntax element may indicate the value of the zero run length level minus three divided by two. When the value of the zero_run_length_level_minus3_div2 syntax element is not present in the bitstream, the decoder 201 may infer that the value of the zero_run_length_level_minus3_div2 syntax element is equal to 0. The variable zero_run_length_level may be calculated according to expression (4).

[0094] zero_run_length_level=zero_run_length_level_equal_zero? 0:(zero_run_length_level_equal_one? 1:(zero_run_length_level_equal_two? 2:(3+zero_run_length_level_minus3_parity+(zero_run_length_level_minus3_div2<<1)))) (4).

[0095] The value of zero_run_length can be calculated according to expression (5).

[0096] zero_run_length=useGolomb? (2*zero_run_lenght_level+zero_run_length_LSB):zero_run_length_level (5).

[0097] Figure 4 According to some embodiments of the present disclosure Figure 2 Detailed block diagram of an exemplary decoder 201 in the decoding system 200 in FIG. Figure 4 As shown, the decoder 201 may include an arithmetic decoding module 402, a geometry synthesis module 404, a reconstruction module 406, and an inverse coordinate transformation module 408, which together are configured to decode the positions associated with the points of the point cloud from the geometry bitstream (ie, geometry decoding). Figure 4 As shown, the decoder 201 may further include an arithmetic decoding module 410, an inverse quantization module 412, an attribute inverse transform module 414, and a color inverse transform module 416, which are together configured to decode the attributes associated with the points of the point cloud from the attribute bitstream (i.e., attribute decoding). It should be understood that Figure 4 Each of the multiple elements shown in is shown independently to represent the characteristic functions that are different from each other in the point cloud decoder, and this does not mean that the various components are formed by separate hardware or single software configuration units. That is, for ease of explanation, each element is included to be listed as an element, and at least two of these elements can be combined to form a single element, or an element can be divided into multiple elements to perform a function. It should also be understood that some of these elements are not necessary elements for performing the functions described in the present disclosure, but may be optional elements for improving performance. It should also be understood that these elements can be implemented using electronic hardware, firmware, computer software, or any combination thereof. Whether these elements are implemented as hardware, firmware, or software depends on the specific application and the design constraints imposed on the decoder 201. It should also be understood that, Figure 4 The modules shown in are for illustration purposes only, and in some examples, the decoder 201 may include different modules for point cloud decoding.

[0098] When a point cloud bitstream (e.g., a geometry bitstream or an attribute bitstream) is input from a point cloud encoder (e.g., encoder 101), the decoder 201 may decode the input bitstream in the opposite process of the point cloud encoder. Therefore, for ease of description, the decoding details described above regarding the encoding may be omitted. The arithmetic decoding modules 402 and 410 may be configured to decode the geometry bitstream and the attribute bitstream, respectively, to obtain various information encoded into the bitstream. For example, the arithmetic decoding module 410 may decode the attribute bitstream to obtain attribute information associated with each point, such as a quantization level or coefficient of an attribute associated with each point. Optionally, the dequantization module 412 may be configured to dequantize the quantization level of the attribute associated with each point to obtain the coefficient of the attribute associated with each point. In addition to the attribute information, the arithmetic decoding module 410 may also parse the bitstream to obtain various other information (e.g., in the form of syntax elements), such as syntax elements indicating the order followed by the points in the 1D array of attribute encoding.

[0099] The inverse attribute transform module 414 may be configured to perform an inverse attribute transform (e.g., inverse RAHT, inverse prediction transform, or inverse lifting transform) to transform data from a transform domain (e.g., coefficients) back to an attribute domain (e.g., luminance and / or chrominance information of a color attribute). Optionally, the color inverse transform module 416 may be configured to convert a YCbCr color attribute to an RGB color attribute.

[0100] For geometry decoding, the geometry synthesis module 404 , the reconstruction module 406 , and the coordinate inverse transformation module 408 of the decoder 201 may be configured to perform inverse operations of the geometry analysis module 306 , the voxelization module 304 , and the coordinate transformation module 302 of the encoder 101 , respectively.

[0101] Consistent with the scope of the present disclosure, the encoder 101 and the decoder 201 may be configured to adopt various novel syntax element representation and organization schemes disclosed herein to improve the flexibility and versatility of point cloud coding.

[0102] According to some aspects of the present disclosure, various attribute presence syntax elements are introduced at different levels to control the enabling / disabling of all attributes or individual attributes in point cloud encoding. In some embodiments, different parameters under the same condition check at the same level (e.g., associated with the same attribute) can be grouped together to reduce the number of condition checks, thereby further simplifying the scheme. Figure 8 An exemplary hierarchy of parameter sets for G-PCC according to some embodiments of the present disclosure is shown. A point cloud can be represented by a 1D array comprising a set of points, each of which is associated with a property such as a geometric shape and an attribute (e.g., color and reflectivity). A set of points associated with different timestamps can be considered a "sequence".

[0103] like Figure 8 As shown, the syntax elements (e.g., parameters, flags, etc.) used to encode the header of the point cloud can be organized in a hierarchy with various levels. At the top level, the hierarchy can include a sequence header, for example, a header of a sequence parameter set (SPS) associated with a sequence representing the point cloud. At the second level, the hierarchy can include one or more property headers belonging to the sequence header, such as a geometry parameter header and one or more attribute parameter headers. In some embodiments, the geometry parameter header and the attribute parameter header can also be at the same level as the SPS. For example, as Figure 8 As shown, the next level under the SPS may include a header for a geometry parameter set belonging to the SPS and associated with a geometric shape, and one or more headers (1 to n) for an attribute parameter set belonging to the SPS and each associated with a corresponding attribute (e.g., color or reflectivity). At the third level, the hierarchy may include one or more slice property headers belonging to each property header, such as a slice geometry parameter header and a slice attribute parameter header. That is, a sequence representing a point cloud may be divided into one or more slices, each slice comprising a point slice, and each point slice may be associated with one or more slice property headers. For example, as Figure 8 As shown, the next level under the geometry parameter set may include one or more slice geometry parameter set headers, each belonging to the set parameter set and associated with the corresponding point slice. Similarly, the next level under each attribute parameter set may include one or more slice attribute parameter set headers, each belonging to the corresponding attribute parameter set and associated with the corresponding point slice. It should be understood that in some examples, the hierarchy may include fewer or more levels, such as one or more picture / frame levels.

[0104] As mentioned before, to reduce memory usage, one can specify a predefined number to limit the number of neighbors that can be used to generate predictions, such as Figure 7 As shown. For prediction, one or more previously encoded neighboring points can be used to predict the current point. After encoding the neighboring points, the attribute information (e.g., color values, reflectivity values, depth values, etc.) can be maintained in data buffers (e.g., storage bins) of the encoder 101 and the decoder 201. One or more compressed attribute information values ​​(e.g., color values, reflectivity values, depth values, etc.) are stored in the data buffer and used for prediction of other points. One or more compressed attribute information values ​​may be referred to as "transform coefficients". In order to limit the size of the data buffer used to maintain one or more attribute information values ​​used for prediction, the present disclosure limits the maximum number of transform coefficients stored for prediction (maxNumofCoeff).

[0105] According to some aspects consistent with the present disclosure, maxNumofCoeff may be specified to control the maximum buffer size and constrain the maximum number of transform coefficients stored in the buffer for prediction. In addition, another parameter coeffLengthControl is specified to limit the maximum allowed delay, which is defined as maxNumofCoeff*coeffLengthControl. Both parameters are encoded with ue(v), which is the 0th order exponential-Golomb (EG) code specified in Table 5 for encoding a given integer v, where x0, x1, ..., xn are binary numbers.

[0106]

[0107] Table 5: k-order EG

[0108] Typically, maxNumofCoeff is a quadratic of an unconstrained integer. Therefore, using the prior art, an unexpected amount of memory may be occupied to maintain the transform coefficients used for prediction. In order to limit the amount of memory storage used for attribute information value storage, the encoder 101 can encode maxNumofCoeff using a logarithmic format instead of directly encoding its decimal value. More specifically, log2maxNumofCoeffMinusX can be encoded in the bitstream in ue(v) format, where X is an integer. maxNumofCoeff can be calculated as follows: maxNumofCoeff=1<<(log2maxNumofCoeffMinusX+X). Accordingly, the decoder 201 can calculate maxNumofCoeff by decoding maxNumofCoeffMinusX based on a logarithmic format. For example, if maxNumofCoeff is equal to Y, the decoder 201 can calculate Y=<<(log2YmaxNumofCoeffMinusX+X).

[0109] When X is 8, log2maxNumofCoeffMinus8 will be encoded, and the encoder 101 and the decoder 201 can calculate maxNumofCoeff as follows: maxNumofCoeff=1<<(log2maxNumofCoeffMinus8+8). To this end, the present disclosure proposes an exemplary log2maxNumofCoeffMinusX syntax element, which is decoded from the bitstream by the decoder 201. As an example and not a limitation, X can be an integer between 0 and 16. An exemplary syntax change to the attribute header is shown below in Table 6.

[0110]

[0111] Table 6: Syntax changes to the Attributes header

[0112] By encoding the maximum number of transform coefficients (e.g., maxNumofCoeffMinusX) with log2, the number of bits used to transmit this information to the decoder 201 can be significantly reduced compared to the prior art. Once the maxNumofCoff is determined, the decoder 201 can decode the bitstream to generate an enhanced image, frame, and / or video.

[0113] As described above, the attribute residual can be binarized in a format where a zero run length is followed by a non-zero residual value. For example, the encoder 101 can encode the zero run length and the non-zero residual value into the bitstream using context-adaptive binary arithmetic coding (CABAC). After quantization, the attribute information value can be zero. If the current point is zero, the next point can also be zero, and so on. According to some aspects consistent with the present disclosure, instead of encoding multiple zeros, the encoder 101 can use zero run length encoding to compress the point cloud to represent multiple consecutive zeros in the zero run length, rather than encoding multiple consecutive zero points. In some embodiments, the value of the zero run length can be limited so that it is friendly to hardware implementation.

[0114] The zero run length encoding has two branches depending on whether the k-order EG codeword is less than a predefined threshold. The value of the zero run length represented by one branch (e.g., the first branch) can be half of the value represented by the other branch (e.g., the second branch). The zero run length of the first branch can be encoded using the following exemplary technique.

[0115] For example, the first binary bit (bin) is encoded to indicate whether the value of zero run length is zero; if it is not zero, the second binary bit is encoded to indicate whether the value of zero run length is one; if it is not one, the third binary bit is encoded to indicate whether the value of zero run length is two; if it is not two, the parity flag is encoded to indicate whether the value of zero run length minus three is odd or even.

[0116] After these four flags, a residual value representing the value of (zero run length - 3) / 2 may be encoded. This residual value may be encoded using a second-order EG codeword. If the maximum number of binary bits supported by the hardware (e.g., at encoder 101 and / or decoder 201) is N, the maximum value of the second-order EG codeword may be represented as 1<<((N-1)>>1+1). For example, if N is 32, the maximum value of the residual value will be 1<<((32-1)>>1+1), which is equal to 65536.

[0117] Because the value of zero run length is encoded with a parity value, the maximum value represented may be 131075, which is 65536*2+3. Therefore, the present disclosure proposes that for the first branch and the second branch of AVS-GPCC, the maximum value of zero run length (maximum_zero_run_length) may be set to 131075 and 262150, respectively.

[0118] Alternatively, the maximum allowed zero run length value can be set to any value less than 131075, for example, for the first branch, it is set to 131072. The maximum allowed zero run length of the second branch is twice the maximum allowed for the first branch. For example, the maximum value can be set to a fixed number, or encoded in the bitstream, either in the SPS or in the attribute header. Additionally and / or alternatively, the maximum allowed zero run length can be set to 131072 for all cases.

[0119] For transform-based GPCC coding, there may be two parameters, such as maxNumofCoeff and coeffLengthControl, which are used to control the maximum delay. The maximum delay (Nc) is defined as follows: Nc = maxNumofCoeff * coeffLengthControl. The maximum delay also enforces the maximum zero run length value allowed for such an application. Therefore, the present disclosure proposes that the allowed Nc can be less than the allowed maximum_zero_run_length.

[0120] In addition, according to the value of the zero run length, the encoding of the zero run length can be achieved by calling the zero_run_length_code(useGolomb) syntax element multiple times. If the return value of zero_run_length_code(useGolomb) is equal to the maximum value allowed, zero_run_length_code(useGolomb) can be encoded again until the return value of zero_run_length_code(useGolomb) is less than the maximum value allowed. The modified syntax table is shown in Table 7.

[0121]

[0122] Table 8: Syntax elements for residual_zero_run_length coding

[0123] residual_zero_run_length is the zero run length of the attribute encoding, zero_run_length is the return value of the function zero_run_length_code(useGolomb), and if maxNumofCoeff and coeffLengthControl are not present in the bitstream, the MAXIMUM_VALUE of the first and second branches in zero_run_length_code(useGolomb) is 131075 and 262150, respectively, or the MAXIMUM_VALUE is simply set to 131072. If maxNumofCoeff and coeffLengthControl are present in the bitstream, the MAXIMUM_VALUE is equal to Nc. As an example and not limitation, assuming that the MAXIMUM_VALUE of the zero run length is 131072, the zero run length is 655360. When this occurs, the zero run length is encoded five times separately (e.g., a multi-loop process) using the syntax elements of Table 8 to indicate that the zero run length is 655360.

[0124] Fig. 9 Flowchart of an exemplary method 900 for point cloud encoding according to some embodiments of the present disclosure is shown. The method 900 may be performed by the encoder 101 of the encoding system 100 or any other suitable point cloud encoding system. As described below, the method 900 may include operations 902 to 912. It should be understood that some of these operations may be optional, and some of these operations may be performed simultaneously or in conjunction with Fig. 9 The order shown is different from the order in which it is executed.

[0125] At 902, the encoder may determine a maximum number of transform coefficients for predicting attribute values ​​of points in a set of points. For example, in order to limit the amount of memory storage used for attribute information value storage, the encoder 101 may encode maxNumofCoeff in a logarithmic format instead of directly encoding its decimal value. More specifically, log2maxNumofCoeffMinusX may be encoded in the bitstream in the ue(v) format, where X is an integer. maxNumofCoeff may be calculated as follows: maxNumofCoeff=1<<(log2maxNumofCoeffMinusX+X). Accordingly, the decoder 201 may calculate maxNumofCoeff by decoding maxNumofCoeffMinusX based on a logarithmic format. For example, when X is 8, log2maxNumofCoeffMinus8 will be encoded, and the encoder 101 and the decoder 201 may calculate maxNumofCoeff as follows: maxNumofCoeff=1<<(log2maxNumofCoeffMinus8+8). To this end, the present disclosure proposes an exemplary log2maxNumofCoeffMinusX syntax element, which is decoded from the bitstream by the decoder 201. As an example and not a limitation, X may be an integer between 0 and 16. An exemplary syntax change to the attribute header is shown above in Table 6.

[0126] At 904, the encoder may encode the bitstream to indicate the maximum number of transform coefficients based on a logarithmic format. For example, once the maxNumofCoff is determined, the encoder 101 may encode the bitstream to generate an enhanced image, frame, and / or video.

[0127] At 906, the encoder may obtain a plurality of transform coefficients associated with neighboring points in the point cloud. For example, to reduce memory usage, a predefined number may be specified to limit the number of neighboring points that may be used to generate a prediction, such as Figure 7As shown. For prediction, one or more previously encoded adjacent points can be used to predict the current point. After obtaining the adjacent points from the bitstream, the attribute information (e.g., color value, reflectivity value, depth value, etc.) can be maintained in a data buffer (e.g., storage bin) of the encoder 101 and the decoder 201. The compressed one or more attribute information values ​​(e.g., color value, reflectivity value, depth value, etc.) are stored in the data buffer and used for prediction of other points. The compressed one or more attribute information values ​​may be referred to as "transform coefficients". In order to limit the size of the data buffer used to maintain one or more attribute information values ​​used for prediction, the present disclosure limits the maximum number of transform coefficients stored for prediction (maxNumofCoeff).

[0128] At 908, the encoder may determine a maximum buffer size based on the maximum number of transform coefficients. For example, the maximum buffer size may be determined based on the maximum number of transform coefficients (eg, one buffer bin per transform coefficient).

[0129] At 910, the encoder may maintain each transform coefficient of the plurality of transform coefficients in a buffer equal to the maximum buffer size. For example, each transform coefficient may be maintained in a different buffer bin.

[0130] At 912, the encoder may predict the property value of the point based on the plurality of transform coefficients. For example, the prediction of the property value of the point may be determined based on the transform coefficients maintained in a buffer.

[0131] Fig.10 1 is a flow chart showing an exemplary method 1000 for point cloud decoding according to some embodiments of the present disclosure. The method 1000 may be performed by the decoder 201 of the decoding system 200 or any other suitable point cloud encoding system. The method 1000 may include operations 1002 to 1012 as described below. It should be understood that some of these operations may be optional, and some of these operations may be performed simultaneously or in conjunction with each other. Fig.10 The order shown is different from the order in which it is executed.

[0132] At 1002, the decoder may determine a maximum number of transform coefficients for predicting an attribute value of a point in a set of points. For example, in order to limit the size of a data buffer for maintaining one or more attribute information values ​​for prediction, the present disclosure limits the maximum number of transform coefficients stored for prediction (maxNumofCoeff). According to some aspects consistent with the present disclosure, maxNumofCoeff may be specified to control the maximum buffer size and constrain the maximum number of transform coefficients stored in the buffer for prediction. In addition, another parameter coeffLengthControl is specified to limit the maximum allowed delay, which is defined as maxNumofCoeff*coeffLengthControl. Both parameters are encoded with ue(v), which is a 0th-order EG code specified in Table 5 for encoding a given integer v, where x0, x1, ..., xn are binary numbers. For example, when X is 8, log2maxNumofCoeffMinus8 will be encoded, and the encoder 101 and the decoder 201 may calculate maxNumofCoeff as follows: maxNumofCoeff=1<<(log2maxNumofCoeffMinus8+8).

[0133] To this end, the present disclosure proposes an exemplary log2maxNumofCoeffMinusX syntax element, which is decoded from the bitstream by the decoder 201. As an example and not a limitation, X may be an integer between 0 and 16. An exemplary syntax change to the attribute header is shown above in Table 6.

[0134] At 1004, the decoder may decode the bitstream to determine the maximum number of transform coefficients based on the logarithmic format. For example, once the maxNumofCoff is determined, the decoder 201 may decode the bitstream to generate an enhanced image, frame, and / or video.

[0135] At 1006, the decoder may obtain a plurality of transform coefficients associated with neighboring points in the point cloud. For example, to reduce memory usage, a predefined number may be specified to limit the number of neighboring points that may be used to generate a prediction, such as Figure 7As shown. For prediction, one or more previously encoded adjacent points may be used to predict the current point. After obtaining the adjacent points from the bitstream, the attribute information (e.g., color values, reflectivity values, depth values, etc.) may be maintained in a data buffer (e.g., a storage bin) of the encoder 101 and the decoder 201. The compressed one or more attribute information values ​​(e.g., color values, reflectivity values, depth values, etc.) are stored in the data buffer and used for prediction of other points. The compressed one or more attribute information values ​​may be referred to as "transform coefficients". In order to limit the size of the data buffer used to maintain one or more attribute information values ​​used for prediction, the present disclosure limits the maximum number of transform coefficients stored for prediction (e.g., maxNumofCoeff, Y, etc.).

[0136] At 1008, the decoder may determine a maximum buffer size based on the maximum number of transform coefficients. For example, the maximum buffer size may be determined based on the maximum number of transform coefficients (eg, one buffer bin per transform coefficient).

[0137] At 1010, the decoder may maintain each transform coefficient of the plurality of transform coefficients in a buffer equal to the maximum buffer size. For example, each transform coefficient may be maintained in a different buffer.

[0138] At 1012, the decoder may predict a property value for the point based on the plurality of transform coefficients. For example, a prediction of the property value for the point may be generated based on the transform coefficients maintained in a buffer.

[0139] Fig.11 A flowchart of an exemplary method 1100 for point cloud encoding according to some embodiments of the present disclosure is shown. The method 1100 may be performed by the encoder 101 of the encoding system 100 or any other suitable point cloud decoding system. The method 1100 may include operations 1102 to 1108 as described below. It should be understood that some of these operations may be optional and some of these operations may be performed.

[0140] At 1102, the encoder may determine a maximum delay (Nc) associated with a maximum zero run length. In some embodiments, the maximum delay may be less than the maximum zero run length. For example, for transform-based GPCC encoding, there may be two parameters, such as maxNumofCoeff and coeffLengthControl, which are used to control the maximum delay. The maximum delay (Nc) is defined as follows: Nc = maxNumofCoeff * coeffLengthControl. The maximum delay also enforces the maximum zero run length value allowed for such an application. Therefore, the present disclosure proposes that the allowed Nc may be less than the allowed maximum_zero_run_length.

[0141] At 1104, the encoder may determine a maximum zero run length associated with a plurality of property values ​​associated with one or more points in a set of points. In some embodiments, the maximum zero run length may be determined based at least in part on Nc. In some embodiments, determining the maximum zero run length associated with a plurality of property values ​​associated with one or more points in a set of points may include decoding a first flag from a bitstream to determine whether the zero run length is zero. In some embodiments, determining the maximum zero run length associated with a plurality of property values ​​associated with one or more points in a set of points may include: in response to determining that the zero run length is not zero, decoding a second flag from the bitstream to determine whether the zero run length is one. In some embodiments, determining the maximum zero run length associated with a plurality of property values ​​associated with one or more points in a set of points may include: in response to determining that the zero run length is not one, decoding a third flag from the bitstream to determine whether the zero run length is two. In some embodiments, determining the maximum zero run length associated with a plurality of property values ​​associated with one or more points in a set of points may include: in response to determining that the zero run length is not two, decoding a fourth flag from the bitstream to determine whether the value of the zero run length minus three is an odd number or an even number. In some embodiments, determining the maximum zero run length associated with multiple attribute values ​​associated with one or more points in a set of points may include decoding the remaining value of the zero run length from the bitstream. In some embodiments, the remaining value of the zero run length may include the value of the zero run length minus three divided by two. For example, depending on whether the k-order EG codeword is less than a predefined threshold, the zero run length encoding has two branches. The value of the zero run length represented by one branch (e.g., the first branch) may be half of the value represented by another branch (e.g., the second branch). The zero run length of the first branch may be encoded using the following exemplary techniques. For example, the first binary bit is encoded to indicate whether the value of the zero run length is zero; if the value of the zero run length is not zero, the second binary bit is encoded to indicate whether the value of the zero run length is one; if the value of the zero run length is not one, the third binary bit is encoded to indicate whether the value of the zero run length is two; if the value of the zero run length is not two, the parity flag will be encoded to indicate whether the value of the zero run length minus three is an odd number or an even number. After these four flags, a residual value representing the value of (zero run length - 3) / 2 can be decoded. The residual value can be encoded using a second-order EG codeword. If the maximum number of binary bits supported by the hardware (e.g., at encoder 101 and / or decoder 201) is N, the maximum value of the second-order EG codeword can be represented as 1<<((N-1)>>1+1). For example, if N is 32, the maximum value of the residual value will be 1<<((32-1)>>1+1), which is equal to 65536.By decoding these syntax elements encoded by encoder 101 , decoder 201 can determine the maximum zero run length.

[0142] At 1106, the encoder may determine whether the zero run length is less than or equal to the maximum zero run length. This determination may be made by comparing the zero run length to the maximum zero run length. If "yes" at 1106, the operation may move to 1108; otherwise, if "no" at 1106, the operation may move to 1110.

[0143] At 1108, the encoder may encode the bitstream in a single loop process based on the zero run length. As an example and not limitation, assuming that the MAXIMUM_VALUE of the zero run length is 131072, the zero run length is 131070. When this occurs, the zero run length is encoded once (e.g., a single loop process) using the syntax elements of Table 8 to indicate that the zero run length is 131070.

[0144] At 1110, the encoder may encode the bitstream in a multi-loop process based on the maximum zero run length and the zero run length. As an example and not limitation, assuming that the MAXIMUM_VALUE of the zero run length is 131072, the zero run length is 655360. When this occurs, the zero run length is encoded five times (e.g., a multi-loop process) using the syntax elements of Table 8 to indicate that the zero run length is 655360.

[0145] Fig.12 1 is a flow chart showing an exemplary method 1200 for point cloud decoding according to some embodiments of the present disclosure. The method 1200 may be performed by the decoder 201 of the decoding system 200 or any other suitable point cloud decoding system. The method 1200 may include operations 1202 to 1210 as described below. It should be understood that some of these operations may be optional, and some of these operations may be performed simultaneously or in conjunction with each other. Fig.12 The order shown in the figure is different from the order in which it is executed.

[0146] At 1202, the decoder may determine a maximum delay (Nc) associated with a maximum zero run length. In some embodiments, the maximum delay may be less than the maximum zero run length. For example, for transform-based GPCC encoding, there may be two parameters, such as maxNumofCoeff and coeffLengthControl, which are used to control the maximum delay. The maximum delay (Nc) is defined as follows: Nc = maxNumofCoeff * coeffLengthControl. The maximum delay also enforces the maximum zero run length value allowed for such an application. Therefore, the present disclosure proposes that the allowed Nc may be less than the allowed maximum_zero_run_length.

[0147] At 1204, the decoder may determine a maximum zero run length associated with a plurality of property values ​​associated with one or more points in a set of points. At 1204, the decoder may determine a maximum zero run length associated with a plurality of property values ​​associated with one or more points in a set of points. In some embodiments, determining, by at least one processor, the maximum zero run length associated with the plurality of property values ​​associated with one or more points in a set of points may include: in response to the bitstream being transform coded, determining the maximum zero run length as Nc indicated in the bitstream. In some embodiments, determining, by at least one processor, the maximum zero run length associated with the plurality of property values ​​associated with one or more points in a set of points may include: in response to the bitstream not being transform coded, determining the maximum zero run length as a predetermined value (e.g., 131072). In some embodiments, Nc may be calculated as a maximum number of transform coefficients (maxNumofCoeff) syntax element multiplied by a coefficient length control (CoeffLengthControl) syntax element encoded in the bitstream.

[0148] At 1206, the decoder may determine whether the zero run length is less than or equal to the maximum zero run length. This determination may be made by comparing the zero run length to the maximum zero run length. If "yes" at 1206, the operation may move to 1208; otherwise, if "no" at 1206, the operation may move to 1210.

[0149] At 1208, the decoder may encode the bitstream in a single-loop process based on the zero run length. As an example and not limitation, assuming that the MAXIMUM_VALUE of the zero run length is 131072, the zero run length is 131070. When this occurs, the zero run length is decoded once (e.g., a single-loop process) using the syntax elements of Table 8 to determine that the zero run length is 131070.

[0150] At 1210, the decoder may encode the bitstream in a multi-loop process based on the maximum zero run length and the zero run length. As an example and not a limitation, assuming that the MAXIMUM_VALUE of the zero run length is 131072, the zero run length is 655360. When this occurs, the zero run length is decoded five times (e.g., a multi-loop process) using the syntax elements of Table 8 to indicate that the zero run length is 655360.

[0151] In various aspects of the present disclosure, the functions described herein may be implemented in hardware, software, firmware, or any combination thereof. If the functions are implemented in software, the functions may be stored as instructions on a non-transitory computer-readable medium. Computer-readable media include computer storage media. Storage media may be a computer program that can be processed by a processor (e.g., Figure 1 and Figure 2 Any available medium accessed by the processor 102 in the computer readable medium. As an example and not limitation, such a computer-readable medium may include RAM, ROM, EEPROM, CD-ROM or other optical disk storage, HDD (e.g., disk storage or other magnetic storage device), flash drive, SSD, or any other medium that can be used to carry or store the required program code in the form of instructions or data structures and can be accessed by a processing system (e.g., a mobile device or a computer). Disks and discs used herein include compact disks (CDs), laser discs, optical discs, digital video discs (DVDs), and floppy disks, wherein disks generally reproduce data magnetically, while optical discs use lasers to reproduce data optically. Each of the above combinations should also be included in the scope of computer-readable media.

[0152] According to one aspect of the present disclosure, a method for decoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The method may include determining, by at least one processor, a maximum number of transform coefficients for predicting attribute values ​​of points in the set of points. The method may include decoding, by at least one processor, a bitstream to determine the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

[0153] In some embodiments, the method may include obtaining, by at least one processor, a plurality of transform coefficients associated with neighboring points in the point cloud. In some embodiments, a number of transform coefficients in the plurality of transform coefficients may be equal to a maximum number of transform coefficients.

[0154] In some embodiments, the method may include determining, by at least one processor, a maximum buffer size based on a maximum number of transform coefficients. In some embodiments, the method may include maintaining, by at least one processor, each transform coefficient in the plurality of transform coefficients in a buffer equal to the maximum buffer size.

[0155] In some embodiments, the method may include predicting, by at least one processor, a property value for the point based on the plurality of transform coefficients.

[0156] In some embodiments, the maximum number of transform coefficients may be determined based on Y=1<<(log2YminusX+X), where Y is the maximum number of transform coefficients indicated in the bitstream using the log2YminusX syntax element.

[0157] According to another aspect of the present disclosure, a system for decoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The system may include at least one processor and a memory storing instructions. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: determine a maximum number of transform coefficients for predicting attribute values ​​of points in a set of points. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: decode a bitstream to determine the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

[0158] In some embodiments, the memory stores instructions that, when executed by at least one processor, can also cause the at least one processor to perform the following operations: obtain a plurality of transform coefficients associated with adjacent points in the point cloud. In some embodiments, the number of transform coefficients in the plurality of transform coefficients can be equal to the maximum number of transform coefficients.

[0159] In some embodiments, the memory stores instructions that, when executed by at least one processor, cause the at least one processor to perform operations such as determining a maximum buffer size based on a maximum number of transform coefficients. The memory stores instructions that, when executed by at least one processor, cause the at least one processor to perform operations such as maintaining each transform coefficient in a plurality of transform coefficients in a buffer equal to the maximum buffer size.

[0160] In some embodiments, the memory stores instructions that, when executed by at least one processor, cause the at least one processor to perform the following operations: predicting a property value of the point based on a plurality of transform coefficients.

[0161] In some embodiments, the maximum number of transform coefficients may be determined based on Y=1<<(log2YminusX+X), where Y is the maximum number of transform coefficients indicated in the bitstream using the log2YminusX syntax element.

[0162] According to another aspect of the present disclosure, a method for encoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The method may include determining, by at least one processor, a maximum number of transform coefficients for predicting a property value of a point in the set of points. The method may include encoding, by at least one processor, a bitstream to indicate the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

[0163] In some embodiments, the method may include generating, by at least one processor, a plurality of transform coefficients associated with adjacent points in the point cloud. In some embodiments, a number of transform coefficients in the plurality of transform coefficients may be equal to a maximum number of transform coefficients.

[0164] In some embodiments, the method may include determining, by at least one processor, a maximum buffer size based on a maximum number of transform coefficients. The method may include maintaining, by at least one processor, each transform coefficient of the plurality of transform coefficients in a buffer equal to the maximum buffer size.

[0165] In some embodiments, the method may include predicting, by at least one processor, a property value for the point based on the plurality of transform coefficients.

[0166] In some embodiments, the maximum number of transform coefficients indicated by the log2maxNumofCoeffMinusX syntax element may be used in the bitstream.

[0167] According to another aspect of the present disclosure, a system for encoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The system may include at least one processor and a memory storing instructions. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: determine a maximum number of transform coefficients for predicting attribute values ​​of points in a set of points. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: encode a bitstream to indicate the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

[0168] In some embodiments, the memory stores instructions that, when executed by at least one processor, can also cause the at least one processor to perform the following operations: generate a plurality of transform coefficients associated with adjacent points in the point cloud. In some embodiments, the number of transform coefficients in the plurality of transform coefficients can be equal to the maximum number of transform coefficients.

[0169] In some embodiments, the memory stores instructions that, when executed by at least one processor, further cause the at least one processor to perform the following operations: determine a maximum buffer size based on a maximum number of transform coefficients. In some embodiments, the memory stores instructions that, when executed by at least one processor, further cause the at least one processor to perform the following operations: maintain each transform coefficient of the plurality of transform coefficients in a buffer equal to the maximum buffer size.

[0170] In some embodiments, the memory stores instructions that, when executed by at least one processor, may further cause the at least one processor to perform the following operations: predicting a property value of the point based on a plurality of transform coefficients.

[0171] In some embodiments, the maximum number of transform coefficients may be determined based on Y=1<<(log2YminusX+X), where Y is the maximum number of transform coefficients indicated in the bitstream using the log2YminusX syntax element.

[0172] According to another aspect of the present disclosure, a method for decoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The method may include: determining, by at least one processor, a maximum zero run length associated with a plurality of attribute values ​​associated with one or more points in the set of points. The method may include: decoding, by at least one processor, a bitstream in a single-loop process based on the zero run length in response to the encoded zero run length being less than or equal to the maximum zero run length. The method may include: decoding, by at least one processor, a bitstream in a multi-loop process based on the maximum zero run length and the encoded zero run length in response to the encoded zero run length being greater than the maximum zero run length.

[0173] In some embodiments, determining, by the at least one processor, a maximum zero-run length associated with a plurality of property values ​​associated with one or more points in a set of points may include: in response to the bitstream being transform coded, determining the maximum zero-run length as Nc indicated in the bitstream. In some embodiments, determining, by the at least one processor, a maximum zero-run length associated with a plurality of property values ​​for one or more points in a set of points may include: in response to the bitstream not being transform coded, determining the maximum zero-run length as a predetermined value.

[0174] In some embodiments, Nc may be calculated as a maximum number of transform coefficients (maxNumofCoeff) syntax element multiplied by a coefficient length control (CoeffLengthControl) syntax element encoded in the bitstream.

[0175] According to another aspect of the present disclosure, a system for decoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The system may include at least one processor and a memory storing instructions. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: determine a maximum zero run length associated with multiple attribute values ​​associated with one or more points in the set of points. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: in response to an encoded zero run length being less than or equal to the maximum zero run length, decode a bitstream in a single-cycle process based on the zero run length. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: in response to an encoded zero run length being greater than the maximum zero run length, decode a bitstream in a multi-cycle process based on the maximum zero run length and the encoded zero run length.

[0176] In some embodiments, to determine a maximum zero run length associated with a plurality of property values ​​associated with one or more points in a set of points, the memory stores instructions that, when executed by at least one processor, cause the at least one processor to: in response to the bitstream being transform encoded, determine the maximum zero run length as Nc indicated in the bitstream; and

[0177] In some embodiments, in order to determine a maximum zero run length associated with multiple attribute values ​​associated with one or more points in a set of points, the memory stores instructions that, when executed by at least one processor, cause the at least one processor to perform the following operations: in response to the bitstream not being transform encoded, determine the maximum zero run length to a predetermined value.

[0178] In some embodiments, Nc may be calculated as a maximum number of transform coefficients (maxNumofCoeff) syntax element multiplied by a coefficient length control (CoeffLengthControl) syntax element encoded in the bitstream.

[0179] According to another aspect of the present disclosure, a method for encoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The method may include: determining, by at least one processor, a maximum zero run length associated with a plurality of attribute values ​​associated with one or more points in the set of points. The method may include: encoding a bitstream in a single-cycle process based on the zero run length in response to the encoded zero run length being less than or equal to the maximum zero run length by at least one processor. The method encodes the bitstream in a multi-cycle process based on the maximum zero run length and the encoded zero run length in response to the encoded zero run length being greater than the maximum zero run length by at least one processor.

[0180] In some embodiments, determining, by the at least one processor, a maximum zero-run length associated with a plurality of property values ​​associated with one or more points in a set of points may include: in response to the bitstream being transform coded, determining the maximum zero-run length as Nc indicated in the bitstream. In some embodiments, determining, by the at least one processor, a maximum zero-run length associated with a plurality of property values ​​associated with one or more points in a set of points may include: in response to the bitstream not being transform coded, determining the maximum zero-run length as a predetermined value.

[0181] According to another aspect of the present disclosure, a system for encoding a point cloud is provided, the point cloud being represented by a 1D array including a set of points. The system may include at least one processor and a memory storing instructions. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: determine a maximum zero run length associated with multiple attribute values ​​associated with one or more points in the set of points. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: in response to the encoded zero run length being less than or equal to the maximum zero run length, encode a bitstream in a single-cycle process based on the zero run length. The memory stores instructions that, when executed by at least one processor, may cause the at least one processor to perform the following operations: in response to the encoded zero run length being greater than the maximum zero run length, encode the bitstream in a multi-cycle process based on the maximum zero run length and the encoded zero run length.

[0182] In some embodiments, to determine the maximum zero run length associated with a plurality of property values ​​associated with one or more points in a set of points, the memory stores instructions that, when executed by at least one processor, cause the at least one processor to perform the following operations: in response to the bitstream being transform coded, determine the maximum zero run length as Nc indicated in the bitstream. In some embodiments, to determine the maximum zero run length associated with a plurality of property values ​​associated with one or more points in the set of points, the memory stores instructions that, when executed by at least one processor, cause the at least one processor to perform the following operations: in response to the bitstream not being transform coded, determine the maximum zero run length as a predetermined value.

[0183] In some embodiments, Nc may be calculated as a maximum number of transform coefficients (maxNumofCoeff) syntax element multiplied by a coefficient length control (CoeffLengthControl) syntax element.

[0184] The foregoing description of the various embodiments will reveal the general nature of the present disclosure, so that others can easily modify and / or change these embodiments for various applications by applying knowledge in the art without excessive experimentation without departing from the general concepts disclosed. Therefore, such changes and modifications are intended to be within the meaning and scope of equivalents of the disclosed embodiments based on the teachings and guidance provided herein. It should be understood that the words or terms in this article are for descriptive purposes rather than for limitation, so those skilled in the art should interpret the terms or words in this specification in accordance with these teachings and guidance.

[0185] The embodiments of the present disclosure have been described above with the help of functional building blocks that illustrate the implementation of the specified functions and their relationships. For ease of description, the boundaries of these functional building blocks are arbitrarily defined in this article. As long as the specified functions and their relationships can be properly performed, alternative boundaries can be defined.

[0186] The Summary and Abstract sections may set forth one or more but not all exemplary embodiments of the present disclosure as contemplated by one or more inventors, and thus, are not intended to limit the present disclosure and the appended claims in any way.

[0187] Various functional blocks, modules and steps are disclosed above. The arrangements provided are exemplary and non-restrictive. Therefore, the functional blocks, modules and steps can be reordered or combined in a manner different from the examples provided above. Similarly, some embodiments include only a subset of functional blocks, modules and steps, and any such subset is allowed.

[0188] The breadth and scope of the present disclosure should not be limited by any of the above-described exemplary embodiments, but should be defined only in accordance with the following claims and their equivalents.

Claims

1. A method for decoding a point cloud, the point cloud being represented by a one-dimensional 1D array comprising a set of points, the method comprising: determining, by at least one processor, a maximum number of transform coefficients for predicting a property value for a point in the set of points; as well as The bitstream is decoded by the at least one processor to determine the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

2. The method according to claim 1, further comprising: obtaining, by the at least one processor, a plurality of transform coefficients associated with adjacent points in the point cloud; The number of transform coefficients in the plurality of transform coefficients is equal to the maximum number of the transform coefficients.

3. The method according to claim 2, further comprising: determining, by the at least one processor, a maximum buffer size based on the maximum number of transform coefficients; as well as Each transform coefficient of the plurality of transform coefficients is maintained, by the at least one processor, in a buffer equal to the maximum buffer size.

4. The method according to claim 2, further comprising: The property value of the point is predicted by the at least one processor based on the plurality of transform coefficients.

5. The method according to claim 1, wherein: The maximum number of transform coefficients is determined based on Y=1<<(log2YminusX+X), where Y is the maximum number of transform coefficients indicated in a bitstream using a log2YminusX syntax element.

6. A system for decoding a point cloud, the point cloud being represented by a one-dimensional 1D array comprising a set of points, the system comprising: at least one processor; as well as A memory storing instructions, which, when executed by the at least one processor, cause the at least one processor to: determining a maximum number of transform coefficients for predicting a property value for a point in the set of points; as well as The bitstream is decoded to determine the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

7. The system according to claim 6, wherein: The memory stores instructions that, when executed by the at least one processor, further cause the at least one processor to perform the following operations: Obtaining a plurality of transform coefficients associated with adjacent points in the point cloud; The number of transform coefficients in the plurality of transform coefficients is equal to the maximum number of the transform coefficients.

8. The system according to claim 7, wherein: The memory stores instructions that, when executed by the at least one processor, further cause the at least one processor to perform the following operations: determining a maximum buffer size based on the maximum number of transform coefficients; and Each transform coefficient of the plurality of transform coefficients is maintained in a buffer equal to the maximum buffer size.

9. The system according to claim 7, wherein: The memory stores instructions that, when executed by the at least one processor, further cause the at least one processor to perform the following operations: The attribute value of the point is predicted based on the plurality of transform coefficients.

10. The system according to claim 6, wherein: The maximum number of transform coefficients is determined based on 1<<(log2YminusX+X), where Y is the maximum number of transform coefficients indicated in a bitstream using a log2YminusX syntax element.

11. A method for encoding a point cloud, the point cloud being represented by a one-dimensional 1D array comprising a set of points, the method comprising: determining, by at least one processor, a maximum number of transform coefficients for predicting a property value for a point in the set of points; as well as The bitstream is encoded, by the at least one processor, to indicate the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

12. The method according to claim 11, further comprising: generating, by the at least one processor, a plurality of transform coefficients associated with adjacent points in the point cloud; The number of transform coefficients in the plurality of transform coefficients is equal to the maximum number of the transform coefficients.

13. The method according to claim 12, further comprising: determining, by the at least one processor, a maximum buffer size based on the maximum number of transform coefficients; as well as Each transform coefficient of the plurality of transform coefficients is maintained, by the at least one processor, in a buffer equal to the maximum buffer size.

14. The method according to claim 12, further comprising: The property value of the point is predicted by the at least one processor based on the plurality of transform coefficients.

15. The method according to claim 11, wherein: The maximum number of transform coefficients is determined based on 1<<(log2YminusX+X), where Y is the maximum number of transform coefficients indicated in a bitstream using a log2YminusX syntax element.

16. A system for encoding a point cloud, the point cloud being represented by a one-dimensional 1D array comprising a set of points, the system comprising: at least one processor; as well as A memory storing instructions, which, when executed by the at least one processor, cause the at least one processor to: determining a maximum number of transform coefficients for predicting a property value for a point in the set of points; as well as The bitstream is encoded to indicate the maximum number of transform coefficients based on a logarithmic format minus a fixed integer.

17. The system of claim 16, wherein: The memory stores instructions that, when executed by the at least one processor, further cause the at least one processor to perform the following operations: generating a plurality of transform coefficients associated with adjacent points in the point cloud; The number of transform coefficients in the plurality of transform coefficients is equal to the maximum number of the transform coefficients.

18. The system of claim 17, wherein: The memory stores instructions that, when executed by the at least one processor, further cause the at least one processor to perform the following operations: determining a maximum buffer size based on the maximum number of transform coefficients; and Each transform coefficient of the plurality of transform coefficients is maintained in a buffer equal to the maximum buffer size.

19. The system of claim 17, wherein: The memory stores instructions that, when executed by the at least one processor, further cause the at least one processor to perform the following operations: The attribute value of the point is predicted based on the plurality of transform coefficients.

20. The system of claim 16, wherein: The maximum number of transform coefficients is determined based on 1<<(log2YminusX+X), where Y is the maximum number of transform coefficients indicated in a bitstream using a log2YminusX syntax element.

21. A method for decoding a point cloud, the point cloud being represented by a one-dimensional 1D array comprising a set of points, the method comprising: determining, by at least one processor, a maximum zero run length associated with a plurality of attribute values ​​associated with one or more points in the set of points; decoding, by the at least one processor, a bitstream in a single-loop process based on the zero run length in response to the encoded zero run length being less than or equal to the maximum zero run length; as well as In response to the encoded zero run length being greater than the maximum zero run length, the at least one processor decodes the bitstream in a multi-cycle process based on the maximum zero run length and the encoded zero run length.

22. The method according to claim 21, wherein: Determining, by the at least one processor, the maximum zero-run length associated with a plurality of attribute values ​​associated with the one or more points in the set of points comprises: In response to the bitstream being transform coded, determining the maximum zero run length as a maximum delay Nc indicated in the bitstream; and In response to the bitstream not being transform coded, the maximum zero run length is determined to be a predetermined value.

23. The method according to claim 22, wherein: Nc is calculated as the maximum number of transform coefficients, maxNumofCoeff syntax element, multiplied by the coefficient length control, CoeffLengthControl syntax element, encoded in the bitstream.

24. A system for decoding a point cloud, the point cloud being represented by a one-dimensional 1D array comprising a set of points, the system comprising: at least one processor; as well as A memory storing instructions, which, when executed by the at least one processor, cause the at least one processor to: determining a maximum zero run length associated with a plurality of attribute values ​​associated with one or more points in the set of points; In response to the encoded zero run length being less than or equal to the maximum zero run length, decoding a bitstream in a single-loop process based on the zero run length; as well as In response to the encoded zero run length being greater than the maximum zero run length, the bitstream is decoded in a multi-cycle process based on the maximum zero run length and the encoded zero run length.

25. The system of claim 24, wherein: To determine the maximum zero run length associated with a plurality of attribute values ​​associated with the one or more points in the set of points, the memory stores instructions that, when executed by the at least one processor, cause the at least one processor to: In response to the bitstream being transform coded, determining the maximum zero run length as a maximum delay Nc indicated in the bitstream; and In response to the bitstream not being transform coded, the maximum zero run length is determined to be a predetermined value.

26. The system of claim 25, wherein: Nc is calculated as the maximum number of transform coefficients, maxNumofCoeff syntax element, multiplied by the coefficient length control, CoeffLengthControl syntax element, encoded in the bitstream.

27. A method for encoding a point cloud, the point cloud being represented by a one-dimensional 1D array comprising a set of points, the method comprising: determining, by at least one processor, a maximum zero run length associated with a plurality of attribute values ​​associated with one or more points in the set of points; encoding, by the at least one processor, a bitstream in a single-loop process based on the zero-run length in response to the encoded zero-run length being less than or equal to the maximum zero-run length; as well as In response to the encoded zero-run length being greater than the maximum zero-run length, the at least one processor encodes the bitstream in a multi-cycle process based on the maximum zero-run length and the encoded zero-run length.

28. The method according to claim 27, wherein: Determining, by the at least one processor, the maximum zero-run length associated with a plurality of attribute values ​​associated with the one or more points in the set of points comprises: In response to the bitstream being transform coded, determining the maximum zero run length as a maximum delay Nc indicated in the bitstream; and In response to the bitstream not being transform coded, the maximum zero run length is determined to be a predetermined value.

29. The system of claim 28, wherein: Nc is calculated as the maximum number of transform coefficients, maxNumofCoeff syntax element, multiplied by the coefficient length control, CoeffLengthControl syntax element.

30. A system for encoding a point cloud, the point cloud being represented by a one-dimensional 1D array comprising a set of points, the system comprising: at least one processor; as well as A memory storing instructions, which, when executed by the at least one processor, cause the at least one processor to: determining a maximum zero run length associated with a plurality of attribute values ​​associated with one or more points in the set of points; In response to the encoded zero run length being less than or equal to the maximum zero run length, encoding a bitstream in a single-loop process based on the zero run length; as well as In response to the encoded zero run length being greater than the maximum zero run length, encoding the bitstream in a multi-cycle process based on the maximum zero run length and the zero run length.

31. The system of claim 30, wherein: To determine the maximum zero run length associated with a plurality of attribute values ​​associated with the one or more points in the set of points, the memory stores instructions that, when executed by the at least one processor, cause the at least one processor to: In response to the bitstream being transform coded, determining the maximum zero run length as a maximum delay Nc indicated in the bitstream; and In response to the bitstream not being transform coded, the maximum zero run length is determined to be a predetermined value.

32. The system of claim 31, wherein: Nc is calculated as the maximum number of transform coefficients, maxNumofCoeff syntax element, multiplied by the coefficient length control, CoeffLengthControl syntax element.

Images