Encoding and decoding method, encoder, decoder and storage medium

Abstract

The embodiment of the invention discloses an encoding and decoding method, an encoder, a decoder and a storage medium, and the method comprises the steps: analyzing a first group of bit information in a code stream, and determining the quotient of a to-be-decoded value; analyzing the second group of bit information in the code stream, and determining the remainder of the numerical value to be decoded; wherein the second group of bit information comprises bit information of a preset length, or bit information of (the preset length + 1); and determining the to-be-decoded value according to the quotient of the to-be-decoded value and the remainder of the to-be-decoded value. Therefore, the entropy coding and decoding performance of the point cloud can be improved.

Description

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application claims priority to U.S. provisional patent application No. 63 / 566,809, filed on March 18, 2024, entitled “INTERMEDIARY QUANTIZATION METHOD FOR LEARNING BASED POINT CLOUD CODE REPRODUCTION.”

[0003] This application claims priority to U.S. provisional patent application No. 63 / 567,312, filed on March 19, 2024, entitled “SPARSETENSOR LATENT FEATURES BINARIZATION FOR LEARNING BASED POINT CLOUD CODEDREPRESENTATION.” Technical Field

[0004] The embodiments of the present application relate to the field of point cloud encoding and decoding technology, and in particular to an encoding and decoding method, an encoder, a decoder, and a storage medium. Background Art

[0005] With the vigorous development of emerging technologies such as augmented reality, virtual reality, autonomous driving and robotics, point cloud data has become one of the main data forms due to its concise expression of three-dimensional space. However, the amount of point cloud data is huge, and directly storing point cloud data consumes a lot of memory and is not conducive to transmission. Therefore, high-performance point cloud compression technology is very necessary.

[0006] In recent years, neural networks and deep learning technologies have been widely used in the field of point cloud geometry compression. However, the current entropy encoding and decoding processes in the learning-based Artificial Intelligence Point Cloud Coding (AI-PCC) standard are not fully considered. Improving entropy encoding and decoding performance remains a pressing technical challenge in this field. Summary of the Invention

[0007] The embodiments of the present application provide a coding and decoding method, an encoder, a decoder, and a storage medium, which can improve the entropy coding and decoding performance of point clouds.

[0008] The technical solution of the embodiment of the present application can be implemented as follows:

[0009] In a first aspect, an embodiment of the present application provides a decoding method, applied to a decoder, the method comprising:

[0010] Parsing the first set of bits in the bitstream to determine the quotient of the value to be decoded;

[0011] Parsing a second set of bit information in the code stream to determine a remainder of the value to be decoded; wherein the second set of bit information includes: bit information of a preset length, or bit information of (preset length+1);

[0012] The value to be decoded is determined according to the quotient of the value to be decoded and the remainder of the value to be decoded.

[0013] In a second aspect, an embodiment of the present application provides an encoding method, applied to an encoder, the method comprising:

[0014] Determining the quotient and remainder of the value to be encoded;

[0015] Determining a first set of bit information based on a quotient of the value to be encoded;

[0016] Determining a second set of bit information based on a remainder of the value to be encoded; wherein the second set of bit information includes: bit information of a preset length, or bit information of (preset length+1);

[0017] The first group of bit information and the second group of bit information are respectively coded, and the obtained coded bits are sequentially written into the bit stream.

[0018] In a third aspect, an embodiment of the present application provides an encoder, comprising a first determining unit and an encoding unit, wherein:

[0019] a first determining unit configured to determine a quotient and a remainder of a value to be encoded; determine a first set of bit information based on the quotient of the value to be encoded; and determine a second set of bit information based on the remainder of the value to be encoded; wherein the second set of bit information includes: bit information of a preset length, or bit information of (preset length+1);

[0020] The encoding unit is configured to encode the first group of bit information and the second group of bit information respectively, and write the obtained encoded bits into the bit stream in sequence.

[0021] In a fourth aspect, an embodiment of the present application provides an encoder, comprising a first memory and a first processor; wherein,

[0022] a first memory for storing a computer program capable of running on the first processor;

[0023] The first processor is configured to execute the method according to the second aspect when running a computer program.

[0024] In a fifth aspect, an embodiment of the present application provides a decoder, comprising a decoding unit and a second determining unit, wherein:

[0025] a decoding unit configured to parse a first set of bit information in a bit stream to determine a quotient of a value to be decoded; and parse a second set of bit information in the bit stream to determine a remainder of the value to be decoded; wherein the second set of bit information includes: bit information of a preset length, or bit information of (preset length+1);

[0026] The second determining unit is configured to determine the value to be decoded according to the quotient of the value to be decoded and the remainder of the value to be decoded.

[0027] In a sixth aspect, an embodiment of the present application provides a decoder, the decoder comprising a second memory and a second processor; wherein,

[0028] a second memory for storing a computer program capable of running on the second processor;

[0029] The second processor is configured to execute the method according to the first aspect when running a computer program.

[0030] In a seventh aspect, an embodiment of the present application provides a computer-readable storage medium on which a computer program is stored. When the computer program is executed by a processor, it implements the decoding method as described in the first aspect, or implements the encoding method as described in the second aspect.

[0031] In an eighth aspect, an embodiment of the present application provides a computer-readable storage medium on which a code stream is stored. The code stream is generated by executing the steps of the encoding method described in the second aspect.

[0032] In a ninth aspect, an embodiment of the present application provides a computer program product, comprising a computer program or instructions, which, when executed by a processor, implements the decoding method as described in the first aspect, or implements the encoding method as described in the second aspect.

[0033] The embodiment of the present application provides a coding and decoding method, an encoder, a decoder, and a storage medium. At the encoding end, the quotient and remainder of the value to be encoded are determined; based on the quotient of the value to be encoded, a first group of bit information is determined; based on the remainder of the value to be encoded, a second group of bit information is determined; the first group of bit information and the second group of bit information are respectively encoded and processed, and the obtained coded bits are written into the code stream in sequence. At the decoding end, the first group of bit information in the code stream is parsed to determine the quotient of the value to be decoded; the second group of bit information in the code stream is parsed to determine the remainder of the value to be decoded; the value to be decoded is determined based on the quotient of the value to be decoded and the remainder of the value to be decoded. The second group of bit information includes: bit information of a preset length, or bit information of (preset length + 1). In this way, the encoding end encodes the quotient and remainder of the value to be encoded separately after determining them. A new binarization method is used here for encoding processing. For example, the Golomb-Rice code method can be used for binarization processing. The remainder can be encoded by bit information of a preset length, or it can be encoded by bit information of (preset length + 1); then the decoding end performs corresponding decoding on the quotient and remainder respectively to obtain the value to be decoded; and the value to be encoded here is obtained by zero-run processing, which can also save coding bits and thus improve the entropy coding and decoding performance. BRIEF DESCRIPTION OF THE DRAWINGS

[0034] Figure 1A Schematic diagram of a three-dimensional point cloud image;

[0035] Figure 1B It is a partial enlarged schematic diagram of a three-dimensional point cloud image;

[0036] Figure 2A Schematic diagram of the six viewing dimensions of point cloud images;

[0037] Figure 2B It is a schematic diagram of the composition structure of the file header information part and the data part;

[0038] Figure 3 Schematic diagram of PCG voxelization;

[0039] Figure 4 Schematic diagram of the MP-POV processing process;

[0040] Figure 5 Schematic diagram of sparse geometric coding framework;

[0041] Figure 6 Schematic diagram of the up-down scaling of the voxel sampling layer;

[0042] Figure 7 This is a diagram of the network architecture of the classic ResNet;

[0043] Figure 8Schematic diagram of SOPA's upscaling process;

[0044] Figure 9 Schematic diagram of the upscaling process of multi-level SOPA;

[0045] Figure 10 Schematic diagram of probability thresholding of dense object point cloud;

[0046] Figure 11 Schematic diagram of position offset adjustment for sparse LiDAR point clouds;

[0047] Figure 12 Schematic diagram of level 1 / 3 / 8 for grouping the 8 marked MP-POVs;

[0048] Figure 13 This is a schematic diagram of the SLNE enhanced first-level SOPA;

[0049] Figure 14 Schematic diagram of a general architecture with m scales coded in lossless mode and (Nm) scales coded in lossy mode;

[0050] Figure 15 This is a schematic diagram of the application scenario of the geometric encoder;

[0051] Figure 16 A flowchart illustrating the OPU implementation details;

[0052] Figure 17 Schematic diagram of the structure of IRN and NPFormer used to form DNN blocks;

[0053] Figure 18 Schematic diagram of the linear quantization process;

[0054] Figure 19 Schematic diagram 1 of a decoding method provided in an embodiment of the present application;

[0055] Figure 20 Schematic diagram 2 of a decoding method provided in an embodiment of the present application;

[0056] Figure 21 A schematic diagram of a non-uniform quantization process provided in an embodiment of the present application;

[0057] Figure 22 A schematic diagram of an application scenario of non-uniform quantization based on learning provided in an embodiment of the present application;

[0058] Figure 23 Schematic diagram 1 of a flow chart of an encoding method provided in an embodiment of the present application;

[0059] Figure 24 Schematic diagram 2 of a flow chart of an encoding method provided in an embodiment of the present application;

[0060] Figure 25 A schematic diagram of a coding method provided in an embodiment of the present application Figure 3 ;

[0061] Figure 26 A schematic diagram of the structure of an encoder provided in an embodiment of the present application;

[0062] Figure 27 A schematic diagram of the hardware structure of an encoder provided in an embodiment of the present application;

[0063] Figure 28 A schematic diagram of the structure of a decoder provided in an embodiment of the present application;

[0064] Figure 29 A schematic diagram of the hardware structure of a decoder provided in an embodiment of the present application;

[0065] Figure 30 A schematic diagram of the structure of a coding and decoding system provided in an embodiment of the present application. DETAILED DESCRIPTION

[0066] In order to enable a more detailed understanding of the features and technical contents of the embodiments of the present application, the implementation of the embodiments of the present application is described in detail below with reference to the accompanying drawings. The attached drawings are for reference only and are not used to limit the embodiments of the present application.

[0067] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by those skilled in the art to which this application pertains. The terms used herein are for the purpose of describing the embodiments of this application only and are not intended to limit this application.

[0068] In the following description, reference is made to “some embodiments”, which describes a subset of all possible embodiments, but it will be understood that “some embodiments” may be the same subset or different subsets of all possible embodiments and may be combined with each other without conflict.

[0069] It should also be pointed out that the terms "first\second\third" involved in the embodiments of the present application are only used to distinguish similar objects and do not represent a specific ordering of the objects. It can be understood that "first\second\third" can be interchanged with a specific order or sequence where permitted, so that the embodiments of the present application described here can be implemented in an order other than that illustrated or described here.

[0070] It should be understood that point cloud is a three-dimensional representation of the surface of an object. Point cloud (data) of the surface of an object can be collected through acquisition equipment such as photoelectric radar, lidar, laser scanner, and multi-view camera.

[0071] A point cloud is a set of irregularly distributed discrete points in three-dimensional space that express the spatial structure and surface properties of a three-dimensional object or scene. These points contain geometric information used to represent spatial position and attribute information used to represent the appearance texture of the point cloud. Figure 1A Displays 3D point cloud images and Figure 1B A local enlarged image of the 3D point cloud image is shown, and it can be seen that the point cloud surface is composed of densely distributed points.

[0072] Two-dimensional images contain information at every pixel, and their distribution is regular, so there's no need to record their position. However, the distribution of points in a point cloud in three-dimensional space is random and irregular, so recording the spatial position of each point is necessary to fully represent the object in three-dimensional space. Similar to two-dimensional images, each location in the acquisition process has corresponding attribute information, typically including color and reflectance. Color information reflects the object's color, typically expressed in RGB; reflectance information reflects the surface texture, typically expressed in reflectance. Point cloud data typically consists of geometric information (x, y, z) representing the three-dimensional spatial position, as well as attribute information such as color (r, g, b) and reflectance. For example, reflectance information can be one-dimensional reflectance (r); color information can be in any color space, or it can be three-dimensional color information, such as RGB. Here, R represents red (red), G represents green (green), and B represents blue (blue). For another example, the color information may be luminance and chrominance (YCbCr, YUV) information, where Y represents brightness (Luma), Cb (U) represents blue color difference, and Cr (V) represents red color difference.

[0073] For example, a point cloud obtained using laser measurement principles may include both 3D coordinate information and reflectivity information for each point. For another example, a point cloud obtained using photogrammetry principles may include both 3D coordinate information and 3D color information for each point. For another example, a point cloud obtained using a combination of laser measurement and photogrammetry principles may include both 3D coordinate information, reflectivity information, and 3D color information for each point.

[0074] like Figure 2A and Figure 2B The following is a point cloud image and its corresponding data storage format. Figure 2A Provides six viewing dimensions of point cloud images. Figure 2BThe file consists of a header and a data section. The header includes the data format, data representation type, the total number of points in the point cloud, and the content represented by the point cloud. For example, a point cloud file in the ".ply" format is represented by ASCII code and has a total of 207,242 points. Each point has 3D coordinate information (x, y, z) and 3D color information (r, g, b).

[0075] Before further explaining the embodiments of the present application in detail, the nouns and terms that may be involved in the embodiments of the present application are explained first. The nouns and terms involved in the embodiments of the present application are subject to the following interpretations:

[0076] Geometric information: A set of three-dimensional (x, y, z) coordinates describing the positions associated with mesh vertices. The (x, y, z) coordinates representing the positions should have a well-defined precision and dynamic range.

[0077] Attribute information: A collection of attribute primary colors (R, G, B), transformed primary colors (Y, U, V), reflectivity, transparency, and / or normals, associated with the three-dimensional (x, y, z) coordinates of the vertex that describe the attribute value. The values ​​(R, G, B, and reflectivity) representing the attribute information should have a well-defined precision and dynamic range.

[0078] Point cloud: A collection of discrete data points in space. Points can represent three-dimensional shapes or objects. Each point location has a collection of geometric information and, optionally, at least one attribute.

[0079] Quantization: is the process of mapping continuous infinite values ​​to a smaller set of discrete finite values.

[0080] Rate-distortion optimized quantization: It is encountered in source coding of lossy data compression algorithms, with the goal of managing distortion within the range of bit rates supported by the communication channel or storage medium.

[0081] Arithmetic Encoding (AE);

[0082] Arithmetic Decoding (AD);

[0083] Positively-Occupied Voxels (POV);

[0084] Non-Occupied (empty) Voxel (NOV);

[0085] Most-Probable Positively-Occupied Voxels (MP-POV);

[0086] Point Cloud Geometry (PCG);

[0087] Convolutional Neural Networks (CNN);

[0088] SparseCNN-based Occupancy (SOPA);

[0089] SparseCNN based Local Neighborhood Embedding (SLNE);

[0090] deep neural network (DNN);

[0091] Voxel Sampling Layer (VSL);

[0092] Deep Feature Aggregation (DFA);

[0093] Occupancy Output Layer (OOL);

[0094] Occupancy Processing Unit (OPU): a module used for geometry compression in the form of binary octree occupancy codes;

[0095] Attribute Processing Unit (APU): a module used for attribute compression;

[0096] Geometry Coding Unit (GCU): a module used for geometry compression;

[0097] Dyadic DownScaling (DDS);

[0098] MultiLayer Perception (MLP);

[0099] Conditional Probability Approximation (CPA);

[0100] Classic residual neural network (Inception ResNet, IRN);

[0101] Neighborhood Point Attention (NPA);

[0102] k-Nearest Neighbor (kNN);

[0103] Voxel: An image of a three-dimensional space region restricted to a given size. A voxel has its own node coordinates (geometry), its own form in a recognized coordinate system, and has the characteristics (attributes) of the modeled area.

[0104] It should also be understood that a point cloud is a collection of non-uniformly and sparsely distributed points that can be characterized using their three-dimensional coordinates (e.g., (x, y, z)) and attributes (e.g., RGB color, reflectivity, etc.) (if applicable). Unlike the well-structured pixel grids of a two-dimensional image plane or video frame, a point cloud relies on unconstrained displacements of points to flexibly represent three-dimensional objects of arbitrary shape. However, due to the difficulty in representing and utilizing the cross-correlations between irregularly scattered points in a free three-dimensional space, problems arise in effectively encoding geometric occupancy.

[0105] In general, the compression efficiency of a point in a point cloud is closely related to the probability approximation of that point conditioned on its available neighbors. The more accurate the context modeling and the closer the probability distribution is to the real data, the fewer bits are consumed.

[0106] The voxel representation of PCG is as follows Figure 3 As shown in the figure, (a) is a uniform voxel representation, and (b) is an octree representation. Among them, (a) uses a densely sampled uniform voxel grid (which can be called "uniform voxels") and converts it into a binary occupancy state (or occupancy state) representation; (b) describes whether the geometric position of the current voxel is occupied (POV, occupancy state = 1) or not occupied (NOV, occupancy state = 0).

[0107] The non-uniformly distributed POVs of the input PCG can be approximated using sparse tensors by caching the geometric coordinates and attribute information (if applicable) of the MP-POVs generated from the previous lower-scale POVs by voxel scaling, e.g. Figure 4 As shown in Figure 2, (a) is a sparse tensor, (b) is a binary voxel downsampling, and (c) is a binary voxel upsampling. The scale sparse tensor is formed under the multi-scale representation framework by gradually reducing the original PCG to a multi-resolution PCG and correspondingly enlarging it for hierarchical reconstruction, as shown in Figure 2. Figure 5 shown.

[0108] exist Figure 5 In the encoding process, the PCG tensor is regressed and decremented, and the occupied voxels at each scale are encoded into a binary bit stream (or "bit stream") according to the occupancy probability of the occupied voxels. In the decoding process, the occupied voxels are reconstructed by decoding the binary bit stream with the occupancy probability.

[0109] Occupancy probability estimation can leverage cross-scale and same-scale prior information and be embedded in the encoder and decoder to achieve bit-by-bit accurate matching. This sparse CNN-based occupancy probability approximation is called "SOPA." Depending on the trade-off between performance and complexity, SOPA can be implemented in a single-stage or multi-stage manner.

[0110] Cross-scale context modeling.

[0111] The occupancy of the MP-POV at each scale is encoded into the compressed bitstream and decoded accordingly to reconstruct the POV at the same scale. On the multi-scale representation model, cross-scale context modeling is performed by approximating the occupancy probability of each MP-POV at the current scale using the decoded POV from the previous lower scale. Cross-scale context modeling is limited to between two consecutive scales.

[0112] Sparse convolution.

[0113] 3D sparse convolution can be effectively applied to sparse tensors. 3D sparse convolution is similar to the commonly used 3D dense convolution, but only uses the effective MP-POV for convolution, which fully utilizes the sparse characteristics of point clouds.

[0114] A set of coordinates can be used and associated features To construct a sparse tensor. Therefore, sparse convolution can be expressed as:

[0115]

[0116] in, and are the input coordinates and the output coordinates. If the resolution is maintained, then and same. and are the input eigenvector and output eigenvector at coordinate u(xu,yu,zu) respectively. Define a center with u, There is a 3D convolution kernel with an offset k in the kernel. By setting different k, the method obtains a predefined 3D receptive field (e.g. k×k×k or k 3 ) for information aggregation. Wi represents the weight of the kernel.

[0117] Sparse convolution (SConv) or transposed sparse convolution (TSConv) can be formatted using “K, C, S”, where K = k×k×k (k 3 ), is the receptive field of the three-dimensional convolution; C represents the number of channels; for downscaling, S can be s×s×s↓(s 3 ↓); or for ascending scale, S can be s×s×s↑(s 3 ↑). Correspondingly, the downscaling (upscaling) operator is associated with SConv (TSConv).

[0118] Voxel Sampling Layer (VSL) can be achieved by using Figure 6 The "SConv 2 3 ,C,2 3 ↓" or "TSConv 2 3 ,C,2 3 ↑”, which binary upscales or downscales voxels. Deep Feature Aggregation (DFA) is used to represent and embed information from spatial neighbors within the receptive field. Occupancy Output Layer (OOL) is used for probability or offset derivation.

[0119] Figure 5 The sparse geometric coding framework shown consists of a series of binary voxel sampling, for example, S = 2 × 2 × 2↑ when upscaling, or S = 2 × 2 × 2↓ when downscaling. Binary voxel sampling can be integrated with sparse CNN blocks for better information embedding during resampling. This step-by-step scaling mechanism enables multi-scale representations to easily support resolution scalability. Since the processing between two adjacent scales is the same, it can be achieved by Figure 5 The two-scale example from the (i-1)th scale to the i-th scale is shown to fully explain the entire sparse PCGC. Each POV from the previous scale will be subdivided into 8 MP-POVs, where some MP-POVs can be POVs and the rest are NOVs. The true value is known in the encoder but unknown in the decoder. At each scale, the occupancy state of each MP-POV is compressed in the encoder, and the POV is reversely reconstructed from the upscaled MP-POV in the decoder by parsing the compressed codestream syntax. Therefore, the same cross-scale context model is shared between the encoder and decoder, which is generated by SOPA using the decoded POV at the previous scale to generate the occupancy probability pMP-POV of the MP-POV in the upscaled tensor for arithmetic coding.

[0120] Network architecture.

[0121] Convolutional layers and (non-linear) activation layers are usually stacked to form sparse CNN blocks, including Figure 6 The voxel sampling layer (VSL) and Figure 7Deep Feature Aggregation (DFA) and Occupancy Output Layer (OOL) are shown. All computations are performed using sparse distributed POV or MP-POV in sparse tensors. Figure 7 For example, (a) represents deep feature aggregation, and (b) represents the occupied output layer. They are described in detail below.

[0122] (1) Voxel Sampling Layer (VSL).

[0123] Voxel upscaling is embedded in SOPA, and voxel downscaling is embedded in SLNE to perform cross-scale message passing. For downscaling in SLNE, “SConv 2 3 ,C,2 3 ↓" to merge 8 spatially connected voxels (e.g. 2×2×2) into one voxel ( Figure 6 ), which can be referred to as "VSL 2 3 ↓”.

[0124] For example, Figure 8 Describes the SOPA upscaling process, where the application Figure 8 The upscaling in SOPA shown in TSConv 2 3 ,C,2 3 ↑" can subdivide the voxel into 8 subvoxels (or subnodes), namely VSL 2 3 ↑. C is an adjustable model parameter representing the number of channels. The upscaling process of multi-level SOPA is as follows Figure 9 As shown, the (i-1)th scale is raised to the i-th scale.

[0125] (2) Deep Feature Aggregation (DFA).

[0126] For most convolutional layers where there is no resolution scaling, “SConv k 3 , C” to aggregate the features of neighboring voxels at the same scale. To characterize the spatial dependencies between voxel neighbors, a deep IRN block consisting of 3 basic IRN units can be applied.

[0127] (3) Occupied output layer (OOL).

[0128] The OPA model is then described in detail. For the last occupancy output layer (OOL), the OPA model can be composed of 3 convolutional layers and 1 activation layer (Sigmoid layer) to derive the occupancy probability p in the range of [0, 1] for the dense object PCG, as shown in Figure 7 As shown in (b) in .

[0129] To compress sparse LiDAR point clouds, the OOL embedded in the SOPA (position) model removes the Sigmoid layer and reduces the number of output channels of the last convolutional layer from 1 to 1. Figure 10 ) expands to 3( Figure 11 ) in order to directly derive the three coordinate offsets. Figure 10 An example of probabilistic thresholding of a dense object point cloud. Figure 11 This is an example of Position Offset Adjustment (POA) for sparse LiDAR point clouds.

[0130] Lossless SOPA.

[0131] The compression performance of the learning-based encoder depends on the efficiency of the underlying SOPA engine used for context modeling. Multi-level SOPA gradually estimates the pMP-POV by leveraging the correlation between the previous lower-scale POV and the causal neighbors at the same scale. The causal neighbors have been processed and used as prior knowledge for processing the current element. After that, the multi-level SOPA architecture mainly relies on permuting the MP-POV groups (e.g., Figure 12 The method of using the elements from G1 to G8 in the dataset to explore the dependencies between groups is used. Figure 12 An example of levels 1 / 3 / 8 grouping 8 labeled MP-POVs is shown.

[0132] Here, different groups can be arranged to implement multi-level computations and process groups of elements at the same stage simultaneously. The POV just determined in the previous stage is used as a priori for processing MP-POV in the subsequent stage, effectively revealing neighborhood correlations.

[0133] Level 8 SOPA.

[0134] Considering any set of “8 MP-POVs” sampled from the corresponding POV at the previous scale, the intuitive solution is to classify each element into a separate group, e.g. Figure 12 G1, G2, ..., G8 are shown. The same labeling is applied to all "8 MP-POV" sets. Therefore, the MP-POV labeled "1" (i.e., G1 MP-POV) will be processed simultaneously in the first stage (i.e., "S.1"), followed by the MP-POV labeled "2" (i.e., G2 MP-POV in the second stage "S.2"), until all 8 groups are traversed.

[0135] Implementation Figure 9 The steps for the 8-level SOPA are as follows:

[0136] Step 1: By using stacked DFA blocks and VSL blocks, all MP-POVs are upscaled from the corresponding POVs of the previous lower scale and divided into 8 groups from G1 to G8. Multi-level SOPA is applied to process the grouped elements from the first group G1 to the last group G8, and the elements in the same group are processed in parallel.

[0137] Step 2: At level 1, the G1 MP-POV is processed using stacked DFA blocks and OOL blocks to determine the pMP-POV of the G1 MP-POV so that the true value voxel occupancy information can be compressed into the bitstream in the encoder or the bitstream can be parsed in the decoder to identify POV and NOV. It should be noted that the decoded POV and associated features (i.e. Figure 9 The dark grey filled “1” in the second level of the ) to process the MP-POV in the subsequent level and trim the NOV immediately, i.e. the top left corner “1” in the first level is Figure 9 NOV to be removed in level 2.

[0138] Step 3: For level 2 and the remaining levels, the calculation is the same as level 1, but the input data is slightly different. As mentioned above, the POV and its features from the previous level are used as a priori to process the MP-POV in the subsequent levels for better occupancy probability estimation.

[0139] SLNE-enhanced SOPA.

[0140] Figure 13 The SLNE between the i-th scale and the (i-1)-th scale is shown. Similar to the SOPA model, the same SLNE is applied to any two adjacent scales. As can be seen, except that the sparse tensor POV i Geometric downscaling to POV i-1 In addition, SLNE also aggregates the local neighborhood changes of each POV as the characteristic attribute F of POV i-1 Therefore, POV i-1 The occupancy status and characteristic attributes of each POV in the video are compressed into the bitstream.

[0141] The two-scale SLNE model uses 3 DFA blocks and 2 “VSL 2 3 ↓” blocks are interleaved to perform feature downscaling and embedding; correspondingly, a pair of “VSL 2 3 The ↑" and DFA blocks are used for feature upscaling. Quantization (Q), which is widely used in learning-based image / video coding, is applied, where uniform noise injection is used during training and rounding is used during inference. A factorized entropy model is used to compress features. At each scale, the occupancy state and feature attributes of the sparse tensor are separately encoded and reused in the bitstream.

[0142] The decoder receives the reconstructed occupancy state and features of each POV at the (i-1)th scale, where the reconstructed occupancy state and features of each POV at the (i-1)th scale are fed into the SOPA engine to derive the occupancy probability of the MP-POV at the i-th scale. Occupancy reconstruction is achieved by encoding and decoding the bitstream related to the occupancy state using the estimated MP-POV probability; and correspondingly, feature reconstruction stacks the DFA block and VSL block to increase the decoded feature scale by 2 times on the three axes. Figure 13 As shown, SLNE related feature attribute processing (e.g., downscaling, encoding, decoding, and upscaling) is contained in two consecutive scales. According to a large number of simulations, stacking 3 DFA blocks and 2 VSL blocks interleaved before quantization can well balance the compactness and efficiency of quantized features in order to best estimate the occupancy probability of MP-POV in the i-th scale tensor. The stacking of 1 DFA block and 1 VSL block to upscale the decoded features is to match the previous lower scale (e.g., Figure 13 The geometric resolution of the sparse tensor at the (i-1)th scale in .

[0143] It harms SOPA.

[0144] (1) Probability threshold of dense point cloud.

[0145] By using Figure 8 The OOL block in SOPA shown in the figure is used to derive the occupancy probability of each MP-POV in the lossless mode, and the lossy mode sequentially applies the probability threshold t to classify and determine the binary occupancy state. Figure 10 As shown in Figure 2, if the probability pMP-POV>t, then MP-POV is POV; otherwise, MP-POV is NOV. t can be set adaptively according to the number of POVs at each scale.

[0146] (2) Used for position offset adjustment of sparse point clouds.

[0147] The lossy SOPA based on probability threshold works well for compression of dense point clouds. In order to process sparse point clouds as LiDAR, the occupancy probability approximation in the native SOPA model is replaced by the occupied position adjustment. Figure 11 In

[15] , occupied position adjustment is called "SOPA (position)". This method includes a DFA block and a modified OOL block to directly estimate the coordinate offset. In the OOL block, the Sigmoid layer is removed and the output layer is set with 3 channels to generate the position offset for adjustment.

[0148] like Figure 11 As shown, each sparse tensor at the mth scale is scaled to the Nth scale (N>m) in one step.m ,y m , z m ), the corresponding POV at the Nth scale is:

[0149]

[0150] in, as the position offset estimated according to the proposed SOPA(position).

[0151] For example, in Figure 14 A unified learning based framework is described in

[15] , which has sequential application in lossy and lossless stages. A general architecture with m scales coded losslessly and (Nm) scales coded in lossy mode is provided. Figure 15 This is a schematic diagram of the application scenario of the geometric encoder. Figure 15 As shown, (a) is lossless static coding, (b) is lossy static coding, and (c) is lossy dynamic coding.

[0152] For example, Figure 16 This is a flowchart of the OPU implementation details. Figure 16 As shown, (a) is lossless OPU, (b) is lossy OPU, and (c) is dynamic coding component. Among them, lossless OPU uses multi-level CPA (MsCPA) to estimate the loss from the first group of Os l , g1 to group 8 Os l , Os at the subscale level of g8 l The occupancy probability of elements in the image is determined by the fractal dimension. Lossy OPU uses fractal dimensioning to guide CPR-D to refine shifted POVs or to guide CPR-V to restore lost POVs. For example, the lossless OPU and lossy OPU mentioned above only utilize low-scale spatial priors for static encoding. By distorting the temporal prior information of the lossless and lossy modes, dynamic encoding can be flexibly achieved.

[0153] Lossless OPU.

[0154] For a given geometric tensor Os l 7. Lossless OPU input lower scale prior Os l-1 To execute Os for arithmetic coding l The conditional probability approximation (CPA) of each relevant element in the superset, e.g.

[0155] P(Os l |Of s l-1 )=p(Os l |Os l-1 )=CPA(Os l-1 ).

[0156] The strict definition of the lower scale prior should be Of s l-1 , because Of s l-1 It can be a decoded reconstruction using the underlying compression noise, e.g. Or it can enhance high-dimensional features learned from spatial neighbors or temporal references, e.g. Figure 16 In lossless mode, Of s l-1 =Os l-1 .

[0157] Os l-1 Each POV in the image is enlarged to 8 MP-POVs contained in the local 2×2×2 image (e.g. Figure 16 (a)). Such MP-POV patch is similar to the one provided by Os l The corresponding 2×2×2 voxel cubes consisting of interconnected non-POV and POV are geometrically aligned. Each MP-POV represents a probability, which can then be used to losslessly compress the corresponding voxel element (e.g., POV or non-POV), or perform a probabilistic determination to classify the MP-POV as POV or non-POV for use in predictive reconstruction in a lossy mode.

[0158] like Figure 17 As shown in Figure 2, a DNN block can be implemented by simply stacking three classic ResNet (IRN) blocks or three NPFormer (Neighborhood Point Former) blocks. IRN includes sparse convolutions, while NPFormer relies on Neighborhood Point Attention (NPA).

[0159] This DNN block can be used to estimate shifted residuals, such as the shifted residuals in the PR unit of CPR-D, for coordinate refinement;

[0160] This DNN block can also be applied to the PM unit to generate the conditional context of the compressed quantized latent feature Fe^ in FeCPA.

[0161] Binary downsampling (DS↓) is often integrated with DNN blocks to build AT (Analysis Transform) or extractor units for neighborhood correlation representation and embedding.

[0162] Binary upsampling (US↑) is used to scale s l-1 The POV below is expanded to scale s l The corresponding 2×2×2 MP-POV patch below (as shown in the CPA model).

[0163] Neighborhood attention.

[0164] The architecture of NPA is as follows Figure 17 Assume that the input of the NPA layer is composed of coordinates and features A sparse tensor O is composed of , and a kNN search is performed on each element in O to form a tensor Then use the relative position to expand the tensor, that is:

[0165]

[0166] This is called Positional Embedding.

[0167] Assume Q, K kNN and V kNN are query vector, key vector and value vector respectively. Quantized representation From F in Linear transformation; and By F e The weights of these three linear transformations are and NPA is:

[0168]

[0169] Output {C out , F out}. C out -C in The same resolution is involved in NPA. The kNN neighborhood and attention mechanism in NPA help the network adaptively exploit local correlations regardless of the density of the underlying content. In contrast, the fixed receptive field setting in sparse convolution may not include enough (and effective) neighbors, especially for sparse content.

[0170] In the current model, the NPA representation uses a linear transformation from F to Q, however, limiting the possibility of assigning a multidimensional representation of different sparse tensor transformations with contributions from the transformed dimensions to the reconstructed signal.

[0171] It should also be understood that a quantizer is a process that discretizes its input by performing a mapping from a continuous set to a discrete set. For example, consider a K-point regular scalar quantizer Q with its output levels C = {ci; i = 1, 2, ..., K}, and a partition unit i = 1, 2, …, K} and the mapping ci defines that when s ∈ [pi-1, pi), the mapping ci = Q(s). In addition, a unit Q-1(ci) = [pi-1, pi) is defined as the inverse image of the output level ci under Q. For i = 1, if p0 = -∞, the closed interval [p0, p1) is replaced by the open interval (p0, p1).

[0172] Figure 18This is a schematic diagram of the linear quantization process, where Δ represents the spacing. With linear quantization, the finite set of values ​​from which to choose is evenly spaced to represent a continuous signal. B bits are used to represent the amplitude of a sample, and a sample can be mapped to only one of 2^B possible levels. For a signal F within the range R, the spacing D between these levels is equal to D = R / 2^B.

[0173] A sign-magnitude truncation method is used, which can map the input value F to the closest level Q whose absolute value is smaller than the absolute value of F. (floor indicates that F is a positive value, and ceil indicates that F is a negative value).

[0174] In most cases, the nature of the quantized value of the latent feature F is mapped to a "0" value.

[0175] The current binarization process is based on a fixed bit depth representation of the quantized latent feature representation, using a fixed length model. Therefore, each value should be encoded using 8 bits of precision to represent a value.

[0176] The current entropy coding engine is then implemented using adaptive arithmetic coding with factorization:

[0177]

[0178] For each individual symbol, the probability The distribution is specified as a random distribution function, also known as the cumulative distribution function (CDF), which is an important tool for describing the probability of a random variable taking on a certain value. Here, the probability distribution is static and represented using a symbol-based encoding.

[0179] Based on this, an embodiment of the present application provides a coding method to determine the quotient and remainder of a value to be encoded; based on the quotient of the value to be encoded, determine a first group of bit information; based on the remainder of the value to be encoded, determine a second group of bit information; encode the first group of bit information and the second group of bit information respectively, and write the obtained coded bits into the code stream in sequence. An embodiment of the present application also provides a coding method to parse the first group of bit information in the code stream to determine the quotient of the value to be decoded; parse the second group of bit information in the code stream to determine the remainder of the value to be decoded; determine the value to be decoded based on the quotient of the value to be decoded and the remainder of the value to be decoded. Wherein, the second group of bit information includes: bit information of a preset length, or bit information of (preset length + 1).

[0180] That is to say, the embodiment of the present application can introduce a new binarization method before entropy coding, for example, it can be binarization processing using the Golomb-Rice code method, and the remainder can be encoded by bit information of a preset length, or it can be encoded by bit information of (preset length + 1); then the decoding end performs corresponding decoding on the quotient and the remainder respectively to obtain the value to be decoded; and the value to be encoded here is obtained by zero-run processing, so that effective potential feature data representation and encoding can be achieved, coding bits are saved, compression efficiency is improved, and entropy coding and decoding performance can be improved.

[0181] The embodiments of the present application will be described in detail below with reference to the accompanying drawings.

[0182] In one embodiment of the present application, Figure 19 1 is a flowchart of a decoding method provided in an embodiment of the present application. Figure 19 As shown, the method may include:

[0183] S1901: parse the first group of bit information in the code stream to determine the quotient of the value to be decoded.

[0184] S1902: parse the second group of bit information in the code stream to determine the remainder of the value to be decoded.

[0185] It should be noted that this decoding method can be applied to a decoder, specifically a method for efficiently representing sparse tensors, and more specifically, a method for binarizing the latent features of sparse tensors used in learning-based point cloud coding representation. By introducing a new binarization method, compression efficiency is improved.

[0186] It should also be noted that, in the embodiment of the present application, the value to be decoded here can be an absolute value, in other words, the value to be decoded is a non-negative integer. In some embodiments, the value to be decoded can be a non-negative integer obtained after zero-run processing.

[0187] In the embodiment of the present application, for the current point cloud, the value to be decoded may also be a non-negative integer obtained by zero-run processing of the quantized array of the potential features of the current point cloud.

[0188] In addition, in an embodiment of the present application, for a code stream, the first group of bits precedes the second group of bits. The first group of bits is used to determine the quotient of a value to be decoded, and the second group of bits is used to determine the remainder of the value to be decoded. In some embodiments, a delimiter is provided between the first group of bits and the second group of bits. The method may further include: skipping the delimiter before parsing the second group of bits in the code stream.

[0189] That is, in the embodiment of the present application, the first group of bit information in the code stream is first parsed to determine the quotient of the value to be decoded; then the delimiter is skipped; and then the second group of bit information in the code stream is parsed to determine the remainder of the value to be decoded.

[0190] For example, in an embodiment of the present application, the decoding format of the code stream may be: <first group of bit information><delimiter><second group of bit information>; or, <quotient code><delimiter><remainder code>. In a specific implementation, the delimiter may be represented by a 0 bit, and the delimiter is 1 bit long.

[0191] In some embodiments, parsing the first group of bit information in the code stream to determine the quotient of the value to be decoded may include: parsing the first group of bit information in the code stream based on a unary code to determine the quotient of the value to be decoded.

[0192] In the embodiments of the present application, unary code, also known as "run-length encoding" or "run-length encoding," is an encoding method that represents data by counting the number of consecutive identical symbols. In one possible implementation, the decoding rule is as follows: for a symbol x to be decoded (x>=0), the first group of bit information may include x "first symbols." The first symbol can be 1 or 0.

[0193] For example, for a symbol x to be decoded (x>=0), the first group of bit information may include x "1s." Here, assuming the first group of bit information is "111," the value obtained after decoding based on the unary code is 3. Assuming the first group of bit information is "11111," the value obtained after decoding based on the unary code is 5.

[0194] In some embodiments, the quotient of the value to be decoded is related to the bit length in the first group of bit information. Wherein, the first group of bit information includes identical symbols, and the bit length here is the number of consecutive identical symbols. Exemplarily, the first group of bit information includes only 1 bits. Then, in an embodiment of the present application, the number of 1s in the first group of bit information can be counted, and the resulting count result can be used as the quotient of the value to be decoded.

[0195] It should also be noted that in this embodiment of the present application, the first group of bit information is located at the beginning of the code stream of the value to be decoded. Therefore, the number of consecutive identical symbols (e.g., 1) at the beginning of the code stream can be counted to obtain the quotient of the value to be decoded. If there are q consecutive 1s at the beginning of the code stream, then the quotient of the value to be decoded is q.

[0196] It is understandable that in the embodiment of the present application, the second group of bit information may include: bit information of a preset length, or bit information of (preset length+1), wherein the value of the preset length may be related to a preset parameter.

[0197] In some embodiments, the value of the preset parameter may be a fixed integer value. The preset parameter may be represented by M, that is, the value of M may be fixed to a certain integer value. Accordingly, the value of the preset length may be a fixed value related to M.

[0198] In a possible implementation, the method may further include: setting the value of the preset length to be equal to the logarithm of the preset parameter with base 2. Exemplarily, assuming the preset length is b, then b=log2M.

[0199] In another possible implementation, the method may further include: presetting the parameter to 2 raised to the power of b, where b represents a preset length. That is, M=2 b .

[0200] In some embodiments, parsing the second group of bits in the bitstream to determine the remainder of the value to be decoded may include parsing the second group of bits in the bitstream based on a Golomb-Rice code to determine the remainder of the value to be decoded. That is, in this embodiment of the present application, the remainder of the value to be decoded may be determined based on bit b or bit (b+1) in the bitstream.

[0201] In one possible implementation, for determining the remainder of the value to be decoded, see Figure 20 , the method may include:

[0202] S2001: parse bit information of a preset length in a code stream to determine a first value.

[0203] S2002: When the first value is less than a first threshold, set the remainder of the value to be decoded to be equal to the first value.

[0204] S2003: When the first value is greater than or equal to the first threshold, parse the bit information of (preset length+1) in the code stream to determine the second value.

[0205] S2004: Set the remainder of the value to be decoded to be equal to the difference between the second value and the first threshold.

[0206] In an embodiment of the present application, by parsing the bit information of b bits after the delimiter, a first value r' can be determined; when the first value r' is less than the first threshold, the remainder r of the value to be decoded is r'; otherwise, when the first value r' is greater than or equal to the first threshold, then by parsing the bit information of (b+1) bits after the delimiter, a second value r" can be determined, and the remainder r of the value to be decoded is the difference between r" and the first threshold.

[0207] In some embodiments, the method may further include: determining a first threshold value according to a preset length and a preset parameter. In other words, the first threshold value is related to the preset length b and the preset parameter M.

[0208] In a possible implementation, the first threshold may be set to be equal to the difference between 2 raised to the power of (preset length + 1) and the preset parameter. b+1 -M.

[0209] That is, after skipping the delimiter, for the remainder of the value to be decoded, assuming b = log2M, then the first value r' can be determined based on the bit information of b bits after the delimiter. b+1 -M, then the remainder of the value to be decoded r=r'; otherwise, when r'≥2 b+1 -M, then the second value r" can be determined based on the bit information of the b bits after the delimiter. At this time, the remainder r of the value to be decoded = r"-2 b+1 +M.

[0210] It should be noted that in the embodiment of the present application, in the process of parsing the code stream, whether it is the first group of bit information or the second group of bit information, each bit therein (or called a "binary symbol") can be obtained using context-adaptive binary arithmetic decoding, thereby having better compression efficiency.

[0211] S1903: Determine the value to be decoded according to the quotient of the value to be decoded and the remainder of the value to be decoded.

[0212] In an embodiment of the present application, after obtaining the quotient of the value to be decoded and the remainder of the value to be decoded, the value to be decoded can be determined. One possible implementation is to set the value to be decoded equal to the sum of the product of the quotient of the value to be decoded and a preset parameter and the remainder. For example, assuming the value to be decoded is N, then N = q*M+r.

[0213] It can also be understood that since the value to be decoded can be a non-negative integer obtained after the quantization array of the potential feature of the current point cloud is processed by zero-run; then in some embodiments, the method can also include: after obtaining the value to be decoded, determining at least one set of zero-run parameters; wherein each set of zero-run parameters includes a zero-run value and a non-zero element; based on at least one set of zero-run parameters, determining the quantization array of the potential feature; dequantizing the quantization array of the potential feature to determine the feature vector of the potential feature.

[0214] In the embodiment of the present application, any non-negative integer can use the above-mentioned binarization method for determining the value to be decoded. Figure 19 The decoding process shown can decode and restore at least one set of zero-run parameters, such as at least one zero-run value and at least one non-zero element; then zero-run decoding is performed based on at least one set of zero-run parameters, so as to obtain a quantized array of potential features; and then the quantized array of potential features is dequantized to determine the feature vector of the potential features.

[0215] In the embodiment of the present application, taking one set of zero-run parameters as an example, for the zero-run value, since the encoder directly encodes the zero-run value as the value to be encoded, the decoding method may further include: determining the zero-run value based on the value to be decoded. In other words, during the decoding process of the zero-run value, the decoded value to be decoded may be directly used as the zero-run value.

[0216] In addition, in the embodiment of the present application, for non-zero elements, in order to save coding bits, since the encoding end encodes the non-zero element minus 1 as the value to be encoded, the decoding end may further include: adding 1 to the value to be decoded to determine the non-zero element. In other words, during the decoding process of the non-zero element, the decoded value to be decoded can be added by 1 and used as the corresponding non-zero element.

[0217] For example, suppose the decoded set of values ​​is {3, 12}, where 3 is a zero-run value and (12+1) is a non-zero element; then after zero-run decoding, the quantized array of potential features is: 0 0 0 13. Suppose the decoded set of values ​​is {3, 12; 2, 0}, where 3 is the first zero-run value, (12+1) is the first non-zero element, 2 is the second zero-run value, and (0+1) is the second non-zero element; then after zero-run decoding, the quantized array of potential features is: 0 0 0 13 0 0 1.

[0218] It can also be understood that in the embodiment of the present application, the quantized array of potential features can be dequantized using a uniform quantization factor, or the quantized array of potential features can be dequantized using a non-uniform quantization factor, without any limitation here.

[0219] In a possible implementation, the method may include: determining a uniform quantization factor corresponding to a eigenvector of the potential feature; and dequantizing a quantized array of the potential feature based on the uniform quantization factor to determine the eigenvector of the potential feature.

[0220] In the embodiment of the present application, the uniform quantization factor means that each feature element in the feature vector of the potential feature uses the same quantization factor for quantization and dequantization operations. Here, the uniform quantization factor can also be regarded as linear quantization, as mentioned above. Figure 16 shown.

[0221] In another possible implementation, the method may include: determining a non-uniform quantization factor corresponding to a eigenvector of the potential feature; and dequantizing a quantized array of the potential feature based on the non-uniform quantization factor to determine the eigenvector of the potential feature.

[0222] In the embodiment of the present application, the non-uniform quantization factor means that each feature element in the feature vector of the potential feature uses its own quantization factor for quantization and dequantization operations. Here, the non-uniform quantization factor can also be regarded as nonlinear quantization, such as Figure 21 shown.

[0223] In the embodiment of the present application, the non-uniform quantization factor can be generated from the uniform quantization factor, wherein the input signal uses a non-decreasing smoothing function Transformed, then quantized using a uniform quantization factor Q with K equally spaced levels on (0, 1), and finally quantized by the expansion function To deal with it, please refer to Figure 21 The non-uniform quantization process shown.

[0224] In a possible implementation, for determining the non-uniform quantization factor, taking the random vector s as an example, the compression function can be adjusted To optimize the non-uniform quantizer to minimize the random vector Its quantitative representation The distortion between Exemplarily, for a given random vector s and MSE distortion metric, the optimization is performed by solving the following equation:

[0225]

[0226] Here, the minimization is performed over all K levels of scalar quantizers. A standard way of doing this may be through the Lloyd algorithm, which iteratively updates the division unit (ie, the size of the quantization factor) and the output level (ie, the quantized value) by applying the conditions for the optimal solution of the quantizer.

[0227]

[0228] Here, the minimization is performed on all K levels of regularized scalar quantizers and obtained by the solver like Figure 22 As shown. Among them, x represents the original vector in the compressed network, y represents the compressed value, and z represents the quantized value. Represents the reconstructed value after the network is restored.

[0229] In another possible implementation, after the encoder determines the non-uniform quantization factor corresponding to the eigenvector of the latent feature, it can also be directly written into the bitstream. Accordingly, the method can further include parsing the bitstream to determine the non-uniform quantization factor corresponding to the eigenvector of the latent feature. In this way, the decoder can directly obtain the non-uniform quantization factor corresponding to the eigenvector of the latent feature by parsing the bitstream, and then dequantize the quantized array of the latent feature to obtain the eigenvector of the latent feature.

[0230] The embodiment of the present application provides a decoding method, which parses the first group of bit information in the code stream to determine the quotient of the value to be decoded; parses the second group of bit information in the code stream to determine the remainder of the value to be decoded; and determines the value to be decoded based on the quotient of the value to be decoded and the remainder of the value to be decoded. The second group of bit information includes: bit information of a preset length, or bit information of (preset length + 1). In this way, a new binarization method is used for encoding processing, for example, binarization processing can be performed using the Golomb-Rice code method; the quotient can be obtained by decoding a unary code; the remainder can be obtained by decoding the bit information of a preset length, or it can be obtained by decoding the bit information of (preset length + 1) to obtain the value to be decoded; and the value to be decoded here is obtained after zero-run processing, so that coding bits can be saved, thereby improving entropy decoding performance.

[0231] In another embodiment of the present application, Figure 23 1 is a flow chart of an encoding method provided in an embodiment of the present application. Figure 23 As shown, the method may include:

[0232] S2301, determine the quotient and remainder of the value to be encoded.

[0233] It should be noted that this encoding method can be applied to encoders, specifically a method for efficiently representing sparse tensors, and more specifically, a method for binarizing the latent features of sparse tensors used in learning-based point cloud coding representation. By introducing a new binarization method, compression efficiency is improved.

[0234] It should also be noted that, in the embodiments of the present application, the value to be encoded here can be an absolute value, in other words, the value to be encoded is a non-negative integer. In some embodiments, the value to be encoded can be a non-negative integer obtained after zero-run processing.

[0235] In the embodiment of the present application, for the current point cloud, the value to be encoded may also be a non-negative integer obtained by zero-run processing of the quantized array of the potential features of the current point cloud.

[0236] In an embodiment of the present application, after obtaining the value to be encoded, the quotient and remainder of the value to be encoded can be determined. In some embodiments, the method may include: performing a division operation on the value to be encoded and a preset parameter to determine the quotient of the value to be encoded; and performing a subtraction operation on the value to be encoded and the product of the quotient of the value to be encoded and the preset parameter to determine the remainder of the value to be encoded.

[0237] In the embodiment of the present application, the value of the preset parameter can be a fixed integer value. The preset parameter can be represented by M, that is, the value of M can be fixed to a certain integer value.

[0238] For example, assuming that the value to be encoded is N and the quotient of the value to be encoded is q, then Or it can be expressed as:

[0239] For the remainder r of the value to be encoded, r=N-qM, or it can also be expressed as: r=Nmodulo(M).

[0240] S2302: Determine a first group of bit information based on the quotient of the value to be encoded.

[0241] S2303: Determine a second group of bit information based on the remainder of the value to be encoded.

[0242] In an embodiment of the present application, after obtaining the quotient of the value to be encoded, a corresponding first set of bit information may be generated. In some embodiments, the method may include: binarizing the quotient of the value to be encoded based on a unary code to determine the first set of bit information.

[0243] In the embodiments of the present application, unary code, also known as "run-length encoding" or "run-length encoding," is an encoding method that represents data by counting the number of consecutive identical symbols. In one possible implementation, the encoding rule is as follows: for a symbol x to be encoded (x >= 0), the first group of bit information may include x "first symbols." The first symbol may be 1 or 0.

[0244] For example, for a symbol x to be encoded (x>=0), the first group of bit information may include x "1s." For example, if the value to be encoded is 3, then after encoding based on the unary code, the first group of bit information obtained may be "111"; if the value to be encoded is 5, then after encoding based on the unary code, the first group of bit information obtained may be "11111."

[0245] In another possible implementation, the encoding rule may be as follows: for the symbol x to be encoded (x>=0), the first group of bit information may include: x "1"s followed by one "0". For example, if the value to be encoded is 3, then after encoding based on the unary code, the first group of bit information obtained may be "1110"; if the value to be encoded is 5, then after encoding based on the unary code, the first group of bit information obtained may be "111110". The "0" can also be regarded as a separator, used to distinguish the first group of bit information from the second group of bit information in the code stream.

[0246] In some embodiments, the quotient of the value to be encoded is related to the bit length in the first group of bit information. Wherein, the first group of bit information includes the same symbol, and the bit length here is the number of consecutive identical symbols. Exemplarily, the first group of bit information includes 1 bit, then in an embodiment of the present application, for the quotient q of the value to be encoded, a symbol string of q length containing 1 bit can be written in the first group of bit information. Alternatively, the first group of bit information includes 0 bits, then in an embodiment of the present application, for the quotient q of the value to be encoded, a symbol string of q length containing 0 bits can be written in the first group of bit information.

[0247] It is understandable that in the embodiment of the present application, the second group of bit information may include: bit information of a preset length, or bit information of (preset length+1), wherein the value of the preset length may be related to a preset parameter.

[0248] In some embodiments, the value of the preset parameter may be a fixed integer value, where the preset parameter is represented by M. Accordingly, the value of the preset length may be a fixed value related to M.

[0249] In a possible implementation, the method may further include: setting the value of the preset length to be equal to the logarithm of the preset parameter with base 2. Exemplarily, assuming the preset length is b, then b=log2M.

[0250] In another possible implementation, the method may further include: presetting the parameter to 2 raised to the power of b, where b represents a preset length. That is, M=2 b .

[0251] In some embodiments, determining the second set of bit information based on the remainder of the value to be encoded may include: binarizing the remainder of the value to be encoded based on a Golomb-Rice code to determine the second set of bit information.

[0252] That is to say, in the embodiment of the present application, the remainder r of the value to be encoded can be encoded based on the b bits of the Rice code, or can be encoded based on a selection between the b bits and (b+1) bits of the Golomb code.

[0253] In one possible implementation, determining the second group of bit information based on the remainder of the value to be encoded may include: when the remainder of the value to be encoded is less than a first threshold, binarizing the remainder of the value to be encoded to determine bit information of a preset length; and determining the bit information of the preset length as the second group of bit information.

[0254] In another possible implementation, determining the second group of bit information based on the remainder of the value to be encoded may include: when the remainder of the value to be encoded is greater than or equal to a first threshold, binarizing the remainder of the value to be encoded to determine the bit information of (preset length + 1); and determining the bit information of (preset length + 1) as the second group of bit information.

[0255] That is, in the embodiment of the present application, if the remainder r of the value to be encoded is less than the first threshold, then b bits can be used to encode r in the binary representation; otherwise, if the remainder r of the value to be encoded is greater than or equal to the first threshold, then (b+1) bits can be used to encode r+2 in the binary representation. b+1 -M.

[0256] In some embodiments, the method may further include: determining a first threshold value according to a preset length and a preset parameter. In other words, the first threshold value is related to the preset length b and the preset parameter M.

[0257] In a possible implementation, the first threshold may be set to be equal to the difference between 2 raised to the power of (preset length + 1) and the preset parameter. b+1 -M.

[0258] For example, for the remainder r of the value to be encoded, assuming b = log2M, then when r'<2 b+1 -M, the second group of bit information includes b bits, that is, b bits are used to encode r; otherwise, when r'≥2 b+1 -M, the second group of bit information includes (b+1) bits, that is, (b+1) bits are used to encode r+2 b+1 -M.

[0259] In short, in the embodiment of the present application, both q and r can be encoded using a variable number of bits. q can be encoded by a unary code; r can be encoded by b bits of a Rice code, or by a combination of b bits and (b+1) bits of a Golomb code, where b = [log2(M)]. If r < 2 b+1 -M, then b bits are used to encode r; otherwise, (b+1) bits are used to encode r. It should be noted that when M is a power of 2, b bits can be used to encode all values ​​of r.

[0260] S2304: Encode the first group of bit information and the second group of bit information respectively, and write the obtained encoded bits into the bit stream in sequence.

[0261] It should be noted that in the embodiments of the present application, the first group of bits precedes the second group of bits in the bitstream. The first group of bits is used to determine the quotient of the value to be encoded, and the second group of bits is used to determine the remainder of the value to be encoded. In some embodiments, a separator is provided between the first group of bits and the second group of bits. The method may further include: encoding the first group of bits, the separator, and the second group of bits, respectively, and sequentially writing the resulting encoded bits into the bitstream.

[0262] That is to say, for the numerical value to be encoded, first encode the first group of bit information corresponding to the quotient in the code stream, and then encode the 1-bit separator; then encode the second group of bit information corresponding to the remainder in the code stream. Exemplarily, in an embodiment of the present application, the encoding format in the code stream can be: <first group of bit information><separator><second group of bit information>; or, <quotient code><separator><remainder code>. In a specific implementation, the separator can be represented by 0 bits (bit), and the length of the separator is 1 bit. In addition, considering that the quotient code represented by the unary code is usually composed of x "1"s plus a "0"; at this time, the "0" is the separator, so the encoding format in the code stream can also be regarded as: <quotient code><remainder code>.

[0263] It should also be noted that in an embodiment of the present application, during the encoding process, whether it is the first group of bit information or the second group of bit information, each bit therein (or called a "binary symbol") can be entropy coded using context-adaptive binary arithmetic coding, thereby having better compression efficiency.

[0264] It is understandable that in the embodiments of the present application, any non-negative integer can use the above-mentioned encoding method for binarizing the value to be encoded. For example, the value to be encoded here can be a non-negative integer obtained after the quantization array of the potential features of the current point cloud is processed by zero run. Then in some embodiments, see Figure 24 , the method may further include:

[0265] S2401, determine the sparse tensor of the current point cloud.

[0266] S2402, performing feature extraction on the sparse tensor to determine the feature vector of the potential feature.

[0267] S2403, quantize the feature vector of the potential feature to determine the quantized array of the potential feature.

[0268] S2404 , performing zero-run processing on the quantized array of potential features to determine at least one set of zero-run parameters; wherein each set of zero-run parameters includes a zero-run value and a non-zero element.

[0269] S2405 : Determine at least one value to be encoded based on the zero-run values ​​and non-zero elements in at least one set of zero-run parameters.

[0270] In an embodiment of the present application, a multi-scale neural network model can be used to scale the current point cloud to obtain a sparse tensor of the current point cloud. Feature extraction can then be performed on the sparse tensor to obtain a eigenvector of the potential feature. The eigenvector of the potential feature can then be quantized to determine a quantized array of the potential feature. Finally, after obtaining the quantized array of the potential feature, zero-run processing can be performed on the quantized array of the potential feature to obtain at least one set of zero-run parameters. Based on the zero-run values ​​and non-zero elements in the at least one set of zero-run parameters, at least one value to be encoded is determined.

[0271] In some embodiments, zero-run processing is performed on the quantization array of potential features to determine at least one set of zero-run parameters, which may include: based on the i-th element in the quantization array, judging whether the value of the i-th element is equal to 0; when the value of the i-th element is equal to 0, adding 1 to the first variable, and updating i with i+1, and continuing to judge whether the value of the i-th element is equal to 0; when the value of the i-th element is not equal to 0, determining the value of the first variable as the zero-run value, and determining the i-th element as a non-zero element, and updating i with i+1; when i is not equal to T, initializing the first variable to 0, and continuing to judge whether the value of the i-th element is equal to 0, until i is equal to N, to obtain at least one set of zero-run parameters.

[0272] In the embodiment of the present application, the initialization value of i is 0. Here, i is an integer greater than or equal to 0 and less than or equal to T, where T represents the number of elements in the quantized array. In addition, the first variable can be represented by k, where k is an integer greater than or equal to 0.

[0273] In the embodiment of the present application, each set of zero-run parameters needs to be encoded. In one possible implementation, for zero-run encoding, see Figure 25 , the method may include:

[0274] S2501, i=0.

[0275] S2502, k=0.

[0276] S2503, determine val[i]==0.

[0277] S2504, i=i+1.

[0278] S2505, k=k+1.

[0279] S2506, set the zero run to k.

[0280] S2507, generate a binary symbol string of k.

[0281] S2508: Perform entropy coding on the binary symbol string of k.

[0282] S2509, generate a binary symbol string of val[i]-1.

[0283] S2510, perform entropy coding on the binary symbol string of val[i]-1.

[0284] S2511, i=i+1.

[0285] S2512, judge i==T.

[0286] S2513: Output the encoded code stream of the val[] array.

[0287] It should be noted that the input is the val[] array, whose size is T elements, where T is a positive integer; the output is the encoded bitstream of the val[] array. Furthermore, for step S2503, if the result is yes, steps S2504-S2505 are executed, and then the process returns to step S2503; if the result is no, steps S2506-S2512 are executed. For step S2512, if the result is yes, step S2513 is executed; if the result is no, the process returns to step S2502. In this way, at least one set of zero-run parameters can be obtained.

[0288] It should also be noted that, in the embodiment of the present application, taking one set of zero-run parameters as an example, for a zero-run value, the method may include: when the zero-run value is non-zero, determining the zero-run value as the value to be encoded. In other words, during the encoding process of the zero-run value, the non-zero zero-run value can be directly used as the value to be encoded.

[0289] In addition, in an embodiment of the present application, for non-zero elements, in order to save coding bits, the method may include: when the value of the non-zero element minus 1 is non-zero, determining the value of the non-zero element minus 1 as the value to be encoded. In other words, during the encoding process of the non-zero element, the value of the non-zero element minus 1 can be used as the value to be encoded.

[0290] For example, assuming that the quantization array of the potential feature is: 0 0 0 13, then after zero-run encoding processing, the zero-run value k=3 and the non-zero element val[3]-1=12 can be obtained; therefore, the set of values ​​to be encoded is {3,12}. Assuming that the quantization array of the potential feature is: 0 0 013 0 0 1, then after zero-run encoding processing, the first zero-run value k=3, the first non-zero element val[3]-1=12, the second zero-run value k=2, and the second non-zero element val[6]-1=0 can be obtained; therefore, the set of values ​​to be encoded is {3,12; 2,0}.

[0291] It should be noted that, in the embodiment of the present application, if the zero run value is equal to 0 or the non-zero element minus 1 is equal to 0, then the context-adaptive binary arithmetic coding can be used directly to perform entropy coding processing on it without performing Figure 23 The encoding process shown.

[0292] It can also be understood that in the embodiment of the present application, the feature vector of the potential feature is quantized. A uniform quantization factor can be used to quantize the feature vector of the potential feature, or a non-uniform quantization factor can be used to quantize the feature vector of the potential feature. No limitation is made here.

[0293] In a possible implementation, the method may include: determining a uniform quantization factor corresponding to a feature vector of the potential feature; and quantizing the feature vector of the potential feature based on the uniform quantization factor to determine a quantization array of the potential feature.

[0294] In the embodiment of the present application, the uniform quantization factor means that each feature element in the feature vector of the potential feature uses the same quantization factor for quantization and dequantization operations. Here, the uniform quantization factor can also be regarded as linear quantization, as mentioned above. Figure 16 shown.

[0295] In another possible implementation, the method may include: determining a non-uniform quantization factor corresponding to a feature vector of the potential feature; and quantizing the feature vector of the potential feature based on the non-uniform quantization factor to determine a quantization array of the potential feature.

[0296] In the embodiment of the present application, the non-uniform quantization factor means that each feature element in the feature vector of the potential feature uses its own quantization factor for quantization and dequantization operations. Here, the non-uniform quantization factor can also be regarded as nonlinear quantization, such as Figure 21 shown.

[0297] In the embodiment of the present application, the non-uniform quantization factor can be generated from the uniform quantization factor, wherein the input signal uses a non-decreasing smoothing function Transformed, then quantized using a uniform quantization factor Q with K equally spaced levels on (0, 1), and finally quantized by the expansion function To deal with it, please refer to Figure 21 The non-uniform quantization process shown.

[0298] In some embodiments, determining the non-uniform quantization factor corresponding to the eigenvector of the potential feature may include: performing minimum distortion measurement on the first value in the eigenvector of the potential feature and the reconstructed value of the first value, and determining the non-uniform quantization factor corresponding to the first value; wherein the first value is any value in the eigenvector of the potential feature.

[0299] In a possible implementation, for determining the non-uniform quantization factor, taking the random vector s as an example, the compression function can be adjusted

[0300] To optimize the non-uniform quantizer to minimize the random vector Its quantitative representation The distortion between Exemplarily, for a given random vector s and MSE distortion metric, the optimization is performed by solving the following equation:

[0301]

[0302] Here, the minimization is performed over all K levels of scalar quantizers. A standard way of doing this may be through the Lloyd algorithm, which iteratively updates the division unit (ie, the size of the quantization factor) and the output level (ie, the quantized value) by applying the conditions for the optimal solution of the quantizer.

[0303]

[0304] Here, the minimization is performed on all K levels of regularized scalar quantizers and obtained by the solver like Figure 22 As shown. Among them, x represents the original vector in the compressed network, y represents the compressed value, and z represents the quantized value. Represents the reconstructed value after the network is restored.

[0305] In some embodiments, the method may further include encoding the non-uniform quantization factor corresponding to the eigenvector of the latent feature and writing the resulting coded bits into the bitstream. This allows the decoder to subsequently directly parse the bitstream to obtain the non-uniform quantization factor corresponding to the eigenvector of the latent feature and then dequantize the quantized array of the latent feature to obtain the eigenvector of the latent feature.

[0306] The embodiment of the present application provides a coding method, which determines the quotient and remainder of a value to be coded; determines a first group of bit information based on the quotient of the value to be coded; determines a second group of bit information based on the remainder of the value to be coded; encodes the first group of bit information and the second group of bit information separately, and writes the obtained coded bits into the bit stream in sequence. In this way, after determining the quotient and remainder of the value to be coded, the coding end encodes them separately. A new binarization method is used for coding, for example, a Golomb-Rice code method can be used for binarization. The remainder can be encoded by bit information of a preset length, or by bit information of (preset length + 1); and the value to be coded here is obtained by zero-run processing, thereby saving coding bits and improving entropy coding performance.

[0307] In another embodiment of the present application, based on the aforementioned encoding and decoding method, the embodiment of the present application proposes various supports for multi-attribute datasets of learning-based artificial intelligence point cloud coding (AI-PCC). The method proposed in the embodiment of the present application can be used for future AI-PCC coding standards, especially AVS and MPEG. When implementing the method proposed in the embodiment of the present application, consideration is given to modifying the code stream structure, syntax, constraints, and mapping used to generate the decoded point cloud for standardization.

[0308] In another possible implementation, an embodiment of the present application provides an intermediate quantization method for a learning-based point cloud coded representation. Specifically, a method for efficiently representing sparse tensors is provided as an intermediate representation of a learning-based model for compressed point cloud transmission. Rate-distortion-based quantization can create an efficient data storage mechanism while maintaining the reconstruction fidelity of the point cloud. Furthermore, compression efficiency can be improved by introducing efficient data entropy coding using zero coefficient sequences and nonlinear quantization models.

[0309] In the embodiment of the present application, given the details and strong distribution characteristics of the data distribution, the embodiment of the present application uses non-uniform quantization to represent the signal. The non-uniform quantizer can be generated from the uniform quantizer, where the input signal uses a non-decreasing smooth function The transformation is then performed using a uniform quantizer Q with K equally spaced levels on (0, 1) and finally quantized by the expansion function To deal with. Figure 21 An example of a non-uniform quantization process is shown in .

[0310] Typically, by adjusting the compression function To optimize the non-uniform quantizer to minimize the random vector Its quantitative representation The distortion between Exemplarily, for a given vector s and the MSE distortion metric, the optimization is performed by solving the following equation:

[0311]

[0312] where the minimization is performed over all K levels of scalar quantizers. A standard way to optimize φ is via the Lloyd algorithm, which iteratively updates the partitioning units and output levels by applying conditions for quantizer optimality.

[0313]

[0314] where the minimization is performed on all K-level regularized scalar quantizers and obtained by the solver See Figure 22 shown.

[0315] In another possible implementation, embodiments of the present application provide a method for binarizing latent features of sparse tensors based on learned point cloud encoding representations. Specifically, a method for efficiently representing sparse tensors is provided as an intermediate representation for a learned model for compressed point cloud transmission; and rate-distortion-based quantization enables efficient data storage while maintaining the fidelity of point cloud reconstruction.

[0316] In the embodiment of the present application, it is proposed to use non-uniform quantization to represent the signal, and zero-run coding can be used to encode the quantized representation of the potential feature.

[0317] In the embodiment of the present application, the zero run code indicates that a data run (a sequence of the same data value equal to zero appears in many consecutive data elements) is stored as a single data value and counted, rather than stored as a raw run. Figure 25 Provides an example of generating zero-run code.

[0318] Any non-zero coefficients can be binarized using truncated Golomb-Rice codes.

[0319] A Golomb-Rice code is a code that specifies a number by its bin position (q) and its offset within the bin (r). These two components can be given by the following expression, where x is a non-negative integer being encoded:

[0320]

[0321] Here, both q and r are encoded using a variable number of bits: q is encoded by a unary code; r is encoded by b bits of a Rice code, or a choice between b bits and b+1 bits of a Golomb code, where b = [log2(M)]. If r < 2 b +1 -M, then b bits are used to encode r; otherwise, b+1 bits are used to encode r. When M is a power of 2, b bits are used to encode all values ​​of r, where b = log2(M) bits.

[0322] In a specific embodiment, the steps at the encoding end are as follows:

[0323] (1) The preset parameter M is fixed to an integer value.

[0324] (2) For the number N to be encoded, find:

[0325] business:

[0326] Remainder: r = Nmodulo(M).

[0327] (3) Generate codewords.

[0328] Coding format: <commercial code><remainder code>, where:

[0329] ①Business code:

[0330] Write a string of length q containing 1 bit (or 0 bit);

[0331] Writes a 0 bit (respectively a 1 bit).

[0332] ② Remaining numbers:

[0333] Assume b = log2M,

[0334] If r<2 b+1 -M, then r is encoded using b bits in the binary encoding.

[0335] If r ≥ 2 b+1 -M, then b+1 bits are used to encode r+2 in binary encoding b+1 -M.

[0336] In a specific embodiment, the decoding step is as follows:

[0337] (1) Parse the unary representation of q (count the number of 1s at the beginning of the code stream).

[0338] (2) Skip the 0 separator.

[0339] (3) Assume b = log2M,

[0340] Parse the next b bits into the binary number r'. If r'<2 b+1 1-M, then the remainder r=r′;

[0341] Otherwise, parse the b+1 bit into the binary number r", and the remainder r=r″-2 b+1 +M.

[0342] (4) Calculate N = q*M + r.

[0343] Then, context-adaptive binary arithmetic coding is used in the code stream to compress the binarized coefficients (ie, binary symbols), thereby improving the coding performance.

[0344] In yet another embodiment of the present application, based on the same inventive concept as the above embodiment, Figure 26 This is a schematic diagram of the structure of an encoder provided in an embodiment of the present application. Figure 26As shown, the encoder 260 includes a first determining unit 2601 and an encoding unit 2602, wherein:

[0345] The first determining unit 2601 is configured to determine a quotient and a remainder of a value to be encoded; determine a first group of bit information based on the quotient of the value to be encoded; and determine a second group of bit information based on the remainder of the value to be encoded; wherein the second group of bit information includes: bit information of a preset length, or bit information of (preset length+1);

[0346] The encoding unit 2602 is configured to encode the first group of bit information and the second group of bit information respectively, and write the obtained coded bits into the bit stream in sequence.

[0347] In some embodiments, the value to be encoded is a non-negative integer obtained after zero-run processing.

[0348] In some embodiments, the value to be encoded is a non-negative integer obtained by performing zero-run processing on the quantized array of the potential features of the current point cloud.

[0349] In some embodiments, the first determination unit 2601 is further configured to perform a division operation on the value to be encoded and a preset parameter to determine the quotient of the value to be encoded; and to perform a subtraction operation on the value to be encoded and the product of the quotient of the value to be encoded and the preset parameter to determine the remainder of the value to be encoded.

[0350] In some embodiments, the value of the preset parameter is a fixed integer value.

[0351] In some embodiments, a separator is provided between the first group of bit information and the second group of bit information; the encoding unit 2602 is further configured to encode the first group of bit information, the separator and the second group of bit information respectively, and write the obtained encoded bits into the code stream in sequence.

[0352] In some embodiments, the first determining unit 2601 is further configured to perform binarization processing on the quotient of the coded value based on a unary code to determine the first group of bit information.

[0353] In some embodiments, the quotient of the value to be encoded is related to the bit length in the first group of bit information.

[0354] In some embodiments, the value of the preset length is related to a preset parameter.

[0355] In some embodiments, the first determining unit 2601 is further configured to set the value of the preset length to be equal to the logarithm of the preset parameter with base 2.

[0356] In some embodiments, the first determining unit 2601 is further configured to perform binarization processing on the remainder of the coded value based on the Golomb-Rice code method to determine the second group of bit information.

[0357] In some embodiments, the first determination unit 2601 is further configured to, when the remainder of the value to be encoded is less than the first threshold, binarize the remainder of the value to be encoded to determine bit information of a preset length; and determine the bit information of the preset length as the second group of bit information.

[0358] In some embodiments, the first determination unit 2601 is further configured to, when the remainder of the value to be encoded is greater than or equal to the first threshold, binarize the remainder of the value to be encoded to determine the bit information of (preset length + 1); and determine the bit information of (preset length + 1) as the second group of bit information.

[0359] In some embodiments, the first determining unit 2601 is further configured to determine a first threshold value according to a preset length and preset parameters.

[0360] In some embodiments, the first determining unit 2601 is further configured to set the first threshold to be equal to the difference between 2 raised to the power of (preset length+1) and a preset parameter.

[0361] In some embodiments, the first determination unit 2601 is further configured to determine a sparse tensor of the current point cloud; perform feature extraction on the sparse tensor to determine a feature vector of a potential feature; and quantize the feature vector of the potential feature to determine a quantized array of the potential feature.

[0362] In some embodiments, the first determining unit 2601 is further configured to determine a non-uniform quantization factor corresponding to a feature vector of the potential feature; and quantize the feature vector of the potential feature based on the non-uniform quantization factor to determine a quantization array of the potential feature.

[0363] In some embodiments, the first determination unit 2601 is further configured to perform minimum distortion measurement on the first value in the feature vector of the potential feature and the reconstructed value of the first value to determine the non-uniform quantization factor corresponding to the first value; wherein the first value is any value in the feature vector of the potential feature.

[0364] In some embodiments, the encoding unit 2602 is further configured to perform encoding processing on the non-uniform quantization factors corresponding to the feature vectors of the potential features, and write the obtained encoding bits into the bitstream.

[0365] In some embodiments, the first determination unit 2601 is further configured to perform zero-run processing on the quantization array of potential features to determine at least one set of zero-run parameters; wherein each set of zero-run parameters includes a zero-run value and a non-zero element; and based on the zero-run value and the non-zero element in at least one set of zero-run parameters, determine at least one value to be encoded.

[0366] In some embodiments, the first determination unit 2601 is further configured to determine the zero run value as the value to be encoded when the value of the zero run value is non-zero; or, when the value after subtracting 1 from the non-zero element is non-zero, determine the value after subtracting 1 from the non-zero element as the value to be encoded.

[0367] In some embodiments, the first determination unit 2601 is further configured to determine whether the value of the i-th element is equal to 0 based on the i-th element in the quantization array; when the value of the i-th element is equal to 0, add 1 to the first variable, update i with i+1, and continue to determine whether the value of the i-th element is equal to 0; when the value of the i-th element is not equal to 0, determine the value of the first variable as a zero-run value, determine the i-th element as a non-zero element, and update i with i+1; when i is not equal to T, initialize the first variable to 0, and continue to determine whether the value of the i-th element is equal to 0, until i is equal to N, so as to obtain at least one set of zero-run parameters; wherein, i is an integer greater than or equal to 0 and less than or equal to T, and T represents the number of elements in the quantization array.

[0368] It is understandable that in the embodiments of the present application, a "unit" can be a portion of a circuit, a portion of a processor, a portion of a program or software, etc., and of course it can also be a module, or it can be non-modular. Moreover, the various components in this embodiment can be integrated into a processing unit, or each unit can exist physically separately, or two or more units can be integrated into a single unit. The above-mentioned integrated units can be implemented in the form of hardware or in the form of software functional modules.

[0369] In yet another embodiment of the present application, Figure 27 Schematic diagram of the hardware structure of an encoder provided in an embodiment of the present application. Figure 27 As shown, the encoder 260 may include: a first communication interface 2701, a first memory 2702, and a first processor 2703; each component is coupled together via a first bus system 2704. It is understood that the first bus system 2704 is used to achieve connection and communication between these components. In addition to the data bus, the first bus system 2704 also includes a power bus, a control bus, and a status signal bus. However, for the sake of clarity, Figure 26 In FIG, various buses are labeled as the first bus system 2704.

[0370] The first communication interface 2701 is used to receive and send signals when sending and receiving information with other external network elements;

[0371] A first memory 2702 is used to store computer programs that can be run on the first processor 2703;

[0372] The first processor 2703 is configured to, when running the computer program, execute the following: determining a quotient and a remainder of a value to be encoded; determining a first group of bit information based on the quotient of the value to be encoded; determining a second group of bit information based on the remainder of the value to be encoded; wherein the second group of bit information includes: bit information of a preset length, or bit information of (preset length+1); encoding the first group of bit information and the second group of bit information, respectively, and writing the obtained encoded bits into a bit stream in sequence.

[0373] It is understood that the first memory 2702 in the embodiment of the present application can be a volatile memory or a non-volatile memory, or can include both volatile and non-volatile memories. Among them, the non-volatile memory can be a read-only memory (ROM), a programmable read-only memory (PROM), an erasable programmable read-only memory (EPROM), an electrically erasable programmable read-only memory (EEPROM), or a flash memory. The volatile memory can be a random access memory (RAM), which is used as an external cache. By way of example and not limitation, many forms of RAM are available, such as static random access memory (SRAM), dynamic random access memory (DRAM), synchronous dynamic random access memory (SDRAM), double data rate synchronous dynamic random access memory (DDRSDRAM), enhanced synchronous dynamic random access memory (ESDRAM), synchronous link dynamic random access memory (SLDRAM), and direct RAM bus random access memory (DRRAM). The first memory 2702 of the systems and methods described herein is intended to include, but is not limited to, these and any other suitable types of memory.

[0374] The first processor 2703 may be an integrated circuit chip with signal processing capabilities. During implementation, each step of the above method can be completed by hardware integrated logic circuits or software instructions in the first processor 2703. The above-mentioned first processor 2703 can be a general-purpose processor, a digital signal processor (DSP), an application-specific integrated circuit (ASIC), a field programmable gate array (FPGA), or other programmable logic devices, discrete gate or transistor logic devices, or discrete hardware components. The various methods, steps, and logic block diagrams disclosed in the embodiments of this application can be implemented or executed. The general-purpose processor can be a microprocessor or any conventional processor. The steps of the method disclosed in the embodiments of this application can be directly implemented as being executed by a hardware decoding processor, or can be executed by a combination of hardware and software modules in the decoding processor. The software module can be located in a storage medium mature in the art, such as random access memory, flash memory, read-only memory, programmable read-only memory, electrically erasable programmable memory, registers, etc. The storage medium is located in the first memory 2702 , and the first processor 2703 reads the information in the first memory 2702 and completes the steps of the above method in combination with its hardware.

[0375] It is understood that these embodiments described in the present application can be implemented with hardware, software, firmware, middleware, microcode or a combination thereof. For hardware implementation, the processing unit can be implemented in one or more application specific integrated circuits (Application Specific Integrated Circuits, ASIC), digital signal processors (Digital Signal Processing, DSP), digital signal processing equipment (DSP Device, DSPD), programmable logic device (Programmable Logic Device, PLD), field programmable gate array (Field-Programmable Gate Array, FPGA), general-purpose processors, controllers, microcontrollers, microprocessors, other electronic units for performing functions described in the present application or a combination thereof. For software implementation, the technology described in the present application can be realized by the module (such as process, function etc.) that performs functions described in the present application. The software code can be stored in a memory and executed by a processor. The memory can be implemented in a processor or outside a processor.

[0376] Optionally, as another embodiment, the first processor 2703 is further configured to execute the method described in any one of the aforementioned embodiments when running the computer program.

[0377] This embodiment provides an encoder, and the encoding end encodes the quotient and remainder of the value to be encoded separately after determining the quotient and remainder. A new binarization method is used here for encoding processing, for example, the binarization processing can be performed using the Golomb-Rice code method, and the remainder can be encoded by bit information of a preset length, or it can also be encoded by bit information of (preset length + 1); and the value to be encoded here is obtained by zero-run processing, thereby saving encoding bits and improving entropy coding performance.

[0378] In yet another embodiment of the present application, based on the same inventive concept as the above embodiment, Figure 28 This is a schematic diagram of the structure of a decoder provided in an embodiment of the present application. Figure 28 As shown, the decoder 280 includes a decoding unit 2801 and a second determining unit 2802, wherein:

[0379] The decoding unit 2801 is configured to parse a first set of bit information in the bit stream to determine a quotient of a value to be decoded; and parse a second set of bit information in the bit stream to determine a remainder of the value to be decoded; wherein the second set of bit information includes: bit information of a preset length, or bit information of (preset length+1);

[0380] The second determining unit 2802 is configured to determine the value to be decoded according to the quotient of the value to be decoded and the remainder of the value to be decoded.

[0381] In some embodiments, the value to be decoded is a non-negative integer obtained after zero-run processing.

[0382] In some embodiments, the value to be decoded is a non-negative integer obtained by performing zero-run processing on the quantized array of the potential features of the current point cloud.

[0383] In some embodiments, a delimiter is provided between the first group of bit information and the second group of bit information; the decoding unit 2801 is further configured to skip the delimiter before parsing the second group of bit information in the code stream.

[0384] In some embodiments, the decoding unit 2801 is further configured to parse the first group of bit information in the code stream based on a unary code method to determine the quotient of the value to be decoded.

[0385] In some embodiments, the quotient of the value to be decoded is related to the bit length in the first group of bit information.

[0386] In some embodiments, the value of the preset length is related to a preset parameter.

[0387] In some embodiments, the second determining unit 2802 is further configured to set the value of the preset length to be equal to the logarithm of the preset parameter with base 2.

[0388] In some embodiments, the value of the preset parameter is a fixed integer value.

[0389] In some embodiments, the decoding unit 2801 is further configured to parse the second group of bit information in the code stream based on the Golomb-Rice code method to determine the remainder of the value to be decoded.

[0390] In some embodiments, the decoding unit 2801 is further configured to parse bit information of a preset length in the code stream to determine the first value; the second determination unit 2802 is further configured to set the remainder of the value to be decoded to be equal to the first value when the first value is less than the first threshold.

[0391] In some embodiments, the decoding unit 2801 is further configured to parse the bit information (preset length + 1) in the code stream to determine the second value when the first value is greater than or equal to the first threshold; the second determination unit 2802 is further configured to set the remainder of the value to be decoded equal to the difference between the second value and the first threshold.

[0392] In some embodiments, the second determining unit 2802 is further configured to determine the first threshold according to a preset length and preset parameters.

[0393] In some embodiments, the second determining unit 2802 is further configured to set the first threshold to be equal to the difference between 2 raised to the power of (preset length+1) and a preset parameter.

[0394] In some embodiments, the second determining unit 2802 is further configured to set the value to be decoded to be equal to the sum of the product of the quotient of the value to be decoded and the preset parameter and the remainder.

[0395] In some embodiments, the second determination unit 2802 is further configured to determine at least one set of zero-run parameters after obtaining the numerical value to be decoded; wherein each set of zero-run parameters includes a zero-run value and a non-zero element; determine the quantization array of the potential feature based on the at least one set of zero-run parameters; and dequantize the quantization array of the potential feature to determine the feature vector of the potential feature.

[0396] In some embodiments, the second determining unit 2802 is further configured to determine a zero run value according to the value to be decoded; or to perform an addition operation on the value to be decoded to determine a non-zero element.

[0397] In some embodiments, the second determining unit 2802 is further configured to determine a non-uniform quantization factor corresponding to a eigenvector of the potential feature; and dequantize the quantized array of the potential feature based on the non-uniform quantization factor to determine the eigenvector of the potential feature.

[0398] In some embodiments, the decoding unit 2801 is further configured to parse the code stream to determine the non-uniform quantization factor corresponding to the feature vector of the potential feature.

[0399] It is understood that in this embodiment, a "unit" can be a portion of a circuit, a portion of a processor, a portion of a program or software, etc., and can also be a module or a non-modular system. Furthermore, the various components in this embodiment can be integrated into a single processing unit, or each unit can exist physically separately, or two or more units can be integrated into a single unit. The aforementioned integrated units can be implemented in the form of hardware or software functional modules.

[0400] In yet another embodiment of the present application, Figure 29 This is a schematic diagram of the hardware structure of a decoder provided in an embodiment of the present application. Figure 29 As shown, the decoder 280 may include: a second communication interface 2901, a second memory 2902, and a second processor 2903; each component is coupled together via a second bus system 2904. It is understood that the second bus system 2904 is used to achieve connection and communication between these components. In addition to the data bus, the second bus system 2904 also includes a power bus, a control bus, and a status signal bus. However, for the sake of clarity, Figure 29 In FIG, various buses are labeled as a second bus system 2904.

[0401] The second communication interface 2901 is used to receive and send signals when sending and receiving information with other external network elements;

[0402] The second memory 2902 is used to store computer programs that can be run on the second processor 2903;

[0403] The second processor 2903 is configured to, when running the computer program, execute the following steps: parsing a first set of bit information in a bit stream to determine a quotient of a value to be decoded; parsing a second set of bit information in the bit stream to determine a remainder of the value to be decoded; wherein the second set of bit information includes: bit information of a preset length, or bit information of (preset length+1); and determining the value to be decoded based on the quotient of the value to be decoded and the remainder of the value to be decoded.

[0404] Optionally, as another embodiment, the second processor 2903 is further configured to execute any one of the methods described in the foregoing embodiments when running the computer program.

[0405] It can be understood that the hardware functions of the second memory 2902 are similar to those of the first memory 2702, and the hardware functions of the second processor 2903 are similar to those of the first processor 2703; they will not be described in detail here.

[0406] This embodiment provides a decoder, which adopts a new binarization method for encoding processing, for example, using a Golomb-Rice code method for binarization processing; wherein the quotient can be obtained by decoding a unary code; the remainder can be obtained by decoding bit information of a preset length, or can also be obtained by decoding bit information of (preset length+1) to obtain a value to be decoded; and the value to be decoded here is obtained after zero-run processing, thereby saving encoding bits and improving entropy decoding performance.

[0407] In yet another embodiment of the present application, Figure 30 This is a schematic diagram of the structure of a coding and decoding system provided in an embodiment of the present application. Figure 30 As shown, the encoding and decoding system 300 may include an encoder 3001 and a decoder 3002 .

[0408] In the embodiment of the present application, the encoder 3001 may be the encoder described in any one of the aforementioned embodiments, and the decoder 3002 may be the decoder described in any one of the aforementioned embodiments.

[0409] In some embodiments, embodiments of the present application further provide a computer-readable storage medium having a computer program stored thereon. When executed by a processor, the computer program implements the method described in any of the aforementioned embodiments. Specifically, when executed by a first processor, the computer program implements the encoding method described in any of the aforementioned embodiments, or when executed by a second processor, the computer program implements the decoding method described in any of the aforementioned embodiments.

[0410] In some embodiments, embodiments of the present application further provide a computer program product, including a computer program or instructions. When executed by a processor, the computer program or instructions implement the method described in any of the aforementioned embodiments. Specifically, when executed by a first processor, the computer program or instructions implement the encoding method described in any of the aforementioned embodiments, or when executed by a second processor, implement the decoding method described in any of the aforementioned embodiments.

[0411] In some embodiments, embodiments of the present application further provide a computer program that, when executed by a processor, implements the method described in any of the aforementioned embodiments. The computer program or instructions, when executed by a first processor, implement the encoding method described in any of the aforementioned embodiments, or, when executed by a second processor, implement the decoding method described in any of the aforementioned embodiments.

[0412] In some embodiments, the present application further provides a computer-readable storage medium on which a code stream is stored. The code stream is generated by executing the steps of the encoding method described in any one of the aforementioned embodiments.

[0413] In the embodiment of the present application, the information to be encoded in the encoding method includes at least one of the following: a first group of bit information. Here, the information to be encoded is encoded to be written into the bit stream.

[0414] Those skilled in the art will appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed in this application can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of this application.

[0415] Those skilled in the art will clearly understand that, for the convenience and brevity of description, the specific working processes of the above-described devices and units can refer to the corresponding processes in the aforementioned method embodiments and will not be repeated here.

[0416] In the several embodiments provided in this application, it should be understood that the disclosed devices and methods can be implemented in other ways. For example, the device embodiments described above are merely schematic. For example, the division of the units is merely a logical function division. In actual implementation, there may be other division methods, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0417] The units described as separate components may or may not be physically separate, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed across multiple network units. Some or all of these units may be selected to achieve the purpose of this embodiment according to actual needs.

[0418] In addition, the functional units in the various embodiments of the present application can be integrated into a processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. If the function is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of the present application is essentially or the part that contributes to the prior art or the part of the technical solution can be embodied in the form of a software product, which is stored in a storage medium and includes several instructions for enabling a computer device (which can be a personal computer, a server, or a network device, etc.) to execute all or part of the steps of the method described in the various embodiments of the present application. The aforementioned storage medium includes various media that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0419] It should be noted that, in this application, the terms "comprises," "includes," or any other variations thereof are intended to encompass non-exclusive inclusion, such that a process, method, article, or apparatus comprising a series of elements includes not only those elements but also other elements not explicitly listed, or elements inherent to such process, method, article, or apparatus. In the absence of further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of other identical elements in the process, method, article, or apparatus comprising the element.

[0420] The serial numbers of the above embodiments of the present application are for description only and do not represent the advantages or disadvantages of the embodiments.

[0421] The methods disclosed in the several method embodiments provided in this application can be arbitrarily combined without conflict to obtain new method embodiments.

[0422] The features disclosed in the several product embodiments provided in this application can be arbitrarily combined without conflict to obtain new product embodiments.

[0423] The features disclosed in the several method or device embodiments provided in this application can be arbitrarily combined without conflict to obtain new method embodiments or device embodiments.

[0424] The above description is merely a specific embodiment of the present application, but the scope of protection of the present application is not limited thereto. Any changes or substitutions that can be easily conceived by a person skilled in the art within the technical scope disclosed in this application should be included in the scope of protection of this application. Therefore, the scope of protection of this application should be based on the scope of protection of the claims.

Claims

1. A decoding method, applied to a decoder, comprising: Parsing the first set of bits in the bitstream to determine the quotient of the value to be decoded; Parsing a second set of bit information in the code stream to determine a remainder of the value to be decoded; wherein the second set of bit information includes: bit information of a preset length, or bit information of (preset length+1); The value to be decoded is determined according to the quotient of the value to be decoded and the remainder of the value to be decoded.

2. The method according to claim 1, wherein The value to be decoded is a non-negative integer obtained after zero-run processing.

3. The method according to claim 2, wherein: The value to be decoded is a non-negative integer obtained after the quantization array of the potential features of the current point cloud is processed by zero-run.

4. The method according to claim 1, wherein A separator is provided between the first group of bit information and the second group of bit information; and the method further includes: Before parsing the second group of bit information in the code stream, the delimiter is skipped.

5. The method according to claim 1, wherein The parsing of the first group of bit information in the code stream to determine the quotient of the value to be decoded includes: The first group of bit information in the code stream is parsed based on the unary code method to determine the quotient of the value to be decoded.

6. The method according to claim 5, wherein: The quotient of the to-be-decoded value is related to the bit length in the first group of bit information.

7. The method according to claim 1, wherein The value of the preset length is related to the preset parameters.

8. The method according to claim 7, wherein: The method further comprises: The value of the preset length is set to be equal to the logarithm of the preset parameter with base 2.

9. The method according to claim 7 or 8, wherein The value of the preset parameter is a fixed integer value.

10. The method according to claim 1, wherein The step of parsing the second set of bit information in the code stream to determine the remainder of the value to be decoded includes: The second group of bit information in the code stream is parsed based on the Golomb-Rice code method to determine the remainder of the value to be decoded.

11. The method according to claim 1, wherein The step of parsing the second set of bit information in the code stream to determine the remainder of the value to be decoded includes: Parsing the bit information of the preset length in the bit stream to determine a first value; When the first value is smaller than a first threshold, the remainder of the value to be decoded is set equal to the first value.

12. The method according to claim 11, wherein The parsing of the second group of bit information in the code stream to determine the remainder of the value to be decoded further includes: If the first value is greater than or equal to a first threshold, parsing the bit information of (preset length+1) in the code stream to determine a second value; The remainder of the value to be decoded is set equal to the difference between the second value and the first threshold.

13. The method according to claim 11 or 12, wherein: The method further comprises: The first threshold is determined according to the preset length and preset parameters.

14. The method according to claim 13, wherein The method further comprises: The first threshold is set to be equal to the difference between the (preset length+1) power of 2 and the preset parameter.

15. The method according to claim 1, wherein The determining the value to be decoded according to the quotient of the value to be decoded and the remainder of the value to be decoded includes: The value to be decoded is set to be equal to the sum of the product of the quotient of the value to be decoded and the preset parameter and the remainder.

16. The method according to any one of claims 1 to 15, wherein The method further comprises: After obtaining the value to be decoded, determining at least one set of zero-run parameters; wherein each set of zero-run parameters includes a zero-run value and a non-zero element; determining a quantized array of the potential features based on the at least one set of zero-run parameters; Dequantize the quantized array of the potential feature to determine the feature vector of the potential feature.

17. The method according to claim 16, wherein The method further comprises: Determine the zero-run value according to the value to be decoded; or An addition operation of 1 is performed on the value to be decoded to determine the non-zero element.

18. The method according to claim 16, wherein Dequantizing the quantized array of the potential feature to determine the feature vector of the potential feature includes: Determining a non-uniform quantization factor corresponding to a feature vector of the latent feature; The quantized array of the potential feature is dequantized based on the non-uniform quantization factor to determine a feature vector of the potential feature.

19. The method according to claim 18, wherein The determining of the non-uniform quantization factor corresponding to the feature vector of the potential feature includes: The code stream is parsed to determine a non-uniform quantization factor corresponding to a feature vector of the potential feature.

20. A coding method, applied to an encoder, comprising: Determining the quotient and remainder of the value to be encoded; Determining a first set of bit information based on a quotient of the value to be encoded; Determining a second set of bit information based on the remainder of the value to be encoded; wherein the second set of bit information includes: bit information of a preset length, or bit information of (preset length+1); The first group of bit information and the second group of bit information are respectively coded, and the obtained coded bits are sequentially written into a bit stream.

21. The method according to claim 20, wherein The value to be encoded is a non-negative integer obtained after zero-run processing.

22. The method according to claim 21, wherein The value to be encoded is a non-negative integer obtained after the quantization array of the potential features of the current point cloud is processed by zero-run.

23. The method according to claim 20, wherein Determining the quotient and remainder of the value to be encoded includes: Performing a division operation on the value to be encoded and a preset parameter to determine a quotient of the value to be encoded; A subtraction operation is performed on the value to be encoded and the product of the quotient of the value to be encoded and the preset parameter to determine a remainder of the value to be encoded.

24. The method according to claim 23, wherein The value of the preset parameter is a fixed integer value.

25. The method according to claim 20, wherein A separator is provided between the first group of bit information and the second group of bit information; and the method further includes: The first group of bit information, the delimiter, and the second group of bit information are respectively coded, and the obtained coded bits are sequentially written into a bit stream.

26. The method according to claim 20, wherein The determining of the first group of bit information based on the quotient of the value to be encoded includes: The quotient of the to-be-encoded value is binarized based on a unary code to determine the first group of bit information.

27. The method according to claim 26, wherein The quotient of the to-be-encoded value is related to the bit length in the first group of bit information.

28. The method according to claim 20, wherein The value of the preset length is related to the preset parameters.

29. The method according to claim 28, wherein The method further comprises: The value of the preset length is set to be equal to the logarithm of the preset parameter with base 2.

30. The method according to claim 20, wherein The determining a second group of bit information based on the remainder of the value to be encoded includes: The remainder of the value to be encoded is binarized based on the Golomb-Rice code method to determine the second group of bit information.

31. The method according to claim 30, wherein The determining a second group of bit information based on the remainder of the value to be encoded includes: When the remainder of the value to be encoded is less than a first threshold, binarizing the remainder of the value to be encoded to determine bit information of the preset length; The bit information of the preset length is determined as the second group of bit information.

32. The method according to claim 30, wherein The determining a second group of bit information based on the remainder of the value to be encoded includes: When the remainder of the value to be encoded is greater than or equal to the first threshold, binarizing the remainder of the value to be encoded to determine the bit information of (preset length+1); The (preset length+1) bit information is determined as the second group of bit information.

33. The method according to claim 31 or 32, wherein The method further comprises: The first threshold is determined according to the preset length and preset parameters.

34. The method according to claim 33, wherein The method further comprises: The first threshold is set to be equal to the difference between the (preset length+1) power of 2 and the preset parameter.

35. The method according to any one of claims 20 to 34, wherein The method further comprises: Determining a sparse tensor of the current point cloud; Performing feature extraction on the sparse tensor to determine a feature vector of the potential feature; The feature vector of the potential feature is quantized to determine a quantized array of the potential feature.

36. The method according to claim 35, wherein The step of quantizing the feature vector of the potential feature to determine the quantized array of the potential feature includes: Determining a non-uniform quantization factor corresponding to a feature vector of the latent feature; The feature vector of the potential feature is quantized based on the non-uniform quantization factor to determine a quantization array of the potential feature.

37. The method according to claim 36, wherein The determining of the non-uniform quantization factor corresponding to the feature vector of the potential feature includes: performing minimum distortion measurement on a first value in a feature vector of the potential feature and a reconstructed value of the first value to determine a non-uniform quantization factor corresponding to the first value; The first value is any value in the feature vector of the potential feature.

38. The method of claim 36, wherein: The method further comprises: The non-uniform quantization factors corresponding to the feature vectors of the potential features are coded, and the obtained coded bits are written into a bit stream.

39. The method according to any one of claims 20 to 38, wherein The method further comprises: Performing zero-run processing on the quantized array of the potential features to determine at least one set of zero-run parameters; wherein each set of zero-run parameters includes a zero-run value and a non-zero element; At least one of the to-be-encoded values ​​is determined based on the zero-run values ​​and the non-zero elements in the at least one set of zero-run parameters.

40. The method of claim 39, wherein The method further comprises: When the value of the zero-run value is non-zero, the zero-run value is determined as the value to be encoded; or When the value obtained by subtracting 1 from the non-zero element is non-zero, the value obtained by subtracting 1 from the non-zero element is determined as the value to be encoded.

41. The method of claim 39, wherein The performing zero-run processing on the quantized array of the potential features to determine at least one set of zero-run parameters includes: Based on the i-th element in the quantization array, determining whether the value of the i-th element is equal to 0; When the value of the i-th element is equal to 0, add 1 to the first variable, update i with i+1, and continue to determine whether the value of the i-th element is equal to 0; When the value of the i-th element is not equal to 0, the value of the first variable is determined as the zero-run value, the i-th element is determined as the non-zero element, and i is updated by i+1; When i is not equal to T, the first variable is initialized to 0, and the value of the i-th element is continuously determined to be equal to 0, until i is equal to N, so as to obtain the at least one set of zero-run parameters; Wherein, i is an integer greater than or equal to 0 and less than or equal to T, and T represents the number of elements in the quantization array.

42. An encoder, comprising a first determining unit and an encoding unit, wherein: The first determining unit is configured to determine a quotient and a remainder of the value to be encoded; and determine a first group of bit information based on the quotient of the value to be encoded; and determining a second set of bit information based on the remainder of the value to be encoded; wherein the second set of bit information includes: bit information of a preset length, or bit information of (preset length+1); The encoding unit is configured to perform encoding processing on the first group of bit information and the second group of bit information respectively, and write the obtained encoded bits into the bit stream in sequence.

43. An encoder comprising a first memory and a first processor, wherein: The first memory is used to store a computer program that can be run on the first processor; The first processor is configured to execute the method according to any one of claims 20 to 41 when running the computer program.

44. A decoder comprising a decoding unit and a second determining unit, wherein: The decoding unit is configured to parse the first group of bit information in the bit stream and determine the quotient of the value to be decoded; and parsing a second set of bit information in the code stream to determine the remainder of the value to be decoded; wherein the second set of bit information includes: bit information of a preset length, or bit information of (preset length+1); The second determining unit is configured to determine the value to be decoded according to the quotient of the value to be decoded and the remainder of the value to be decoded.

45. A decoder comprising a second memory and a second processor, wherein: The second memory is used to store a computer program that can be run on the second processor; The second processor is configured to execute the method according to any one of claims 1 to 19 when running the computer program.

46. ​​A computer-readable storage medium having a computer program stored thereon, wherein: When the computer program is executed by a processor, the method according to any one of claims 1 to 19 or the method according to any one of claims 20 to 41 is implemented.

47. A computer-readable storage medium having a code stream stored thereon, wherein: The code stream is generated by executing the steps of the encoding method according to any one of claims 20 to 41.

Images