Point cloud data transmission device, point cloud data transmission method, point cloud data reception device, and point cloud data reception method

Abstract

Disclosed are a point cloud data decoding method and device. The point cloud data decoding method according to embodiments may comprise the steps of: decoding geometry data of point cloud data in a bitstream; and decoding attribute data of the point cloud data. The step of decoding the attribute data comprises the steps of: for specific FGS, generating the levels of details (LoDs) on the basis of a partial occupancy tree corresponding to the FGS; and reconstructing the attribute data of the FGS on the basis of the LoDs.

Description

Point cloud data transmission device, point cloud data transmission method, point cloud data reception device and point cloud data reception method

[0001] The embodiments relate to a method and apparatus for processing point cloud content.

[0002] Point cloud content is content represented as a point cloud, which is a set of points belonging to a coordinate system that represents a three-dimensional space or volume. Point cloud content can represent three-dimensional media and is used to provide various services such as VR (Virtual Reality), AR (Augmented Reality), MR (Mixed Reality), XR (Extended Reality), and autonomous driving services. However, representing point cloud content requires tens of thousands to hundreds of thousands of point data points. Therefore, a method is required to efficiently process a vast amount of point data.

[0003] In other words, there is a problem in that a large amount of throughput is required to transmit and receive point cloud data. Therefore, encoding for compression and decoding for decompression are performed during the process of transmitting and receiving point cloud data; however, due to the large size of the point cloud data, the computations are complex and time-consuming.

[0004] The technical problem according to the embodiments is to provide an apparatus and method for efficiently transmitting and receiving point clouds in order to solve the aforementioned problems, etc.

[0005] The technical problem according to the embodiments is to provide an apparatus and method for solving latency and encoding / decoding complexity.

[0006] The technical problem according to the embodiments is to provide an apparatus and method for efficiently providing scalable services by processing geometry data and attribute data in subgroup units.

[0007] However, the scope of rights of the embodiments is not limited to the technical problems described above, and may be extended to other technical problems that a person skilled in the art can infer based on the entire content described.

[0008] To achieve the above-described purpose and other advantages, a point cloud data decoding method according to embodiments may include the step of decoding geometry data of point cloud data within a bitstream and the step of decoding attribute data of said point cloud data.

[0009] According to embodiments, the geometry data and the attribute data are each decoded in units of fine segmentation slices (FGS), each FGS corresponds one-to-one with a subgroup spatially partitioned within a layer group defined as a group of consecutive tree levels of an occupancy tree, and each FGS can be identified by a combination of a layer group index for identifying the layer group and a subgroup index for identifying the subgroup within the layer group.

[0010] According to embodiments, the step of decoding the attribute data includes, for a specific FGS, a step of generating Levels of Detail (LoDs) based on a partial occupancy tree corresponding to the FGS, and a step of restoring the attribute data of the FGS based on the LoDs, wherein a minimum LoD level information and a maximum LoD level information are obtained based on the start depth information and end depth information of the partial occupancy tree, the minimum LoD level information identifies the finest level of detail among the LoDs, and the maximum LoD level information identifies the coarsest level of detail among the LoDs.

[0011] According to embodiments, the step of generating the LODs can generate the LODs by subsampling points in the direction of the coarse detail level, starting from the finest detail level.

[0012] According to the embodiments, the LoD minimum level information is obtained based on the maximum depth information of the full occupancy tree and the end depth information of the partial occupancy tree, and the LoD maximum level information can be obtained based on the maximum depth information of the full occupancy tree and the start depth information of the partial occupancy tree.

[0013] According to the embodiments, the LoD minimum level information is set to the log2 quantized node size of the finest level of the partial occupancy tree, the LoD maximum level information is set to the log2 quantized node size of the coarsest level of the partial occupancy tree, and if the layer group is not the root layer group, the LoD maximum level information can be set to the value of the log2 quantized node size of the coarsest level of the partial occupancy tree plus 1.

[0014] According to the embodiments, the step of restoring attribute data of the FGS may perform at least one of raw attribute decoding, transform-based decoding, coefficient-weight-based processing, and quant-weight-based processing based on a range corresponding to the number of output attributes of the FGS.

[0015] According to the embodiments, the number of output attributes may be the sum of the number of nodes generated by the partial occupancy tree and the number of points generated from the direct-coded nodes.

[0016] According to embodiments, a point cloud data decoding device includes a memory and at least one processor connected to the memory, and the at least one processor may be configured to decode geometry data of point cloud data in a bitstream and to decode attribute data of the point cloud data.

[0017] According to embodiments, the geometry data and the attribute data are each decoded in units of fine segmentation slices (FGS), each FGS corresponds one-to-one with a subgroup spatially partitioned within a layer group defined as a group of consecutive tree levels of an occupancy tree, and each FGS can be identified by a combination of a layer group index for identifying the layer group and a subgroup index for identifying the subgroup within the layer group.

[0018] According to embodiments, the at least one processor can generate Levels of Detail (LoDs) for a specific FGS based on a partial occupancy tree corresponding to the FGS, restore attribute data of the FGS based on the LoDs, obtain LoD minimum level information and LoD maximum level information based on the start depth information and end depth information of the partial occupancy tree, the LoD minimum level information identifies the finest level of detail among the LoDs, the LoD maximum level information identifies the coarsest level of detail among the LoDs, and generate the LoDs by subsampling points in the direction of the coarsest level of detail starting from the finest level of detail.

[0019] According to the embodiments, the LoD minimum level information is obtained based on the maximum depth information of the entire occupancy tree and the end depth information of the partial occupancy tree, and the LoD maximum level information can be obtained based on the maximum depth information of the entire occupancy tree and the start depth information of the partial occupancy tree.

[0020] According to embodiments, the at least one processor can perform at least one of raw attribute decoding, transform-based decoding, coefficient-weight-based processing, and quant-weight-based processing based on a range corresponding to the number of output attributes of the FGS.

[0021] According to embodiments, a point cloud data encoding method may include the step of encoding geometry data of point cloud data and the step of encoding attribute data of point cloud data.

[0022] According to embodiments, a point cloud data encoding device includes a memory and at least one processor connected to the memory, and the at least one processor may be configured to encode geometry data of point cloud data and attribute data of point cloud data.

[0023] According to embodiments, a method for transmitting point cloud data comprises the steps of acquiring a bitstream for point cloud data and transmitting data including said bitstream, and said bitstream may be generated based on the steps of encoding geometry data of said point cloud data and encoding attribute data of said point cloud data.

[0024] The device and method according to the embodiments can provide a high-quality point cloud service.

[0025] The device and method according to the embodiments can achieve various video codec methods.

[0026] The device and method according to the embodiments can provide general-purpose point cloud content, such as autonomous driving services.

[0027] The apparatus and method according to the embodiments can provide improved parallel processing and scalability by performing spatial adaptive partitioning of point cloud data for independent encoding and decoding of point cloud data.

[0028] The apparatus and method according to the embodiments can improve the encoding and decoding performance of a point cloud by dividing the point cloud data into tile and / or slice units to perform encoding and decoding, and by signaling the data necessary for this purpose.

[0029] The apparatus and method according to the embodiments allow geometry decoding, LoD generation, and attribute decoding to be performed sequentially in subgroup units, thereby enabling decoding in slice units or subgroup units. This structure enables the rapid recovery of geometry and attributes corresponding to a specific subgroup in partial decoding or low-latency decoding environments, thereby enabling processing of the region of interest without waiting for the entire decoding to be completed.

[0030] Drawings are included to further understand the embodiments, and the drawings illustrate the embodiments along with descriptions related to the embodiments.

[0031] FIG. 1 shows an example of a point cloud content provision system according to embodiments.

[0032] FIG. 2 is a block diagram illustrating a point cloud content provision operation according to embodiments.

[0033] FIG. 3 shows an example of a point cloud encoder according to embodiments.

[0034] FIG. 4 shows examples of octree and occupancy codes according to embodiments.

[0035] Figure 5 shows an example of a point configuration by LOD according to embodiments.

[0036] Figure 6 shows an example of a point configuration by LOD according to embodiments.

[0037] FIG. 7 shows an example of a point cloud decoder according to embodiments.

[0038] FIG. 8 is an example of a transmission device according to embodiments.

[0039] FIG. 9 is an example of a receiving device according to embodiments.

[0040] FIG. 10 shows an example of a structure that can be linked with a point cloud data transmission / reception method / device according to embodiments.

[0041] FIGS. 11 and FIGS. 12 are diagrams illustrating the encoding, transmission, and decoding processes of point cloud data according to embodiments.

[0042] FIGS. 13(a) and FIGS. 13(b) show a geometry coding layer structure according to embodiments.

[0043] FIG. 14 shows a layer group and subgroup structure according to embodiments.

[0044] FIGS. 15(a) to 15(c) show representations of layer group-based point cloud data according to embodiments.

[0045] FIG. 16 shows a point cloud data transmission / reception device / method according to embodiments.

[0046] FIG. 17 is a flowchart showing an example of a method for generating LoD according to embodiments.

[0047] FIG. 18 is a diagram showing an example of a method for generating LoD when there is a missing subgroup according to embodiments.

[0048] FIG. 19 is a drawing showing an example of a nearest neighbor search method according to embodiments.

[0049] FIG. 20 is a diagram showing another example of a nearest neighbor search method according to embodiments.

[0050] FIG. 21 is a diagram showing another example of a nearest neighbor search method according to embodiments.

[0051] FIG. 22 is a drawing showing another example of a point cloud transmitting device according to embodiments.

[0052] FIG. 23 is a flowchart showing one embodiment of a method for encoding point cloud data according to embodiments.

[0053] FIG. 24 is a drawing showing another example of a point cloud receiving device according to embodiments.

[0054] FIG. 25 is a flowchart showing one embodiment of a method for decoding point cloud data according to embodiments.

[0055] FIG. 26 is a flowchart showing another embodiment of a method for decoding point cloud data according to embodiments.

[0056] FIG. 27 is a drawing showing an example of points included in each subgroup according to the embodiments.

[0057] FIG. 28 is a diagram showing an example of LoDs generated through subsampling according to embodiments.

[0058] FIG. 29 is a diagram showing an example of an attribute inheritance process according to embodiments.

[0059] FIG. 30 shows an example of a bitstream structure of point cloud data for transmission / reception according to embodiments.

[0060] FIG. 31 is a diagram showing one example of the syntax structure of a sequence parameter set according to the embodiments.

[0061] FIG. 32 is a diagram showing an example of the syntax structure of a dependent attribute data unit header according to embodiments.

[0062] FIG. 33 is a diagram showing one example of the syntax structure of the fgs attribute raw according to the embodiments.

[0063] FIG. 34 is a diagram showing an example of the syntax structure of an FGS occupancy tree according to embodiments.

[0064] FIG. 35 is a drawing showing an example of the syntax structure of a dependent geometry data unit header according to embodiments.

[0065] Figure 36 is a diagram showing an example of compressing and providing geometry and attributes of point cloud data.

[0066] FIG. 37 is a diagram showing another example of compressing and servicing the geometry and attributes of point cloud data according to embodiments.

[0067] FIG. 38 is a diagram showing another example of compressing and providing geometry and attributes of point cloud data according to embodiments.

[0068] FIG. 39 shows a flowchart of a point cloud data encoding method according to embodiments.

[0069] FIG. 40 shows a flowchart of a point cloud data decoding method according to embodiments.

[0070] Preferred embodiments of the embodiments are described in detail, and examples thereof are shown in the accompanying drawings. The following detailed description, with reference to the accompanying drawings, is intended to describe preferred embodiments of the embodiments rather than merely embodiments that may be implemented according to the embodiments. The following detailed description includes details to provide a thorough understanding of the embodiments. However, it is obvious to those skilled in the art that the embodiments may be practiced without these details.

[0071] Most terms used in the embodiments are selected from those commonly used in the field, but some terms are chosen at the applicant's discretion, and their meanings are described in detail in the following description as necessary. Accordingly, the embodiments should be understood based on the intended meaning of the terms, rather than their mere names or meanings.

[0072] FIG. 1 shows an example of a point cloud content provision system according to embodiments.

[0073] The point cloud content providing system illustrated in FIG. 1 may include a transmission device (10000) and a reception device (10004). The transmission device (10000) and the reception device (10004) can communicate via wired or wireless means to transmit and receive point cloud data.

[0074] A transmission device (10000) according to embodiments can acquire, process, and transmit point cloud video (or point cloud content). According to embodiments, the transmission device (10000) may include a fixed station, a base transceiver system (BTS), a network, an Artificial Intelligence (AI) device and / or system, a robot, an AR / VR / XR device and / or server, etc. Additionally, according to embodiments, the transmission device (10000) may include a device that communicates with a base station and / or other wireless devices using wireless access technology (e.g., 5G NR (New RAT), LTE (Long Term Evolution)), a robot, a vehicle, an AR / VR / XR device, a mobile device, a home appliance, an Internet of Things (IoT) device, an AI device / server, etc.

[0075] A transmission device (10000) according to embodiments includes a point cloud video acquisition unit (10001), a point cloud video encoder (10002), and / or a transmitter (or communication module), 10003.

[0076] A point cloud video acquisition unit (10001) according to the embodiments acquires a point cloud video through processing steps such as capture, synthesis, or generation. The point cloud video is a point cloud content represented as a point cloud, which is a set of points located in a three-dimensional space, and may be referred to as point cloud video data, etc. The point cloud video according to the embodiments may include one or more frames. A frame represents a still image / picture. Accordingly, the point cloud video may include a point cloud image / frame / picture and may be referred to as any one of a point cloud image, a frame, and a picture.

[0077] A point cloud video encoder (10002) according to the embodiments encodes the obtained point cloud video data. The point cloud video encoder (10002) can encode the point cloud video data based on point cloud compression coding. The point cloud compression coding according to the embodiments may include Geometry-based Point Cloud Compression (G-PCC) coding and / or Video-based Point Cloud Compression (V-PCC) coding or next-generation coding. Furthermore, the point cloud compression coding according to the embodiments is not limited to the embodiments described above. The point cloud video encoder (10002) can output a bitstream containing the encoded point cloud video data. The bitstream may include not only the encoded point cloud video data but also signaling information related to the encoding of the point cloud video data.

[0078] A transmitter (10003) according to the embodiments transmits a bitstream containing encoded point cloud video data. The bitstream according to the embodiments is encapsulated into a file or segment (e.g., a streaming segment) and transmitted through various networks such as a broadcast network and / or a broadband network. Although not illustrated in the drawings, the transmission device (10000) may include an encapsulation unit (or encapsulation module) that performs an encapsulation operation. Additionally, according to the embodiments, the encapsulation unit may be included in the transmitter (10003). According to the embodiments, the file or segment may be transmitted to a receiving device (10004) via a network or stored on a digital storage medium (e.g., USB, SD, CD, DVD, Blu-ray, HDD, SSD, etc.). The transmitter (10003) according to the embodiments can communicate wired or wirelessly with the receiving device (10004) (or receiver (10005)) via a network such as 4G, 5G, or 6G. Additionally, the transmitter (10003) can perform necessary data processing operations according to a network system (e.g., a communication network system such as 4G, 5G, 6G, etc.). Additionally, the transmission device (10000) can transmit encapsulated data according to an on-demand method.

[0079] A receiving device (10004) according to embodiments includes a receiver (10005), a point cloud video decoder (10006), and / or a renderer (10007). According to embodiments, the receiving device (10004) may include a device, robot, vehicle, AR / VR / XR device, mobile device, home appliance, IoT (Internet of Thing) device, AI device / server, etc., that communicates with a base station and / or other wireless device using wireless access technology (e.g., 5G NR (New RAT), LTE (Long Term Evolution)).

[0080] A receiver (10005) according to the embodiments receives a bitstream containing point cloud video data or a file / segment containing the bitstream from a network or a storage medium. The receiver (10005) can perform necessary data processing operations according to a network system (e.g., a communication network system such as 4G, 5G, 6G, etc.). The receiver (10005) according to the embodiments can output a bitstream by decapsulating the received file / segment. Additionally, according to the embodiments, the receiver (10005) may include a decapsulation unit (or decapsulation module) for performing a decapsulation operation. Additionally, the decapsulation unit may be implemented as an element (or component) separate from the receiver (10005).

[0081] A point cloud video decoder (10006) decodes a bitstream containing point cloud video data. The point cloud video decoder (10006) can decode the point cloud video data according to the way the point cloud video data is encoded (e.g., the reverse process of the operation of a point cloud video encoder (10002)). Accordingly, the point cloud video decoder (10006) can decode the point cloud video data by performing point cloud decompression coding, which is the reverse process of point cloud compression. Point cloud decompression coding includes G-PCC coding.

[0082] The renderer (10007) renders the decoded point cloud video data. In one embodiment, the renderer (10007) can render the decoded point cloud video data according to a viewport, etc. The renderer (10007) can render not only the point cloud video data but also audio data to output point cloud content. According to embodiments, the renderer (10007) may include a display for displaying the point cloud content. According to embodiments, the display may not be included in the renderer (10007) but may be implemented as a separate device or component.

[0083] The arrows indicated by dotted lines in the drawing represent the transmission path of feedback information obtained from the receiving device (10004). The feedback information is information intended to reflect interaction with a user consuming point cloud content and includes user information (e.g., head orientation information, viewport information, etc.). In particular, if the point cloud content is content for a service requiring interaction with a user (e.g., autonomous driving service, etc.), the feedback information may be transmitted to the content transmitting side (e.g., the transmitting device (10000)) and / or the service provider. Depending on the embodiments, the feedback information may be used in the receiving device (10004) as well as the transmitting device (10000), or it may not be provided.

[0084] Head orientation information according to the embodiments may refer to information regarding the user's head position, direction, angle, movement, etc. The receiving device (10004) according to the embodiments may calculate viewport information based on head orientation information. Viewport information is information about the area of ​​the point cloud video that the user is looking at (i.e., the area the user is currently looking at). That is, viewport information is information about the area the user is currently looking at within the point cloud video. In other words, the viewport or viewport area may refer to the area the user is looking at in the point cloud video. And the viewpoint is the point the user is looking at in the point cloud video, and may refer to the exact center point of the viewport area. That is, the viewport is an area centered on the viewpoint, and the size and shape occupied by that area may be determined by the FOV (Field Of View). Therefore, the receiving device (10004) may extract viewport information based on the vertical or horizontal FOV supported by the device in addition to head orientation information. Additionally, the receiving device (10004) can perform gaze analysis, etc. based on head orientation information and / or viewport information to determine the user's point cloud video consumption method, the point cloud video area the user gazes at, the gaze time, etc. According to embodiments, the receiving device (10004) can transmit feedback information including the gaze analysis results to the transmitting device (10000). According to embodiments, a device such as a VR / XR / AR / MR display can extract a viewport area based on the user's head position / direction, the vertical or horizontal FOV supported by the device, etc. According to embodiments, the head orientation information and viewport information may be referred to as feedback information, signaling information, or metadata.

[0085] Feedback information according to the embodiments may be obtained during the rendering and / or display process. Feedback information according to the embodiments may be obtained by one or more sensors included in the receiving device (10004). Additionally, according to the embodiments, feedback information may be obtained by the renderer (10007) or a separate external element (or device, component, etc.). The dotted line in FIG. 1 indicates the process of transmitting feedback information obtained from the renderer (10007). The feedback information may be transmitted to the transmitting side, as well as consumed at the receiving side. That is, the point cloud content providing system may process point cloud data (encoding / decoding / rendering) based on the feedback information. For example, the point cloud video decoder (10006) and the renderer (10007) may use the feedback information, namely head orientation information and / or viewport information, to preferentially decode and render only the point cloud video for the area currently being viewed by the user.

[0086] Additionally, the receiving device (10004) can transmit feedback information to the transmitting device (10000). The transmitting device (10000) (or the point cloud video encoder (10002)) can perform an encoding operation based on the feedback information. Thus, the point cloud content providing system can efficiently process necessary data (e.g., point cloud data corresponding to the user's head position) based on the feedback information without processing (encoding / decoding) all point cloud data, and provide point cloud content to the user.

[0087] According to embodiments, the transmission device (10000) may be referred to as an encoder, transmission device, transmitter, transmission system, etc., and the receiving device (10004) may be referred to as a decoder, receiving device, receiver, receiving system, etc.

[0088] Point cloud data processed in the point cloud content providing system of FIG. 1 according to embodiments (processed through a series of processes of acquisition / encoding / transmission / decoding / rendering) may be referred to as point cloud content data or point cloud video data. According to embodiments, point cloud content data may be used as a concept including metadata or signaling information related to point cloud data.

[0089] The elements of the point cloud content delivery system illustrated in FIG. 1 can be implemented using hardware, software, processors, and / or combinations thereof.

[0090] FIG. 2 is a block diagram illustrating a point cloud content provision operation according to embodiments.

[0091] The block diagram of FIG. 2 illustrates the operation of the point cloud content provision system described in FIG. 1. As described above, the point cloud content provision system can process point cloud data based on point cloud compression coding (e.g., G-PCC).

[0092] A point cloud content providing system according to the embodiments (e.g., a point cloud transmission device (10000) or a point cloud video acquisition unit (10001)) can acquire a point cloud video (20000). The point cloud video is represented as a point cloud belonging to a coordinate system representing a three-dimensional space. The point cloud video according to the embodiments may include a Ply (Polygon File format or the Stanford Triangle format) file. If the point cloud video has one or more frames, the acquired point cloud video may include one or more Ply files. The Ply file contains point cloud data such as the geometry and / or attributes of the points. The geometry includes the positions of the points. The position of each point may be represented by parameters (e.g., values ​​of the X-axis, Y-axis, and Z-axis, respectively) representing a three-dimensional coordinate system (e.g., a coordinate system consisting of XYZ axes). Attributes include attributes of points (e.g., texture information, color (YCbCr or RGB), reflectance (r), transparency, etc. of each point). A point has one or more attributes (or properties). For example, a point may have one attribute which is color, or two attributes which are color and reflectance. According to embodiments, geometry may be referred to as positions, geometry information, geometry data, etc., and attributes may be referred to as attributes, attribute information, attribute data, etc. Additionally, a point cloud content providing system (e.g., a point cloud transmission device (10000) or a point cloud video acquisition unit (10001)) may obtain point cloud data from information related to the acquisition process of point cloud video (e.g., depth information, color information, etc.).

[0093] A point cloud content providing system according to embodiments (e.g., a transmission device (10000) or a point cloud video encoder (10002)) can encode point cloud data (20001). The point cloud content providing system can encode point cloud data based on point cloud compression coding. As described above, point cloud data may include geometry and attributes of points. Accordingly, the point cloud content providing system can output a geometry bitstream by performing geometry encoding to encode geometry. The point cloud content providing system can output an attribute bitstream by performing attribute encoding to encode attributes. According to embodiments, the point cloud content providing system can perform attribute encoding based on geometry encoding. The geometry bitstream and attribute bitstream according to embodiments can be multiplexed and output as a single bitstream. The bitstream according to the embodiments may further include signaling information related to geometry encoding and attribute encoding.

[0094] A point cloud content providing system according to embodiments (e.g., a transmission device (10000) or a transmitter (10003)) can transmit encoded point cloud data (20002). As described in FIG. 1, the encoded point cloud data can be represented as a geometry bitstream and an attribute bitstream. Additionally, the encoded point cloud data can be transmitted in the form of a bitstream along with signaling information related to the encoding of the point cloud data (e.g., signaling information related to geometry encoding and attribute encoding). Additionally, the point cloud content providing system can encapsulate the bitstream transmitting the encoded point cloud data and transmit it in the form of a file or segment.

[0095] A point cloud content providing system according to embodiments (e.g., a receiving device (10004) or a receiver (10005)) can receive a bitstream containing encoded point cloud data. Additionally, the point cloud content providing system (e.g., a receiving device (10004) or a receiver (10005)) can demultiplex the bitstream.

[0096] A point cloud content providing system (e.g., a receiving device (10004) or a point cloud video decoder (10005)) can decode encoded point cloud data (e.g., a geometry bitstream, an attribute bitstream) transmitted as a bitstream. A point cloud content providing system (e.g., a receiving device (10004) or a point cloud video decoder (10005)) can decode point cloud video data based on signaling information related to the encoding of point cloud video data included in the bitstream. A point cloud content providing system (e.g., a receiving device (10004) or a point cloud video decoder (10005)) can decode the geometry bitstream to restore the positions (geometry) of the points. A point cloud content providing system can decode the attribute bitstream based on the restored geometry to restore the attributes of the points. A point cloud content delivery system (e.g., a receiving device (10004) or a point cloud video decoder (10005)) can restore a point cloud video based on positions according to the restored geometry and decoded attributes.

[0097] A point cloud content providing system according to embodiments (e.g., a receiving device (10004) or a renderer (10007)) can render decoded point cloud data (20004). The point cloud content providing system (e.g., a receiving device (10004) or a renderer (10007)) can render geometry and attributes decoded through a decoding process according to various rendering methods. Points of the point cloud content may be rendered as vertices having a certain thickness, cubes having a specific minimum size with the vertex location as the center, or circles with the vertex location as the center, etc. All or part of the rendered point cloud content is provided to a user through a display (e.g., a VR / AR display, a general display, etc.).

[0098] A point cloud content providing system (e.g., a receiving device (10004)) according to the embodiments can obtain feedback information (20005). The point cloud content providing system can encode and / or decode point cloud data based on the feedback information. Since the feedback information and the operation of the point cloud content providing system according to the embodiments are the same as the feedback information and operation described in FIG. 1, a detailed description is omitted.

[0099] FIG. 3 shows an example of a point cloud encoder according to embodiments.

[0100] FIG. 3 shows an example of the point cloud video encoder (10002) of FIG. 1. The point cloud encoder reconstructs point cloud data (e.g., positions and / or attributes of points) and performs encoding operations to adjust the quality of point cloud content (e.g., lossless, lossy, near-lossless) according to network conditions or applications. If the total size of the point cloud content is large (e.g., point cloud content of 60 Gbps in the case of 30 fps), the point cloud content delivery system may not be able to stream the content in real time. Therefore, the point cloud content delivery system may reconstruct the point cloud content based on a maximum target bitrate to provide it according to the network environment.

[0101] As described in FIGS. 1 and 2, the point cloud encoder can perform geometry encoding and attribute encoding. Geometry encoding is performed before attribute encoding.

[0102] The point cloud encoder according to the embodiments comprises a coordinate system transformation unit (Transformation Coordinates, 30000), a quantization unit (Quantize and Remove Points (Voxelize), 30001), an octree analysis unit (Analyze Octree, 30002), a surface approximation analysis unit (Analyze Surface Approximation, 30003), an arithmetic encoder (Arithmetic Encode, 30004), a geometry reconstruction unit (Reconstruct Geometry, 30005), a color transformation unit (Transform Colors, 30006), an attribute transformation unit (Transfer Attributes, 30007), a RAHT transformation unit (30008), an LOD generation unit (Generated LOD, 30009), a lifting transformation unit (Lifting) (30010), and a coefficient quantization unit (Quantize Coefficients, 30011). It includes an and / or arithmetic encoder (30012). In the point cloud encoder of FIG. 3, the coordinate system transformation unit (30000), quantization unit (30001), octree analysis unit (30002), surface approximation analysis unit (30003), arithmetic encoder (30004), and geometry reconstruction unit (30005) can be grouped and referred to as a geometry encoder. Also, the color conversion unit (30006), attribute conversion unit (30007), RAHT conversion unit (30008), LOD generation unit (30009), lifting conversion unit (30010), coefficient quantization unit (30011), and / or arithmetic encoder (30012) can be grouped and referred to as an attribute encoder.

[0103] The coordinate system transformation unit (30000), quantization unit (30001), octree analysis unit (30002), surface approximation analysis unit (30003), arismetic encoder (30004), and geometry reconstruction unit (30005) can perform geometry encoding. Geometry encoding according to the embodiments may include octree geometry coding, direct coding, trisoup geometry encoding, and entropy encoding. Direct coding and trisoup geometry encoding are applied optionally or in combination. Additionally, geometry encoding is not limited to the above examples.

[0104] As illustrated in the drawings, the coordinate system conversion unit (30000) according to the embodiments receives positions and converts them into a coordinate system. For example, the positions can be converted into position information in a three-dimensional space (e.g., a three-dimensional space expressed in an XYZ coordinate system). The position information in the three-dimensional space according to the embodiments may be referred to as geometry information.

[0105] The quantization unit (30001) according to the embodiments quantizes the geometry. For example, the quantization unit (30001) can quantize points based on the minimum position values ​​of all points (e.g., minimum values ​​on each axis for the X-axis, Y-axis, and Z-axis). The quantization unit (30001) performs a quantization operation to find the nearest integer value by multiplying the difference between the minimum position value and the position value of each point by a preset quantization scale value and then performing rounding down or rounding up. Thus, one or more points may have the same quantized position (or position value). The quantization unit (30001) according to the embodiments performs voxelization based on the quantized positions to reconstruct the quantized points. Just as the minimum unit containing 2D image / video information is a pixel, the points of the point cloud content (or 3D point cloud video) according to the embodiments may be contained in one or more voxels. A voxel is a combination of volume and pixel, and refers to a three-dimensional cubic space that is generated when a three-dimensional space is divided into units (unit=1.0) based on axes representing the three-dimensional space (e.g., X-axis, Y-axis, Z-axis). The quantization unit (40001) can match groups of points in the three-dimensional space to voxels. According to embodiments, a single voxel may contain only one point. According to embodiments, a single voxel may contain one or more points. In addition, to represent a single voxel as a single point, the position of the center of the voxel can be set based on the positions of one or more points included in the voxel. In this case, the attributes of all positions included in the voxel can be combined and assigned to the voxel.

[0106] The octree analysis unit (30002) according to the embodiments performs octree geometry coding (or octree coding) to represent the voxels in an octree structure. The octree structure represents points matched to the voxels based on an octree structure.

[0107] The surface approximation analysis unit (30003) according to the embodiments can analyze and approximate an octree. The octree analysis and approximation according to the embodiments is a process of analyzing to voxelize an area containing multiple points in order to efficiently provide octree and voxelization.

[0108] An arithmetic encoder (30004) according to the embodiments entropy-encodes an octree and / or an approximated octree. For example, the encoding method includes an arithmetic encoding method. As a result of the encoding, a geometry bitstream is generated.

[0109] The color conversion unit (30006), attribute conversion unit (30007), RAHT conversion unit (30008), LOD generation unit (30009), lifting conversion unit (30010), coefficient quantization unit (30011) and / or arismetic encoder (30012) perform attribute encoding. As described above, a point may have one or more attributes. The attribute encoding according to the embodiments is applied equally to the attributes of a point. However, if a single attribute (e.g., color) includes one or more elements, independent attribute encoding is applied to each element. The attribute encoding according to the embodiments may include color conversion coding, attribute conversion coding, Region Adaptive Hierarchial Transform (RAHT) coding, prediction transformation (Interpolaration-based hierarchical nearest-neighbour prediction-Prediction Transform) coding, and lifting transformation (interpolation-based hierarchical nearest-neighbour prediction with an update / lifting step (Lifting Transform)) coding. Depending on the point cloud content, the above-described RAHT coding, prediction transformation coding, and lifting transformation coding may be used optionally, or a combination of one or more of the codings may be used. Furthermore, the attribute encoding according to the embodiments is not limited to the examples described above.

[0110] The color conversion unit (30006) according to the embodiments performs color conversion coding that converts color values ​​(or textures) included in attributes. For example, the color conversion unit (30006) can convert the format of color information (e.g., convert from RGB to YCbCr). The operation of the color conversion unit (30006) according to the embodiments may be applied optionally depending on the color values ​​included in attributes.

[0111] The geometry reconstruction unit (30005) according to the embodiments reconstructs (decompresses) an octree and / or an approximated octree. The geometry reconstruction unit (30005) reconstructs an octree / voxel based on the results of analyzing the distribution of points. The reconstructed octree / voxel may be referred to as the reconstructed geometry (or restored geometry).

[0112] The attribute transformation unit (30007) according to the embodiments performs attribute transformation that transforms attributes based on positions where geometry encoding has not been performed and / or reconstructed geometry. As described above, since attributes are dependent on geometry, the attribute transformation unit (30007) can transform attributes based on reconstructed geometry information. For example, the attribute transformation unit (30007) can transform the attributes of a point at a position based on the position value of a point included in a voxel. As described above, when the position of the center point of a voxel is set based on the positions of one or more points included in a voxel, the attribute transformation unit (30007) transforms the attributes of one or more points. When trisoop geometry encoding is performed, the attribute conversion unit (30007) can convert attributes based on the trisoop geometry encoding.

[0113] The attribute transformation unit (30007) can perform attribute transformation by calculating the average value of attributes or attribute values ​​(e.g., the color or reflectance of each point) of neighboring points within a specific location / radius from the position (or position value) of the center point of each voxel. The attribute transformation unit (30007) can apply a weight based on the distance from the center point to each point when calculating the average value. Thus, each voxel has a position and a calculated attribute (or attribute value).

[0114] The attribute conversion unit (30007) can search for neighbor points within a specific location / radius from the position of the center point of each voxel based on a KD tree or a Morton code. A KD tree is a binary search tree that supports a data structure capable of managing points based on their positions to enable rapid Nearest Neighbor Search (NNS). A Morton code is generated by representing the coordinate values ​​(e.g., (x, y, z)) representing the 3D positions of all points as bit values ​​and mixing the bits. For example, if the coordinate values ​​representing the position of a point are (5, 9, 1), the bit values ​​of the coordinate values ​​are (0101, 1001, 0001). When the bit values ​​are mixed according to the bit indices in the order of z, y, and x, it becomes 010001000111. When this value is represented in decimal, it becomes 1095. That is, the Molton code value of the point with coordinates (5, 9, 1) is 1095. The attribute transformation unit (30007) sorts the points based on the Molton code value and can perform shortest neighbor search (NNS) through a depth-first traversal process. After the attribute transformation operation, if shortest neighbor search (NNS) is required in other transformation processes for attribute coding, a KD tree or Molton code is utilized.

[0115] As shown in the drawing, the converted attributes are input to the RAHT conversion unit (30008) and / or LOD generation unit (30009).

[0116] The RAHT transformation unit (30008) according to the embodiments performs RAHT coding to predict attribute information based on reconstructed geometry information. For example, the RAHT transformation unit (30008) can predict attribute information of a node at an upper level of the octree based on attribute information associated with a node at a lower level of the octree.

[0117] The LOD generation unit (30009) according to the embodiments generates a Level of Detail (LOD) to perform predictive transformation coding. The LOD according to the embodiments represents the degree of detail of the point cloud content, and indicates that the smaller the LOD value, the lower the detail of the point cloud content, and the larger the LOD value, the higher the detail of the point cloud content. Points can be classified according to the LOD.

[0118] The lifting transformation unit (30010) according to the embodiments performs lifting transformation coding that transforms the attributes of the point cloud based on weights. As described above, the lifting transformation coding may be applied optionally.

[0119] The coefficient quantization unit (30011) according to the embodiments quantizes attribute-coded attributes based on coefficients.

[0120] An arismetic encoder (30012) according to the embodiments encodes quantized attributes based on arismetic coding.

[0121] The elements of the point cloud encoder of FIG. 3 may be implemented in hardware, software, firmware, or a combination thereof, comprising one or more processors or integrated circuits configured to communicate with one or more memories included in the point cloud providing device, although not illustrated in the drawing. One or more processors may perform at least one of the operations and / or functions of the elements of the point cloud encoder of FIG. 3 described above. Additionally, one or more processors may operate or execute a set of software programs and / or instructions for performing the operations and / or functions of the elements of the point cloud encoder of FIG. 3. One or more memories according to the embodiments may include high-speed random access memory and may include non-volatile memory (e.g., one or more magnetic disk storage devices, flash memory devices, or other non-volatile solid-state memory devices).

[0122] FIG. 4 shows examples of octree and occupancy codes according to embodiments.

[0123] As described in FIGS. 1 to 3, a point cloud content providing system (point cloud video encoder (10002)) or a point cloud encoder (e.g., an octree analysis unit (30002)) performs octree geometry coding based on an octree structure (or octree coding) to efficiently manage the area and / or position of a voxel.

[0124] The top of FIG. 4 shows an octree structure. The three-dimensional space of the point cloud content according to the embodiments is represented by the axes of the coordinate system (e.g., X-axis, Y-axis, Z-axis). The octree structure has two poles (0,0,0) and (2 d , 2 d , 2 d It is generated by recursively subdividing the bounding box (cubical axis-aligned bounding box) defined by ). 2d can be set to the value that constitutes the smallest bounding box enclosing all points of the point cloud content (or point cloud video). d represents the depth of the octree. The value of d is determined according to the following equation. In the equation below, (x int n , y int n , z int n ) represents the positions (or position values) of quantized points.

[0125]

[0126] As illustrated in the middle of the top of Fig. 4, the entire three-dimensional space can be divided into eight spaces according to the division. Each divided space is represented as a cube having six faces. As illustrated in the right of the top of Fig. 4, each of the eight spaces is further divided based on the axes of the coordinate system (e.g., X-axis, Y-axis, Z-axis). Thus, each space is again divided into eight smaller spaces. The divided smaller spaces are also represented as cubes having six faces. This division method is applied until the leaf nodes of the octree become voxels.

[0127] The bottom of Fig. 4 shows the occupancy code of an octree. The occupancy code of an octree is generated to indicate whether each of the eight partitioned spaces resulting from the partitioning of a single space contains at least one point. Therefore, one occupancy code is represented by eight child nodes. Each child node represents the occupancy of the partitioned space, and the child node has a value of 1 bit. Thus, the occupancy code is represented as an 8-bit code. That is, if the space corresponding to the child node contains at least one point, the node has a value of 1. If the space corresponding to the child node does not contain a point (empty), the node has a value of 0. Since the occupancy code shown in Fig. 4 is 00100001, it indicates that the spaces corresponding to the 3rd and 8th child nodes among the eight child nodes each contain at least one point. As illustrated in the drawing, the 3rd child node and the 8th child node each have 8 child nodes, and each child node is represented by an 8-bit Occupancy code. The drawing indicates that the Occupancy code of the 3rd child node is 10000111 and the Occupancy code of the 8th child node is 01001111. A point cloud encoder according to the embodiments (e.g., an arismetic encoder (30004)) can entropy-encode the Occupancy code. Additionally, to increase compression efficiency, the point cloud encoder can intra- / inter-encode the Occupancy code. A receiving device according to the embodiments (e.g., a receiving device (10004) or a point cloud video decoder (10006)) reconstructs the octree based on the Occupancy code.

[0128] A point cloud encoder according to the embodiments (e.g., the point cloud encoder of FIG. 3, or the octree analysis unit (30002)) can perform voxelization and octree coding to store the positions of the points. However, since points in a three-dimensional space are not always evenly distributed, there may be specific areas where few points exist. Therefore, performing voxelization on the entire three-dimensional space is inefficient. For example, if there are almost no points in a specific area, there is no need to perform voxelization up to that area.

[0129] Accordingly, the point cloud encoder according to the embodiments can perform direct coding, which directly codes the positions of points included in a specific region (or nodes excluding leaf nodes of an octree) without performing voxelization on the aforementioned specific region. The coordinates of the points directly coded according to the embodiments are referred to as the Direct Coding Mode (DCM). Additionally, the point cloud encoder according to the embodiments can perform trisoup geometry encoding, which reconstructs the positions of points within a specific region (or node) based on voxels using a surface model. Trisoup geometry encoding is a geometry encoding that represents an object as a series of triangle meshes. Therefore, the point cloud decoder can generate a point cloud from the mesh surface. Direct coding and trisoup geometry encoding according to the embodiments may be performed optionally. In addition, direct coding and trisoop geometry encoding according to the embodiments can be performed in combination with octree geometry coding (or octree coding).

[0130] In order to perform direct coding, the option to use direct mode for applying direct coding must be enabled, and the node to which direct coding is to be applied must not be a leaf node, and there must be points below a threshold within a specific node. In addition, the total number of points subject to direct coding must not exceed a preset threshold. If the above conditions are satisfied, the point cloud encoder (or arismetic encoder (30004)) according to the embodiments can entropy-code the positions (or position values) of the points.

[0131] A point cloud encoder according to the embodiments (e.g., a surface approximation analysis unit (30003)) can determine a specific level of an octree (where the level is smaller than the depth d of the octree) and, starting from that level, perform trisoop geometry encoding to reconstruct the position of points within a node area based on voxels using a surface model (trisoop mode). The point cloud encoder according to the embodiments can specify the level to which trisoop geometry encoding is applied. For example, if the specified level is equal to the depth of the octree, the point cloud encoder does not operate in trisoop mode. That is, the point cloud encoder according to the embodiments can operate in trisoop mode only when the specified level is smaller than the depth value of the octree. A three-dimensional cubic area of ​​nodes at the specified level according to the embodiments is referred to as a block. A block may include one or more voxels. A block or a voxel may correspond to a brick. Within each block, geometry is represented as a surface. A surface according to the embodiments may intersect each edge of the block at most once.

[0132] Since one block has 12 edges, there are at least 12 intersection points within one block. Each intersection point is referred to as a vertex. A vertex along an edge is detected if there is at least one occupied voxel adjacent to that edge among all blocks sharing that edge. An occupied voxel according to the embodiments means a voxel containing a point. The position of a vertex detected along an edge is the average position along the edge of all voxels adjacent to that edge among all blocks sharing that edge.

[0133] When a vertex is detected, the point cloud encoder according to the embodiments includes the starting point (x, y, z) of the edge and the direction vector of the edge ( x, y, z), vertex position values ​​(relative position values ​​within the edge) can be entropy-coded. When trisoop geometry encoding is applied, a point cloud encoder according to the embodiments (e.g., geometry reconstruction unit (30005)) can generate restored geometry (reconstructed geometry) by performing triangle reconstruction, up-sampling, and voxelization processes.

[0134] The vertices located on the edges of the block determine the surface passing through the block. The surface according to the embodiments is a non-planar polygon. The triangle reconstruction process reconstructs the surface represented by triangles based on the edge start point, the edge direction vector, and the vertex position value. The triangle reconstruction process is as follows: ① calculate the centroid value of each vertex, ② subtract the centroid value from each vertex value, ③ square the result, and add all the result together.

[0135]

[0136] Then, the minimum value of the sum is calculated, and a projection process is performed along the axis where the minimum value is located. For example, if the x-element is at its minimum, each vertex is projected along the x-axis relative to the center of the block and projected onto the (y, z) plane. If the value obtained by projecting onto the (y, z) plane is (ai, bi), the θ value is calculated using atan2(bi, ai), and the vertices are aligned based on the θ value. The table below shows the combinations of vertices to generate triangles depending on the number of vertices. The vertices are sorted in order from 1 to n. Table 1 below indicates that for four vertices, two triangles can be formed depending on the combination of vertices. The first triangle is composed of the 1st, 2nd, and 3rd vertices among the aligned vertices, and the second triangle can be composed of the 3rd, 4th, and 1st vertices among the aligned vertices.

[0137] [Table 1] Triangles formed from vertices ordered 1,… , nnTriangles3(1,2,3)4(1,2,3), (3,4,1)5(1,2,3), (3,4,5), (5,1,3)6(1,2,3), (3,4,5), (5,6,1), (1,3,5)7(1,2,3), (3,4,5), (5,6,7), (7,1,3), (3,5,7)8(1,2,3), (3,4,5), (5,6,7), (7,8,1), (1,3,5), (5,7,1)9(1,2,3), (3,4,5), (5,6,7), (7,8,9), (9,1,3), (3,5,7), (7,9,3)10(1,2,3), (3,4,5), (5,6,7), (7,8,9), (9,10,1), (1,3,5), (5,7,9), (9,1,5)11(1,2,3), (3,4,5), (5,6,7), (7,8,9), (9,10,11), (11,1,3), (3,5,7), (7,9,11), (11,3,7)12(1,2,3), (3,4,5), (5,6,7), (7,8,9), (9,10,11), (11,12,1), (1,3,5), (5,7,9), (9,11,1), (1,5,9)

[0138] The upsampling process is performed to voxelize by adding intermediate points along the edges of the triangle. Additional points are generated based on the upsampling factor value and the width of the block. The additional points are referred to as refined vertices. A point cloud encoder according to the embodiments can voxelize the refined vertices. Additionally, the point cloud encoder can perform attribute encoding based on the voxelized positions (or position values).

[0139] Figure 5 shows an example of a point configuration by LOD according to embodiments.

[0140] As described in FIGS. 1 to 4, the encoded geometry is reconstructed (decompressed) before attribute encoding is performed. When direct coding is applied, the geometry reconstruction operation may include changing the arrangement of the direct-coded points (e.g., placing the direct-coded points at the front of the point cloud data). When trisoop geometry encoding is applied, the geometry reconstruction process involves triangle reconstruction, upsampling, and voxelization. Since attributes depend on geometry, attribute encoding is performed based on the reconstructed geometry.

[0141] A point cloud encoder (e.g., an LOD generation unit (30009)) can reorganize points by LOD. The drawing shows point cloud content corresponding to the LOD. The left side of the drawing shows the original point cloud content. The second figure from the left in the drawing shows the distribution of points of the lowest LOD, and the rightmost figure in the drawing shows the distribution of points of the highest LOD. That is, the points of the lowest LOD are distributed sparsely (or coarsely), and the points of the highest LOD are distributed finely. That is, according to the direction of the arrow indicated at the bottom of the drawing, as the LOD increases, the spacing (or distance) between points becomes shorter.

[0142] Figure 6 shows an example of a point configuration by LOD according to embodiments.

[0143] As described in FIGS. 1 to 5, a point cloud content providing system or a point cloud encoder (e.g., a point cloud video encoder (10002), the point cloud encoder of FIG. 3, or an LOD generation unit (30009)) can generate an LOD. The LOD is generated by reorganizing points into a set of refinement levels according to a set LOD distance value (or a set of Euclidean distances). The LOD generation process is performed in a point cloud decoder as well as a point cloud encoder.

[0144] The top of Fig. 6 shows examples of points (P0 to P9) of point cloud content distributed in three-dimensional space. The Original Order in Fig. 6 indicates the order of points P0 to P9 prior to LOD generation. The LOD-based Order in Fig. 6 indicates the order of points following LOD generation. Points are rearranged by LOD. Additionally, high (or fine) LODs include points belonging to low (or coarse) LODs. As illustrated in Fig. 6, LOD0 includes P0, P5, P4, and P2. LOD1 includes the points of LOD0 and P1, P6, and P3. LOD2 includes the points of LOD0, the points of LOD1, and P9, P8, and P7.

[0145] As described in FIG. 3, the point cloud encoder according to the embodiments can perform predictive transform coding, lifting transform coding, and RAHT transform coding selectively or in combination.

[0146] The point cloud encoder according to the embodiments can generate predictors for points and perform predictive transformation coding to set the predicted attribute (or predicted attribute value) of each point. That is, N predictors can be generated for N points. The predictor according to the embodiments can calculate a weight (=1 / distance) value based on the LOD value of each point, indexing information for neighboring points within a set distance per LOD, and the distance value to the neighboring points.

[0147] According to the embodiments, the predicted attribute (or attribute value) is set as the average value of the values ​​obtained by multiplying the attributes (or attribute values, e.g., color, reflectance, etc.) of neighboring points set in the predictor of each point by a weight (or weight value) calculated based on the distance to each neighboring point. The point cloud encoder according to the embodiments (e.g., coefficient quantization unit (30011)) can quantize and inverse quantize the residual values ​​(which may be referred to as residual attributes, residual attribute values, attribute prediction residual values, etc.) obtained by subtracting the predicted attribute (attribute value) from the attribute (attribute value) of each point. The quantization process is as shown in Tables 2 and 3 below.

[0148] int PCCQuantization(int value, int quantStep) {if( value >=0) {return floor(value / quantStep + 1.0 / 3.0);} else {return -floor(-value / quantStep + 1.0 / 3.0);}}

[0149] int PCCInverseQuantization(int value, int quantStep) {if( quantStep ==0) {return value;} else {return value * quantStep;}}

[0150] A point cloud encoder according to the embodiments (e.g., an arismetic encoder (30012)) can entropy-code the quantized and inversely quantized residual values ​​as described above when there are neighboring points in the predictor of each point. A point cloud encoder according to the embodiments (e.g., an arismetic encoder (30012)) can entropy-code the attributes of the corresponding point without performing the process described above when there are no neighboring points in the predictor of each point.

[0151] A point cloud encoder according to the embodiments (e.g., a lifting transformation unit (30010)) can perform lifting transformation coding by generating a predictor for each point, setting the LOD calculated in the predictor, registering neighboring points, and setting weights based on the distance to neighboring points. The lifting transformation coding according to the embodiments is similar to the prediction transformation coding described above, but differs in that weights are cumulatively applied to attribute values. The process of cumulatively applying weights to attribute values ​​according to the embodiments is as follows.

[0152] 1) Create an array QW (QuantizationWight) to store the weight values ​​of each point. The initial value of all elements in QW is 1.0. Add the value obtained by multiplying the current point's predictor weight by the QW value of the predictor index of the neighboring node registered in the predictor.

[0153] 2) Lift prediction process: To calculate the predicted attribute value, the value obtained by multiplying the point's attribute value by a weight is subtracted from the existing attribute value.

[0154] 3) Create temporary arrays named updateweight and update, and initialize the temporary arrays to 0.

[0155] 4) For all predictors, the calculated weight is additionally multiplied by the weight stored in the QW corresponding to the predictor index, and the resulting weight is accumulated in the update weight array with the neighbor node index. In the update array, the value obtained by multiplying the attribute value of the neighbor node index by the calculated weight is accumulated.

[0156] 5) Lift update process: For all predictors, the attribute value of the update array is divided by the weight value of the update weight array at the predictor index, and the original attribute value is added back to the divided value.

[0157] 6) For all predictors, the predicted attribute value is calculated by additionally multiplying the attribute value updated through the lift update process by the weight (stored in QW) updated through the lift prediction process. A point cloud encoder according to the embodiments (e.g., coefficient quantizer (30011)) quantizes the predicted attribute value. Additionally, a point cloud encoder (e.g., arismetic encoder (30012)) entropies the quantized attribute value.

[0158] A point cloud encoder according to the embodiments (e.g., a RAHT transform unit (30008)) can perform RAHT transform coding to predict attributes of upper-level nodes using attributes associated with nodes at lower levels of the octree. RAHT transform coding is an example of attribute intra-coding through octree backward scanning. A point cloud encoder according to the embodiments scans from voxels to the entire region and repeats the merging process up to the root node, merging voxels into larger blocks at each step. The merging process according to the embodiments is performed only on occupied nodes. The merging process is not performed on empty nodes, and the merging process is performed on the node immediately above the empty node.

[0159] The following equation represents the RAHT transformation matrix. g lx,y,z represents the average attribute value of the voxels at level l. g lx,y,z can be calculated from gl+1 2x,y,z and gl+1 2x+1,y,z. g l 2x,y,z and the weights of gl 2x+1,y,z are w1=w l 2x,y,z and w2=wl 2x+1,y,z.

[0160]

[0161] g l-1 x,y,z is a low-pass value used in the merging process at the next higher level. h l-1 x,y,z ε₀ are high-pass coefficients, and the high-pass coefficients at each step are quantized and entropy-coded (e.g., encoding of an arismetic encoder (30012)). The weights are w l-1 x,y,z = w l 2x,y,z + wl is calculated as 2x+1,y,z. The root node is the last g 1 0,0,0 and g 1 0,0,1 It is generated as follows through.

[0162]

[0163] The gDC value is also quantized and entropy-coded, just like the high-pass coefficient.

[0164] FIG. 7 shows an example of a point cloud decoder according to embodiments.

[0165] The point cloud decoder illustrated in FIG. 7 is an example of a point cloud decoder and can perform a decoding operation, which is the reverse process of the encoding operation of the point cloud encoder described in FIG. 1 to 6.

[0166] As described in Fig. 1, the point cloud decoder can perform geometry decoding and attribute decoding. Geometry decoding is performed before attribute decoding.

[0167] A point cloud decoder according to the embodiments comprises an arithmetic decoder (7000), a synthesize octree (7001), a synthesize surface approximation (7002), a reconstruct geometry (7003), an inverse transform coordinates (7004), an arithmetic decoder (7005), an inverse quantize (7006), a RAHT transform (7007), an LOD generater (7008), an inverse lifting (7009), and / or an inverse transform colors (7010).

[0168] An arismetic decoder (7000), an octree composite unit (7001), a surface offset composite unit (7002), a geometry reconstruction unit (7003), and a coordinate system inverse transformation unit (7004) can perform geometry decoding. Geometry decoding according to the embodiments may include direct coding and trisoup geometry decoding. Direct coding and trisoup geometry decoding are applied optionally. Additionally, geometry decoding is not limited to the above examples and is performed as the reverse process of geometry encoding described in FIGS. 1 through 6.

[0169] The arismetic decoder (7000) according to the embodiments decodes the received geometry bitstream based on arismetic coding. The operation of the arismetic decoder (7000) corresponds to the reverse process of the arismetic encoder (30004).

[0170] The octree synthesis unit (7001) according to the embodiments can generate an octree by obtaining an Occupancy code from a decoded geometry bitstream (or information regarding the geometry obtained as a result of decoding). A specific description of the Occupancy code is as described in FIGS. 1 to 6.

[0171] The surface off-relation synthesis unit (7002) according to the embodiments can synthesize a surface based on the decoded geometry and / or the generated octree when trisoop geometry encoding is applied.

[0172] The geometry reconstruction unit (7003) according to the embodiments can regenerate geometry based on a surface and / or decoded geometry. As described in FIGS. 1 through 6, direct coding and trisoop geometry encoding are applied optionally. Accordingly, the geometry reconstruction unit (7003) directly retrieves and adds position information of points to which direct coding has been applied. In addition, when trisoop geometry encoding is applied, the geometry reconstruction unit (7003) can restore geometry by performing reconstruction operations of the geometry reconstruction unit (30005), such as triangle reconstruction, up-sampling, and voxelization operations. Specific details are omitted as they are the same as those described in FIG. 4. The restored geometry may include a point cloud picture or frame that does not contain attributes.

[0173] The coordinate system inverse transformation unit (7004) according to the embodiments can obtain the positions of the points by transforming the coordinate system based on the restored geometry.

[0174] An arismetic decoder (7005), an inverse quantization unit (7006), a RAHT transformation unit (7007), an LOD generation unit (7008), an inverse lifting unit (7009), and / or a color inverse transformation unit (7010) may perform attribute decoding. Attribute decoding according to the embodiments may include RAHT (Region Adaptive Hierarchial Transform) decoding, prediction transformation (Interpolaration-based hierarchical nearest-neighbour prediction-Prediction Transform) decoding, and lifting transformation (interpolation-based hierarchical nearest-neighbour prediction with an update / lifting step (Lifting Transform)) decoding. The three decodings described above may be used optionally, or a combination of one or more decodings may be used. Furthermore, attribute decoding according to the embodiments is not limited to the examples described above.

[0175] The arismetic decoder (7005) according to the embodiments decodes the attribute bitstream into arismetic coding.

[0176] The inverse quantization unit (7006) according to the embodiments inverse quantizes information about the decoded attribute bitstream or the attribute obtained as a result of decoding and outputs the inverse quantized attributes (or attribute values). Inverse quantization may be optionally applied based on the attribute encoding of the point cloud encoder.

[0177] According to embodiments, the RAHT transformation unit (7007), LOD generation unit (7008), and / or inverse lifting unit (7009) can process the reconstructed geometry and inverse quantized attributes. As described above, the RAHT transformation unit (7007), LOD generation unit (7008), and / or inverse lifting unit (7009) can optionally perform a corresponding decoding operation according to the encoding of the point cloud encoder.

[0178] The color inverse conversion unit (7010) according to the embodiments performs inverse conversion coding to inversely convert the color value (or texture) included in the decoded attributes. The operation of the color inverse conversion unit (7010) may be selectively performed based on the operation of the color conversion unit (30006) of the point cloud encoder.

[0179] The elements of the point cloud decoder of FIG. 7 may be implemented in hardware, software, firmware, or a combination thereof, comprising one or more processors or integrated circuits configured to communicate with one or more memories included in the point cloud providing device, although not illustrated in the drawing. One or more processors may perform at least one of the operations and / or functions of the elements of the point cloud decoder of FIG. 7 described above. Additionally, one or more processors may operate or execute a set of software programs and / or instructions for performing the operations and / or functions of the elements of the point cloud decoder of FIG. 7.

[0180] FIG. 8 is an example of a transmission device according to embodiments.

[0181] The transmission device illustrated in FIG. 8 is an example of the transmission device (10000) of FIG. 1 (or the point cloud encoder of FIG. 3). The transmission device illustrated in FIG. 8 can perform at least one of the same or similar operations and methods as the operations and encoding methods of the point cloud encoder described in FIG. 1 to 6. A transmission device according to embodiments may include a data input unit (8000), a quantization processing unit (8001), a voxelization processing unit (8002), an octree occupancy code generation unit (8003), a surface model processing unit (8004), an intra / inter coding processing unit (8005), an arithmetic coder (8006), a metadata processing unit (8007), a color conversion processing unit (8008), an attribute conversion processing unit (or attribute conversion processing unit) (8009), a prediction / lifting / RAHT conversion processing unit (8010), an arithmetic coder (8011) and / or a transmission processing unit (8012).

[0182] The data input unit (8000) according to the embodiments receives or acquires point cloud data. The data input unit (8000) may perform an operation and / or acquisition method identical or similar to the operation and / or acquisition method of the point cloud video acquisition unit (10001) (or the acquisition process (20000) described in FIG. 2).

[0183] The data input unit (8000), quantization processing unit (8001), voxelization processing unit (8002), octree occupancy code generation unit (8003), surface model processing unit (8004), intra / inter coding processing unit (8005), and arithmetic coder (8006) perform geometry encoding. Since the geometry encoding according to the embodiments is identical or similar to the geometry encoding described in FIGS. 1 to 6, a detailed description is omitted.

[0184] The quantization processing unit (8001) according to the embodiments quantizes geometry (e.g., location values ​​of points, or position values). The operation and / or quantization of the quantization processing unit (8001) is the same or similar to the operation and / or quantization of the quantization unit (30001) described in FIG. 3. The specific description is the same as that described in FIG. 1 through 6.

[0185] The voxelization processing unit (8002) according to the embodiments voxelizes the position values ​​of the quantized points. The voxelization processing unit (80002) may perform the same or similar operation and / or process as the operation and / or voxelization process of the quantization unit (30001) described in FIG. 3. The specific description is the same as that described in FIG. 1 to 6.

[0186] The octree occupancy code generation unit (8003) according to the embodiments performs octree coding on the positions of voxelized points based on an octree structure. The octree occupancy code generation unit (8003) can generate an occupancy code. The octree occupancy code generation unit (8003) can perform operations and / or methods identical or similar to the operations and / or methods of the point cloud encoder (or octree analysis unit (30002)) described in FIGS. 3 and 4. The specific description is the same as that described in FIGS. 1 through 6.

[0187] The surface model processing unit (8004) according to the embodiments can perform trisup geometry encoding that reconstructs the positions of points within a specific region (or node) based on a voxel based on a surface model. The surface model processing unit (8004) can perform operations and / or methods identical or similar to the operations and / or methods of the point cloud encoder (e.g., surface approximation analysis unit (30003)) described in FIG. 3. The specific description is the same as that described in FIG. 1 through 6.

[0188] According to the embodiments, the intra / inter coding processing unit (8005) can intra / inter code point cloud data. The intra / inter coding processing unit (8005) can perform coding identical or similar to intra / inter coding. According to the embodiments, the intra / inter coding processing unit (8005) may be included in an arismetic coder (8006).

[0189] An arithmetic coder (8006) according to the embodiments entropy-encodes an octree and / or an approximated octree of point cloud data. For example, the encoding method includes an arithmetic encoding method. The arithmetic coder (8006) performs the same or similar operation and / or method as the arithmetic encoder (30004).

[0190] A metadata processing unit (8007) according to the embodiments processes metadata regarding point cloud data, such as setting values, and provides it to necessary processing processes such as geometry encoding and / or attribute encoding. Additionally, a metadata processing unit (8007) according to the embodiments may generate and / or process signaling information related to geometry encoding and / or attribute encoding. The signaling information according to the embodiments may be encoded separately from geometry encoding and / or attribute encoding. Additionally, the signaling information according to the embodiments may be interleaved.

[0191] The color conversion processing unit (8008), attribute conversion processing unit (8009), prediction / lifting / RAHT conversion processing unit (8010), and arithmetic coder (8011) perform attribute encoding. Since the attribute encoding according to the embodiments is identical or similar to the attribute encoding described in FIGS. 1 to 6, a detailed description is omitted.

[0192] The color conversion processing unit (8008) according to the embodiments performs color conversion coding that converts color values ​​included in attributes. The color conversion processing unit (8008) may perform color conversion coding based on reconstructed geometry. The description of the reconstructed geometry is the same as that described in FIGS. 1 through 6. In addition, it performs the same or similar operation and / or method as the operation and / or method of the color conversion unit (30006) described in FIG. 3. A detailed description is omitted.

[0193] The attribute transformation processing unit (8009) according to the embodiments performs attribute transformation that transforms attributes based on positions where geometry encoding has not been performed and / or reconstructed geometry. The attribute transformation processing unit (8009) performs operations and / or methods identical or similar to the operations and / or methods of the attribute transformation unit (30007) described in FIG. 3. A detailed description is omitted. The prediction / lifting / RAHT transformation processing unit (8010) according to the embodiments may code the transformed attributes by RAHT coding, prediction transformation coding, and lifting transformation coding, or a combination thereof. The prediction / lifting / RAHT transformation processing unit (8010) performs at least one of operations identical or similar to the operations of the RAHT transformation unit (30008), LOD generation unit (30009), and lifting transformation unit (30010) described in FIG. 3. In addition, the descriptions of predictive transformation coding, lifting transformation coding, and RAHT transformation coding are the same as those described in Figures 1 to 6, so a detailed description is omitted.

[0194] The arismetic coder (8011) according to the embodiments can encode coded attributes based on arismetic coding. The arismetic coder (8011) performs the same or similar operation and / or method as the operation and / or method of the arismetic encoder (300012).

[0195] A transmission processing unit (8012) according to embodiments may transmit each bitstream containing encoded geometry and / or encoded attributes and metadata information, or may transmit the encoded geometry and / or encoded attributes and metadata information by configuring them into a single bitstream. When the encoded geometry and / or encoded attributes and metadata information according to embodiments is configured into a single bitstream, the bitstream may include one or more sub-bitstreams. The bitstream according to embodiments may include signaling information and slice data, including SPS (Sequence Parameter Set) for sequence-level signaling, GPS (Geometry Parameter Set) for signaling of geometry information coding, APS (Attribute Parameter Set) for signaling of attribute information coding, and TPS (Tile Parameter Set) for tile-level signaling. The slice data may include information regarding one or more slices. One slice according to embodiments is one geometry bitstream (Geom0 0 ) and one or more attribute bitstreams (Attr0 0 , Attr1 0 It may include ).

[0196] A slice refers to a series of syntax elements representing all or part of a coded point cloud frame.

[0197] According to the embodiments, the TPS may include information regarding each tile (e.g., coordinate value information of a bounding box and height / size information, etc.) for one or more tiles. The geometry bitstream may include a header and a payload. The header of the geometry bitstream according to the embodiments may include identification information of a parameter set included in the GPS (geom_parameter_set_id), a tile identifier (geom_tile_id), a slice identifier (geom_slice_id), and information regarding data included in the payload, etc. As described above, the metadata processing unit (8007) according to the embodiments may generate and / or process signaling information and transmit it to the transmission processing unit (8012). According to the embodiments, the elements performing geometry encoding and the elements performing attribute encoding may share data / information with each other as indicated by the dotted lines. The transmission processing unit (8012) according to the embodiments may perform an operation and / or transmission method identical or similar to the operation and / or transmission method of the transmitter (10003). A detailed explanation is omitted as it is the same as that described in FIGS. 1 and 2.

[0198] FIG. 9 is an example of a receiving device according to embodiments.

[0199] The receiving device illustrated in FIG. 9 is an example of the receiving device (10004) of FIG. 1. The receiving device illustrated in FIG. 9 can perform at least one of the same or similar operations and methods as the operations and decoding methods of the point cloud decoder described in FIG. 1 to FIG. 8.

[0200] A receiving device according to the embodiments may include a receiving unit (9000), a receiving processing unit (9001), an arithmetic decoder (9002), an occupancy code-based octree reconstruction processing unit (9003), a surface model processing unit (triangle reconstruction, up-sampling, voxelization) (9004), an inverse quantization processing unit (9005), a metadata parser (9006), an arithmetic decoder (9007), an inverse quantization processing unit (9008), a prediction / lifting / RAHT inverse transformation processing unit (9009), a color inverse transformation processing unit (9010), and / or a renderer (9011). Each component of the decoding according to the embodiments may perform the inverse process of the components of the encoding according to the embodiments.

[0201] A receiver (9000) according to the embodiments receives point cloud data. The receiver (9000) may perform an operation and / or a receiving method identical or similar to the operation and / or receiving method of the receiver (10005) of FIG. 1. A detailed description is omitted.

[0202] A receiving processing unit (9001) according to the embodiments can obtain a geometry bitstream and / or an attribute bitstream from the received data. The receiving processing unit (9001) may be included in the receiving unit (9000).

[0203] The arismetic decoder (9002), the occupancy code-based octree reconstruction processing unit (9003), the surface model processing unit (9004), and the inverse quantization processing unit (9005) can perform geometry decoding. Since the geometry decoding according to the embodiments is identical or similar to the geometry decoding described in at least one of FIGS. 1 to 8, a detailed description is omitted.

[0204] The arismetic decoder (9002) according to the embodiments can decode a geometry bitstream based on arismetic coding. The arismetic decoder (9002) performs the same or similar operation and / or coding as the operation and / or coding of the arismetic decoder (7000).

[0205] According to the embodiments, the Occupancy code-based octree reconstruction processing unit (9003) can reconstruct an octree by obtaining an Occupancy code from a decoded geometry bitstream (or information regarding geometry obtained as a result of decoding). The Occupancy code-based octree reconstruction processing unit (9003) performs the same or similar operations and / or methods as the octree synthesis unit (7001) and / or octree generation method. According to the embodiments, the surface model processing unit (9004) can perform trisup geometry decoding and related geometry reconstruction (e.g., triangle reconstruction, up-sampling, voxelization) based on the surface model method when trisup geometry encoding is applied. The surface model processing unit (9004) performs the same or similar operations as the surface offset synthesis unit (7002) and / or geometry reconstruction unit (7003).

[0206] The inverse quantization processing unit (9005) according to the embodiments can inverse quantize the decoded geometry.

[0207] A metadata parser (9006) according to the embodiments can parse metadata included in the received point cloud data, such as setting values, etc. The metadata parser (9006) can pass the metadata to geometry decoding and / or attribute decoding. A specific description of the metadata is omitted as it is the same as described in FIG. 8.

[0208] The arismetic decoder (9007), inverse quantization processing unit (9008), prediction / lifting / RAHT inverse transformation processing unit (9009), and color inverse transformation processing unit (9010) perform attribute decoding. Since attribute decoding is identical or similar to the attribute decoding described in at least one of FIGS. 1 to 8, a detailed description is omitted.

[0209] The arismetic decoder (9007) according to the embodiments can decode an attribute bitstream into arismetic coding. The arismetic decoder (9007) can perform decoding of the attribute bitstream based on reconstructed geometry. The arismetic decoder (9007) performs the same or similar operation and / or coding as the operation and / or coding of the arismetic decoder (7005).

[0210] The inverse quantization processing unit (9008) according to the embodiments can inverse quantize the decoded attribute bitstream. The inverse quantization processing unit (9008) performs the same or similar operation and / or method as the operation and / or inverse quantization method of the inverse quantization unit (7006).

[0211] The prediction / lifting / RAHT inverse transformation processing unit (9009) according to the embodiments can process the reconstructed geometry and inverse quantized attributes. The prediction / lifting / RAHT inverse transformation processing unit (9009) performs at least one of the same or similar operations and / or decodings as the operations and / or decodings of the RAHT transformation unit (7007), LOD generation unit (7008), and / or inverse lifting unit (7009) of FIG. 7. The color inverse transformation processing unit (9010) according to the embodiments performs inverse transformation coding to inversely transform the color values ​​(or textures) included in the decoded attributes. The color inverse transformation processing unit (9010) performs the same or similar operations and / or inverse transformation coding as the operations and / or inverse transformation coding of the color inverse transformation unit (7010) of FIG. 7. A renderer (9011) according to the embodiments can render point cloud data.

[0212] FIG. 10 shows an example of a structure capable of interoperability with a point cloud data transmission / reception method / device according to embodiments.

[0213] The structure of FIG. 10 represents a configuration in which at least one of a server (1060), a robot (1010), an autonomous vehicle (1020), an XR device (1030), a smartphone (1040), a home appliance (1050) and / or an HMD (1070) is connected to a cloud network (1010). The robot (1010), the autonomous vehicle (1020), the XR device (1030), the smartphone (1040), or the home appliance (1050) are referred to as devices. Additionally, the XR device (1030) may correspond to a point cloud data (PCC) device according to the embodiments or may be linked with a PCC device.

[0214] The cloud network (1000) may refer to a network that constitutes part of the cloud computing infrastructure or exists within the cloud computing infrastructure. Here, the cloud network (1000) may be configured using a 3G network, a 4G or LTE (Long Term Evolution) network, or a 5G network, etc.

[0215] The server (1060) is connected to at least one of a robot (1010), an autonomous vehicle (1020), an XR device (1030), a smartphone (1040), a home appliance (1050) and / or an HMD (1070) via a cloud network (1000) and can assist in at least some of the processing of the connected devices (1010 to 1070).

[0216] The HMD (Head-Mount Display) (1070) represents one of the types in which an XR device and / or PCC device according to the embodiments may be implemented. A device of the HMD type according to the embodiments includes a communication unit, a control unit, a memory unit, an I / O unit, a sensor unit, and a power supply unit, etc.

[0217] Hereinafter, various embodiments of the device (1010 to 1050) to which the above-described technology is applied will be described. Here, the device (1010 to 1050) illustrated in FIG. 10 may be linked / coupled with a point cloud data transmission / reception device according to the above-described embodiments.

[0218] <PCC+XR>

[0219] The XR / PCC device (1030) may be implemented as a Head-Mount Display (HMD), a Head-Up Display (HUD) equipped in a vehicle, a television, a mobile phone, a smartphone, a computer, a wearable device, a home appliance, digital signage, a vehicle, a stationary robot, or a mobile robot by applying PCC and / or XR (AR+VR) technology.

[0220] The XR / PCC device (1030) can obtain information about surrounding space or real objects by analyzing 3D point cloud data or image data obtained through various sensors or from an external device to generate position data and attribute data for 3D points, and can render and output an XR object to be output. For example, the XR / PCC device (1030) can output an XR object containing additional information about a recognized object by associating it with the recognized object.

[0221] <PCC+XR+모바일폰>

[0222] The XR / PCC device (1030) can be implemented as a mobile phone (1040) or the like by applying PCC technology.

[0223] The mobile phone (1040) can decode and display point cloud content based on PCC technology.

[0224] <PCC+자율주행+XR>

[0225] The autonomous vehicle (1020) can be implemented as a mobile robot, vehicle, unmanned aerial vehicle, etc. by applying PCC technology and XR technology.

[0226] An autonomous vehicle (1020) equipped with XR / PCC technology may refer to an autonomous vehicle equipped with means for providing XR images, or an autonomous vehicle that is the subject of control / interaction within the XR images. In particular, the autonomous vehicle (1020) that is the subject of control / interaction within the XR images is distinguished from the XR device (1030) and can be interconnected with it.

[0227] An autonomous vehicle (1020) equipped with means for providing XR / PCC images can acquire sensor information from sensors including cameras and output XR / PCC images generated based on the acquired sensor information. For example, the autonomous vehicle (1020) can provide an XR / PCC object corresponding to a real object or an object in the screen to the occupant by providing an XR / PCC object by outputting an XR / PCC image with a HUD.

[0228] At this time, when the XR / PCC object is displayed on the HUD, at least a portion of the XR / PCC object may be displayed so as to overlap with the actual object to which the occupant's gaze is directed. On the other hand, when the XR / PCC object is displayed on a display provided inside the autonomous vehicle, at least a portion of the XR / PCC object may be displayed so as to overlap with an object on the screen. For example, the autonomous vehicle (1220) may display XR / PCC objects corresponding to objects such as lanes, other vehicles, traffic lights, traffic signs, motorcycles, pedestrians, buildings, etc.

[0229] VR (Virtual Reality) technology, AR (Augmented Reality) technology, MR (Mixed Reality) technology and / or PCC (Point Cloud Compression) technology according to the embodiments can be applied to various devices.

[0230] In other words, VR technology is a display technology that provides real-world objects or backgrounds solely as CG images. On the other hand, AR technology refers to a technology that displays virtual CG images alongside images of real objects. Furthermore, MR technology is similar to the aforementioned AR technology in that it mixes and combines virtual objects with the real world. However, it is distinguished from AR technology in that while AR technology maintains a clear distinction between real-world objects and virtual objects created from CG images, using virtual objects to complement real-world objects, MR technology regards virtual objects as having the same nature as real-world objects. To give a more specific example, the aforementioned MR technology is applied in hologram services.

[0231] However, recently, rather than clearly distinguishing between VR, AR, and MR technologies, they are also referred to as XR (extended Reality) technology. Accordingly, the embodiments of the present disclosure are applicable to all VR, AR, MR, and XR technologies. These technologies may utilize encoding / decoding based on PCC, V-PCC, and G-PCC technologies.

[0232] The PCC method / device according to the embodiments can be applied to a vehicle providing autonomous driving services.

[0233] Vehicles providing autonomous driving services are connected to PCC devices to enable wired / wireless communication.

[0234] When a point cloud data (PCC) transmitting / receiving device according to the embodiments is connected to a vehicle for wired / wireless communication, it can receive and process content data related to AR / VR / PCC services that can be provided along with an autonomous driving service, and transmit it to the vehicle. Additionally, when the point cloud data transmitting / receiving device is mounted on a vehicle, the point cloud transmitting / receiving device can receive and process content data related to AR / VR / PCC services according to a user input signal received through a user interface device, and provide it to the user. A vehicle or a user interface device according to the embodiments can receive a user input signal. The user input signal according to the embodiments may include a signal indicating an autonomous driving service.

[0235] The point cloud data transmission method / device according to the embodiments is interpreted as a term referring to the transmission device (10000) of FIG. 1, the point cloud video encoder (10002), the transmitter (10003), the acquisition-encoding-transmission (20000-20001-20002) of FIG. 2, the point cloud video encoder of FIG. 3, the transmission device of FIG. 8, the device of FIG. 10, the transmission device of FIG. 22, etc.

[0236] The method / device for receiving point cloud data according to the embodiments is interpreted as a term referring to the receiving device (10004) of FIG. 1, the receiver (10005), the point cloud video decoder (10006), the transmission-decoding-rendering (20002-20003-20004) of FIG. 2, the point cloud video decoder of FIG. 7, the receiving device of FIG. 9, the device of FIG. 10, the receiving device of FIG. 24, etc.

[0237] In addition, the point cloud data transmission / reception method / device according to the embodiments may be referred to simply as the method / device according to the embodiments.

[0238] According to the embodiments, geometry data, geometry information, location information, etc. constituting the point cloud data are interpreted as having the same meaning. Attribute data, attribute information, attribute information, etc. constituting the point cloud data are interpreted as having the same meaning.

[0239] The method / device according to the embodiments can process point cloud data with consideration of scalable transmission.

[0240] The method / device according to the embodiments describes a method for efficiently supporting selective decoding of a portion of data when such decoding is required due to receiver performance or transmission speed when transmitting / receiving point cloud data. In particular, this document proposes a technique to increase the efficiency of scalable coding, wherein the encoder on the transmitting side can selectively transmit information required by the decoder on the receiving side regarding already compressed data, and the decoder can decode it. In this case, the coding unit may be a tree level, LOD, layer group, subgroup, data unit, slice, fine segmentation slice (FGS), etc.

[0241] In particular, this document proposes a method to enhance the efficiency of scalable coding among point cloud data compression methods. Here, scalable coding is a technology that can progressively change the resolution of data according to conditions such as the request / processing speed / performance / transmission bandwidth of the receiver, enabling the transmitter to efficiently deliver compressed data and the receiver to decode the compressed data. To this end, packing for effectively delivering point cloud data configured based on layers may be applied in conjunction with the technology disclosed herein; in particular, when a direct compression mode is used for position compression, a method for configuring and transmitting slice segments is proposed to be more suitable for scalable PCC services. Furthermore, a compression method may be used for the efficient storage and transmission of large-capacity point cloud data that has a wide distribution and high point density.

[0242] Referring to the point cloud data transmission / reception device (or abbreviated as encoder / decoder) according to the embodiments illustrated in FIGS. 3 and 7, the point cloud data consists of a set of points, and each point consists of geometry information (or geometry or geometry data) and attribute information (or attribute or attribute data). The geometry information is the three-dimensional position information (xyz) of each point. That is, the position of each point is expressed by parameters in a coordinate system representing three-dimensional space (for example, parameters of the three axes representing space, namely the X-axis, Y-axis, and Z-axis (x,y,z)). And, the attribute information refers to the color (RGB, YUV, etc.), reflectance, normal vectors, transparency, etc. of the point. Point Cloud Compression (PCC) performs octree-based compression to efficiently compress distribution characteristics that are non-uniformly distributed in three-dimensional space, and compresses attribute information based on this. The point cloud video encoder and point cloud video decoder illustrated in FIGS. 3 and 7 can process operation(s) according to the embodiments through each component.

[0243] According to the embodiments, the transmitting device compresses the geometry information (e.g., location) and attribute information (e.g., color / brightness / reflectivity, etc.) of the point cloud data and transmits them to the receiving device. At this time, the point cloud data can be configured according to an octree structure with layers or according to the Level of Detail (LoD) based on the level of detail, and based on this, scalable point cloud data coding and representation are possible. At this time, it is possible to decode or represent only a part of the point cloud data depending on the performance or transmission speed of the receiving device, but currently there is no method to remove unnecessary data in advance.

[0244] That is, in cases where only a portion of the scalable point cloud compressed bitstream needs to be transmitted (e.g., decoding only a portion of the layers of scalable decoding), it is not possible to select and send only the necessary parts. Therefore, as shown in Fig. 11, the necessary parts must be re-encoded after decoding at the transmitting device, or as shown in Fig. 12, the entire thing must be transmitted to the receiving device and then the necessary data must be selectively applied after decoding at the receiving device.

[0245] However, in the case of Fig. 11, a delay may occur due to the time required for decoding and re-encoding, and in the case of Fig. 12, bandwidth efficiency is reduced because even unnecessary data is transmitted to the receiving device, and there is a disadvantage that data quality must be lowered when using a fixed bandwidth.

[0246] Accordingly, the method / device according to the embodiments provides slices so that the point cloud can be processed by dividing it into regions.

[0247] In particular, for octree-based position compression, entropy-based compression methods and direct coding can be used together, and in this case, we propose a slice configuration to efficiently utilize scalability.

[0248] The method / device according to the embodiments can process the bitstream by dividing it into specific units for efficient bitstream transmission and decoding.

[0249] The method / device according to the embodiments enables selective transmission and decoding of layered point cloud data at the bitstream level.

[0250] The units according to the embodiments may be referred to as LOD, layer, slice, etc. LOD is a term synonymous with LOD in attribute data coding, but in another sense, it may refer to a data unit for a layer structure of a bitstream. The LOD according to the embodiments may be a concept corresponding to a single depth or grouping two or more depths based on the depth (level) of the layer structure of point cloud data, for example, an octree or multiple trees. Similarly, a layer is intended to generate a unit of a sub-bitstream and is a concept corresponding to a single depth or grouping two or more depths, and may correspond to a single LOD or two or more LODs. Furthermore, a slice is a unit for constituting a unit of a sub-bitstream and may correspond to a single depth, a part of a single depth, or two or more depths. Additionally, a slice may correspond to a single LOD, a part of a single LOD, or two or more LODs. According to the embodiments, LOD, layer, and slice may correspond to or be included in relation to each other. Additionally, the unit according to the embodiments may include LOD, layer, slice, layer group, subgroup, etc., and may be referred to as mutually complementary. According to the embodiments, in an octree structure, layer, depth, level, and depth level may be used with the same meaning.

[0251] The method / device according to the embodiments can generate a slice layer group using the layer structure or tree structure of the point cloud data.

[0252] The method / device according to the embodiments may apply segmentation of geometry and attribute bitstreams contained in different slices. Additionally, the coding tree structure of each slice and geometry and attribute coding contained in partial tree information in terms of tree depth may be used.

[0253] FIGS. 13(a) and FIGS. 13(b) illustrate geometry coding layer structures according to embodiments. In particular, FIG. 13(a) is a diagram showing an example of three slices generated by a layer group structure in an encoder on the transmitting side, and FIG. 13(b) is a diagram showing an example of a partially decoded output using two slices in a decoder on the receiving side.

[0254] According to the embodiments, when fine granularity slicing (FGS) is enabled, a G-PCC bitstream can be divided into multiple sub-bitstreams. Here, fine granularity slicing may be referred to as layer group-based slicing. To effectively utilize the layering structure of G-PCC, each slice may contain coded data of a partial coding layer or a partial region. Through segmentation or partitioning paired with the coding layer structure, scalable transmission or spatial random access use cases can be supported in an efficient manner.

[0255] layer group based slice segmentation

[0256] In fine segmentation slicing, each slice segment may contain data coded from a layer group defined as follows.

[0257] A layer group can be defined as a group of consecutive tree layers, and the starting and ending depths of the group of tree layers can be any number in the tree depth, and the starting depth can be smaller than the ending depth. The order of data coded in a slice segment can be the same as the order of data coded in a single slice.

[0258] For example, consider a geometry coding layer structure with eight coding layers as shown in FIG. 13(a). There are three layer groups, and each layer group is matched to a different slice. More specifically, Layer Group 1 for coding layers 0 through 4 is matched to slice 1, Layer Group 2 for coding layer 5 is matched to slice 2, and Layer Group 3 for coding layers 6 through 7 is matched to slice 3. When the first two slices (i.e., slices 1 and 2) are transmitted or selected, the decoded output becomes partial layers 0 through 5, as shown in FIG. 13(b). Using slices in the layer group structure allows for partial decoding of coding layers without accessing the entire bitstream.

[0259] Bitstream and point cloud data according to the embodiments can be generated based on coding layer-based slice partitioning. By slicing the bitstream at the end of the coding layer of the encoding process, the method / device according to the embodiments can select the relevant slice, thereby supporting scalable transmission or partial decoding.

[0260] FIG. 13(a) illustrates a geometry coding layer structure having eight layers, each slice corresponding to a layer group. Layer group 1 includes coding layers 0 through 4. Layer group 2 includes coding layer 5. Layer group 3 is a group for coding layers 6 and 7. If the geometry (or attribute) has a tree structure with eight levels (depths), the bitstream can be hierarchically organized by grouping data corresponding to one or more levels (depths). Each group can be included in a single slice.

[0261] FIG. 13(b) shows the decoded output when two of the three slices are selected. When the decoder selects group 1 and group 2, partial layers from level (depth) 0 to 5 of the tree are selected. That is, by using slices of the layer group structure, partial decoding of the coding layer can be supported without accessing the entire bitstream.

[0262] For the partial decoding process according to the embodiments, the encoder may generate three slices based on a layer group structure. The decoder according to the embodiments may select two slices out of the three slices to perform partial decoding.

[0263] A bitstream according to the embodiments may include slices based on layer groups. Each slice may include a header containing signaling information regarding point cloud data (i.e., geometry data and / or attribute data) included in the slice. A receiving method / device according to the embodiments may select slices and decode point cloud data included in the payload of a slice based on a header included in a selected slice.

[0264] In addition to the layer group structure, the method / device according to the embodiments may further divide the layer group into multiple subgroups to account for spatial random access use cases. The subgroups according to the embodiments are mutually exclusive, and the set of subgroups may be identical to the layer group. Since the points of each subgroup form boundaries in a spatial region, the subgroups can be represented by subgroup bounding box information. Using spatial information, the layer group and subgroup structure can support access to the region of interest (ROI) by selecting slices that cover the ROI. Spatial random access within a frame or tile can be supported by efficiently comparing the bounding box information of the region of interest (ROI) with that of each slice.

[0265] The method / device according to the embodiments may configure a slice for transmitting point cloud data as shown in FIG. 13(a).

[0266] According to the embodiments, the entire coded bitstream may be contained in a single slice. Furthermore, for multiple slices, each slice may contain a sub-bitstream. The order of the slices may be the same as the order of the sub-bitstreams. And, each slice may be matched to a group of layers in a tree structure.

[0267] Also, just as the upper layer of a geometry tree does not affect the lower layer, slices may not affect previous slices.

[0268] The segmented slices according to the embodiments are efficient in terms of error robustness, effective transmission, and supporting region of interest.

[0269] 1) Error resilience

[0270] Compared to a single-slice structure, divided slices can be more robust to errors. That is, if a single slice contains the entire bitstream of a frame, data loss can affect the entire frame data. In contrast, when the bitstream is divided into multiple slices, even if at least one slice is lost, at least one slice unaffected by the loss can still be decoded.

[0271] 2) Scalable transmission

[0272] This document considers cases where multiple decoders with different capabilities can be supported.

[0273] If coded point cloud data (i.e., Point Cloud Compression (PCC) bitstream) is contained in a single slice, the Level of Detail (LOD) of the coded point cloud data can be determined before encoding. Therefore, multiple pre-encoded bitstreams with different resolutions of point cloud data can be transmitted independently. This can be inefficient in terms of large bandwidth or storage space.

[0274] If coded point cloud data (i.e., Point Cloud Compression (PCC) bitstream) is contained in partitioned slices, a single bitstream can support different levels of decoders. From the decoder's perspective, the receiving device can select target layers and pass a partially selected bitstream to the decoder. Similarly, by using a single bitstream instead of partitioning the entire bitstream, partial bitstreams can be efficiently generated at the transmitting device.

[0275] 3) Region-based spatial scalability

[0276] In the context of the G-PCC requirements according to the embodiments, region-based spatial scalability can be defined as follows: that is, the compressed bitstream consists of one or more layers, so that a specific region of interest can have a higher density with additional layers, and the layers can be predicted from the lower layers.

[0277] To support this requirement, it is necessary to support region-wise different detailed representations. For example, in VR / AR applications, it is desirable to represent far objects with lower precision and nearer objects with higher precision. Additionally, the decoder can increase the resolution of the region of interest upon request. This can be implemented by using scalable structures of G-PCC, such as geometry octrees and scalable attribute coding schemes.

[0278] According to the embodiments, decoders must access the entire bitstream based on the current slice structure containing the entire geometry or attributes. This can cause bandwidth, memory, and decoder inefficiencies. Meanwhile, if the bitstream is segmented into multiple slices and each slice contains sub-bitstreams according to scalable layers, the decoder according to the embodiments can select a slice as needed before efficiently parsing the bitstream.

[0279] The method / device according to the embodiments can generate layer groups using the tree structure (or layer structure) of point cloud data.

[0280] Taking Fig. 13(a) as an example, there are eight layers within the geometry coding layer structure (e.g., octree structure), and three slices can be used to contain one or more layers. A group represents a group of layers. When scalable attribute coding is used, the tree structure is identical to the geometry tree structure. The same octree-slice mapping can be used to create attribute slice segments.

[0281] A layer group according to the embodiments represents a group of layer structure units that occur in G-PCC coding, such as an octree layer, a LoD layer, etc.

[0282] A layer group represents a group of layer structure units that occur in G-PCC coding, such as an octree layer and a LoD layer.

[0283] A subgroup can be represented as a set of adjacent nodes based on location information for a single layer group. For example, it can be composed of groups of adjacent nodes according to Morton code order, distance-based adjacent nodes, or coding order. Nodes in a parent-child relationship may also exist within a single subgroup.

[0284] When a subgroup is defined, a boundary occurs in the middle of the layer, and parameters such as entropy_continuation_enabled_flag can be signaled regarding whether entropy continuity is maintained at the boundary. Additionally, continuity can be maintained by referencing the previous slice through ref_slice_id.

[0285] The tree structure according to the embodiments may be an octree structure, and the attribute layer structure or attribute coding tree according to the embodiments may include a Level of Detail (LOD) structure. That is, the tree structure for point cloud data includes layers corresponding to depth or level, and the layers may be grouped.

[0286] The method / device according to the embodiments (e.g., the octree analysis unit (30002) or LOD generation unit (30009) of FIG. 3, the octree synthesis unit (7002) or LOD generation unit (7008) of FIG. 7) can generate an octree structure of geometry or generate an LOD tree structure of attributes. Additionally, point cloud data can be grouped based on layers of the tree structure.

[0287] Referring to FIG. 13(a), multiple layers are grouped to form a first to third group. One group may be further divided to form subgroups.

[0288] According to the embodiments, a slice may contain data coded from a layer group. Here, the layer group is defined as a group of consecutive tree layers, and the start and end depths of the tree layers may be specific numbers within the tree depth, and the start is smaller than the end.

[0289] Figure 13(a) shows a geometry coding layer structure as an example of a tree structure, but a coding layer structure for attributes can be created in the same way.

[0290] FIG. 14 shows a layer group and subgroup structure according to embodiments.

[0291] Referring to Fig. 14, point cloud data and bitstreams can be represented separated by bounding boxes.

[0292] Referring to FIG. 14, a subgroup structure and bounding boxes corresponding to the subgroups are illustrated. For example, there are eight layers within the octree (i.e., layers 0 through 7), and seven slices can be used to contain sub-bitstreams (i.e., subgroups) of one or more layers. For example, layer group 1 consists of layers 0 through 5, layer group 2 contains layer 6, and layer group 3 contains layer 7. Additionally, layer group 2 can be divided into two subgroups (i.e., groups 2-1 and 2-2), and group 3 can be divided into four subgroups (i.e., groups 3-1, 3-2, 3-3, and 3-4). When scalable attribute coding is used, the tree structure is identical to the geometry tree structure. The same octree-slice mapping can be used to create attribute slice segments. In FIG. 14, layer group 1, two subgroups of layer group 2 (group2-1, group2-2), and four subgroups of layer group 3 (group3-1, group3-2, group3-3, group3-4) are included in different slices (i.e., slices 1 through 7). Given the slices of the layer groups and subgroups along with bounding box information, spatial access can be performed by 1) comparing the bounding box of each slice with the ROI, 2) selecting the slice in which the subgroup bounding box overlaps with the ROI, and 3) decoding the selected slice.

[0293] When the ROI is considered in region 3-3, slices 1, 3, and 6 are selected as the subgroup bounding boxes of layer group 1, subgroup 2-2, and 3-3 that cover the ROI area. For effective spatial access, it is assumed that there is no dependency between subgroups of the same layer group. For live streaming or low-latency use cases, time efficiency can be improved by performing selection and decoding when each slice segment is received.

[0294] The method / device according to the embodiments may represent data as a tree (45000) composed of layers (which may be referred to as depths, levels, etc.) when encoding geometry and / or attributes. Point cloud data corresponding to each layer (depth / level) may be grouped into a layer group (or group, 45001). Layer group 2 may be further divided (segmented) into two subgroups (45002), and layer group 3 may be further divided (segmented) into four subgroups (45003). Each subgroup may be composed of each slice to generate a bitstream.

[0295] A receiving device according to the embodiments receives a bitstream, selects a specific slice from the bitstream, and can decode a bounding box corresponding to a subgroup included in the selected slice. For example, if slice 1 is selected, a bounding box (45004) corresponding to layer group 1 can be decoded. Layer group 1 may be data corresponding to the largest area. When additionally displaying a detailed area for layer group 1, the method / device according to the embodiments may select slice 3 and / or slice 6 to hierarchically access the bounding boxes (point cloud data) of subgroup 2-2 and / or subgroup 3-3 for the detailed area included in the area of ​​layer group 1.

[0296] Encoding and decoding of point cloud data using the layer group and subgroup of FIG. 14 can be performed by the transmitting / receiving device of FIG. 1, the encoding and decoding of FIG. 2, the transmitting device / method of FIG. 3, the receiving device / method of FIG. 7, the transmitting / receiving device / method of FIG. 8 and FIG. 9, the devices of FIG. 10, the transmitting / receiving method of FIG. 23, FIG. 25, FIG. 26, the transmitting / receiving device of FIG. 22 and FIG. 24, and the transmitting / receiving method of FIG. 39 and FIG. 40.

[0297] FIGS. 15(a) to 15(c) show representations of layer group-based point cloud data according to embodiments.

[0298] The device / method according to the embodiments can provide efficient access to large-scale point cloud data or high-density point cloud data through layer group slicing based on scalability and spatial access capabilities. Because point cloud data has a large number of points and a large data size, rendering or displaying content may take a significant amount of time. Therefore, as an alternative approach, the level of detail can be adjusted based on the viewer's interest. For example, when the viewer is far from a scene or object, structural or overall area information is more important than local details, whereas as the viewer approaches a specific area or object, detailed information regarding the area of ​​interest is required. By using an adaptive method, the renderer according to the embodiments can efficiently provide data of sufficient quality to the viewer. FIGS. 15(a) through 15(c) illustrate examples of increasing detail for three levels of viewing distance that change based on the ROI.

[0299] The high-level view in Fig. 15(a) shows coarse detail, the mid-level view in Fig. 15(b) shows medium-level detail, and the low-level view in Fig. 15(c) shows fine-grained detail.

[0300] FIG. 16 shows a point cloud data transmission / reception device / method according to embodiments.

[0301] A multi-resolution ROI according to the embodiments can be supported when layer group slicing is used for G-PCC bitstream generation.

[0302] Referring to FIG. 16, multi-resolution ROIs can be supported by the scalability and spatial accessibility of hierarchical slicing. In FIG. 16, the encoder (47001) at the transmitting end can generate bitstream slices of spatial subgroups of each layer group or octree layer groups. Upon request, a slice matching an ROI of each resolution is selected and transmitted to the receiving end. The total bitstream size is reduced compared to a tile-based approach because it does not include details other than the requested ROI. At the receiver, the decoder (47004) can combine slices to produce three outputs, for example: 1) a high-level view output from layer group 1, 2) a mid-level view output from a selected subgroup of layer group 1 and layer group 2, and 3) a low-level view output of good quality detail from layer group 1 and selected subgroups of layer groups 2 and 3. Since the outputs can be generated progressively, the receiver can provide a viewing experience such as a zooming function in which the resolution gradually increases from the high-level view to the low-level view.

[0303] The encoder (47001) above is a point cloud encoder according to the embodiments and may correspond to a geometry encoder and / or an attribute encoder. The encoder (47001) may slice point cloud data based on layer groups (or groups). Layers may be referred to as tree depths, LOD levels, etc. As in 47002, the depths of the geometry octree and / or levels of attribute layers, etc., may be divided into layer groups (or subgroups).

[0304] The slice selector (47003) can be combined with the encoder (47001) to select a divided slice (or sub-slice) and selectively transmit it partially, such as to layer group 1 to layer group 3.

[0305] The decoder (47004) can decode optional and partially transmitted point cloud data. For example, for a high-level view, it can decode layer group 1 (high depth / layer / level or index 0, close to the root). And, for a mid-level view, it can decode based on layer group 1 and layer group 2, increasing the depth / level index more than layer group 1 alone. Additionally, for a low-level view, it can decode based on layer group 1 to layer group 3.

[0306] Referring to FIG. 16, an encoder (47001) according to the embodiments can receive point cloud data as input and slice it into layer groups. That is, the point cloud data can be structured hierarchically and divided into layer groups. In this case, the hierarchical structure may refer to an octree structure or a Level of Detail (LoD). 47002 represents the point cloud data divided into layer groups. A slice selector (47003) can select a layer group (or a corresponding slice), and the selected slices are transmitted to a decoder (47004) at the receiving end. The decoder (47004) can combine the received slices according to the user's request to restore only layer group 1, restore layer groups 1 and 2, or restore all received layer groups. The layer groups are mutually hierarchical and differ in the degree of detail. When only Layer Group 1 is restored, the restored range is wide but cannot be expressed in detail, whereas when Layer Groups 1 through 3 are all restored, the restored range is narrow but can be expressed in detail.

[0307] So far, we have explained scalable coding and decoding of geometry data.

[0308] According to the embodiments, scalable coding and decoding can also be applied to attribute data.

[0309] The present disclosure describes a layer-based attribute compression method for improving the transmission efficiency of scalable attribute compression.

[0310] In particular, the present disclosure proposes a method for generating LoD for partial coding or partial decoding of attribute data.

[0311] More specifically, the present disclosure proposes a method for efficiently performing LoD generation and nearest neighbor (NN) search when a missing slice occurs.

[0312] In addition, the present disclosure proposes a subgroup-based NN search and position correction method.

[0313] In the present disclosure, a layer group may be further divided into several subgroups. Subgroups according to the embodiments are mutually exclusive, and the set of subgroups may be identical to a layer group. Since the points of each subgroup form boundaries in a spatial region, the subgroup may be represented by subgroup bounding box information. Additionally, a single layer group may be referred to as a single subgroup. In the present disclosure, the term subgroup may be used interchangeably with slice or FGS. Accordingly, a missing (or lost) slice may be referred to as a missing subgroup or a missing FGS.

[0314] For example, a subgroup can be represented as a set of adjacent nodes within a single layer group. In this case, it may be composed of groups of adjacent nodes based on Morton code order, groups of adjacent nodes based on distance, or groups of adjacent nodes based on coding order.

[0315] Also, a subgroup may correspond to one LOD or two or more LODs. Additionally, a slice may correspond to one LOD or two or more LODs. Accordingly, in this disclosure, a subgroup may be used interchangeably with slice or FGS. According to embodiments, in an octree structure, layer, depth, level, and depth level may be used interchangeably.

[0316] In the present disclosure, subgroups may have a parent-child relationship. That is, a parent subgroup may have one or more child subgroups. And, child subgroups at the same level may be referred to as sibling subgroups.

[0317] Furthermore, while octree-based geometry coding proceeds by progressively subdividing from the root level to the leaf level, subsampling when creating LoDs proceeds from the leaf level to the root level. Taking Fig. 18 as an example, the arrow indicates the direction of subsampling. Additionally, LoD represents the degree of detail of the point cloud content; a smaller LoD value indicates lower detail, while a larger LoD value indicates higher detail. In other words, in Fig. 18, the detail at LoD N-1 is the lowest, and the detail at LoD N+2 is the highest.

[0318] In the transmitting device of the present disclosure, LoD generation and NN search are performed in the LoD generation unit (30009) of FIG. 3 or the prediction / lifting / RAHT conversion processing unit (8009) of FIG. 8 as an example. This is to aid the understanding of those skilled in the art, and LoD generation and NN search may be performed in each block or module. Additionally, in the receiving device of the present disclosure, LoD generation and NN search are performed in the LoD generation unit (7008) of FIG. 7 or the prediction / lifting / RAHT inverse conversion processing unit (9009) of FIG. 9 as an example. This is to aid the understanding of those skilled in the art, and LoD generation and NN search may be performed in each block or module.

[0319] The present disclosure describes a method for generating a LoD when geometry information is encoded (or decoded) based on a geometry tree (e.g., an octree) and there is a missing slice (i.e., a missing FGS). Additionally, the NN search method in this case is also described.

[0320] FIG. 17 is a flowchart showing an example of a method for generating LoD according to embodiments.

[0321] Assume that geometry-coded (or decoded) points in Fig. 17 are input for attribute coding (or attribute decoding). In this case, LoD can be the maximum depth of the geometry tree.

[0322] That is, subsampling for LOD generation is performed (step 48001). Then, it is checked whether the current LOD is the finest LOD of the current layer group (step 48002). Here, FGS (or layer group-based slicing) means dividing a single slice (i.e., a layer group) into multiple slices (i.e., subgroups), and step 48002 is to check whether the current LOD is the bottom within that layer group.

[0323] If it is not the finest LOD of the current layer group, proceed to step 48001; if it is the finest LOD of the current layer group, proceed to step 48003 to check if the child FGS (referred to as child FGS, child slice, or child subgroup) is missing (step 48003). That is, check if there is a missing FGS (or slice or subgroup).

[0324] If it is confirmed in Step 48003 that there are no missing FGS, proceed to Step 48001, and if it is confirmed that there are missing FGS, detect the missing nodes (Step 48004). Then, add replacement nodes for the detected missing nodes to the corresponding LOD (Step 48005). In other words, if there are missing FGS, this is a process of finding out which additional nodes are needed to create the LOD.

[0325] Then, check if it is the end of the LoD (step 48006). If it is confirmed that it is not the end of the LoD, proceed to step 48001, and if it is confirmed that it is the end of the LoD, terminate the creation of the LoD and perform an NN search based on the created LoDs.

[0326] The following is a detailed description of steps 48003 and 48004.

[0327] That is, as described above, the point cloud data transmission method / device can scalably transmit a bitstream containing point cloud data in slice (or subgroup) units, and the point cloud data reception method / device according to the embodiments can scalably receive and decode the bitstream in slice (or subgroup) units.

[0328] Therefore, at the receiving decoder, all slices may exist during decoding, but some slices may be missing. For example, if partial decoding occurs at the decoder, some slices (or subgroups or FGS) may not exist, and these slices can be referred to as missing (i.e., lost) slices (or subgroups or FGS).

[0329] Therefore, the encoder on the transmitting side of the present disclosure generates the LoD by taking such cases into account.

[0330] Figure 18 is a diagram showing an example of a method for generating LoD when there is a missing FGS (i.e., a missing subgroup).

[0331] In FIG. 18, 48010 represents a parent subgroup, and 48021 and 48025 represent child subgroups of the parent subgroup (48010). For convenience of explanation, 48021 is referred to as the first child subgroup and 48025 as the second child subgroup. At this time, it is assumed that the second child subgroup (48025) is missing.

[0332] As previously mentioned, since subsampling proceeds from the leaf level to the root level, during subsampling, the nodes of 48022-1 of the LoD N+2 layer in the first child subgroup (48021) are sibling nodes, and one of the three sibling nodes is selected as the parent node (48022). Similarly, on the right, one of the four sibling nodes is selected as the parent node. Then, one of the two parent nodes of the LoD N+1 layer is selected as the parent node (48020) of the parent subgroup (48010). That is, the node (48020) of the parent subgroup (48010) is a node created through subsampling of the nodes of the child subgroup of the lower layer.

[0333] However, since the second child subgroup (48025) is missing, the nodes (48023, 48024) of the parent subgroup (48010) cannot be generated through subsampling of the nodes of the child subgroup of the lower layer. That is, the nodes (48023, 48024) are missing nodes of the parent subgroup that cannot be generated through subsampling because the child subgroup is missing.

[0334] The present disclosure provides, in one embodiment, that when a child FGS is missing or lost, the missing nodes are detected in the finest LoD of the parent subgroup (i.e., the bottom LoD of the parent subgroup). For this process, the interim output nodes of the geometry FGS corresponding to the parent subgroup of the current attribute may be used as a reference node list (see step 48004). That is, the present disclosure provides, in one embodiment, that when there is a missing subgroup (or FGS or slice) associated with attribute information, at least one missing node of the corresponding parent subgroup is detected using the subgroup of the geometry (or FGS of the geometry). To this end, the present disclosure assumes that a layer-group structure and / or a subgroup structure are applied equally to geometry and attributes.

[0335] According to the embodiments, after comparing the subsampled nodes from the current child subgroups and the interim geometry slice output nodes, the missing nodes that are in the geometry output but not in the attribute's subsampling output are determined as missing nodes, and the geometry nodes corresponding to these missing nodes are appended to the LoD of the current subgroup. That is, LoD N is generated by the nodes subsampled from LoD N+1 and / or the missing nodes of the current layer group. At this time, the missing nodes of the current layer group are detected from the nodes of the corresponding geometry layer group and appended to the LoD. In other words, LoD N is generated using the nodes subsampled from the child subgroups of the current attribute and / or the nodes of the geometry parent subgroup corresponding to the parent subgroup of the current attribute.

[0336] In the present disclosure, nodes subsampled from LoD N+1 are indices to LoD N by the octree-based sub-sampling process in G-PCCv1. Then, missing nodes caused by missing child FGSs are detected from the geometry FGS interim output, and the detected missing nodes are added to LoD N. In the present disclosure, it is assumed that the LOD of an attribute corresponds to the octree layer of the geometry. That is, the LOD N of an attribute corresponds to the octree layer N of the geometry. Therefore, in the present disclosure, one of the nodes of the octree N of the geometry is set as the missing node of the attribute LOD N.

[0337] Thus, since the missing subgroup in the attribute exists in the layer group of the geometry, the present disclosure creates LoD N by taking the missing nodes of the parent subgroup (LoD N) of the missing subgroup (LoD N+1) from the nodes of the corresponding subgroup of the geometry. That is, the nodes taken from the corresponding subgroup of the geometry are added to LoD N.

[0338] In other words, LoD N of an attribute may include at least one node subsampled from LoD N+1 and / or at least one node (i.e., a missing node) taken from the corresponding subgroup of geometry.

[0339] The following is a description of the process of performing a nearest neighbor (NN) search based on the LoDs generated as described above.

[0340] That is, when performing an NN search, the present disclosure searches for an NN that finds the nearest neighbor of a given point using only points within the same layer group (or subgroup or slice). This is because, as previously mentioned, a missing slice (or missing FGS or missing subgroup) may exist. For example, a missing slice may occur when the slice is not transmitted to the receiving side during scalable transmission. Furthermore, since the nodes of the missing slice cannot be referenced during an NN search when a missing slice occurs, the present disclosure takes as an embodiment the performing an NN search by referencing only the nodes within the subgroup to which the current point to be decoded (or encoded) belongs.

[0341] FIG. 19 is a drawing showing an example of a nearest neighbor search method according to embodiments.

[0342] When performing an NN search, the Indexes subgroup includes at least one LOD to which the points to be encoded (or decoded) belong, and the Retained subgroup includes at least one sub-LOD based on the at least one LOD included in the Indexes subgroup. According to embodiments, the points of at least one LOD in the Indexes subgroup are sorted in ascending order based on the size of the Molton code, and the points of at least one LOD in the Retained subgroup are also sorted in ascending order based on the size of the Molton code. According to embodiments, one embodiment is to search for the NN of the current point (i.e., the point to be encoded or decoded) belonging to the Indexes subgroup among the points belonging to at least one LOD in the Retained subgroup and / or the points belonging to at least one LOD in the Indexes subgroup.

[0343] In FIG. 19, 48030 is the current point to be encoded (or decoded) in the Indexes subgroup. The present disclosure provides, as an embodiment, that when searching for the NN of the current point (48030), the NN of the current point (48030) is found among points belonging to at least one LOD of the Retained subgroup within the subgroup (48033) to which the current point (48030) belongs, and / or points belonging to the subgroup to which the current point (48030) belongs. That is, points belonging to other subgroups (48031) to which the current point (48030) does not belong are not referenced when searching for the NN of the current point (48030).

[0344] In other words, the present disclosure does not consider points (i.e., nodes) that are outside the boundary of the subgroup to which the current point (48030) belongs (i.e., outside the boundary of the subgroup to which the current point (48030) belongs) as neighbor nodes of the current point (48030) when performing an NN search. This is because the subgroup (48031) may be missed.

[0345] As such, the NN search of a point (48030) belonging to the current LoD in this disclosure is performed by finding prediction candidates and coded nodes within the current LoD among neighbor nodes selected from at least one LoD higher than the current LoD. In particular, for a fast search, the search range in this disclosure is bounded by the cubic boundary and the number of points in the Morton coding order as an embodiment. At this time, this disclosure proposes an additional constraint to consider sub-group boundaries referred to as intra-layer-group search boundaries if the neighbor candidate is within the same layer group that has the current node. That is, this disclosure performs the NN search of the current point only within the sub-group to which the current point belongs, and this is referred to as an intra-layer group search.

[0346] Intra-Layer-Group Search Boundary: If neighbor candidates are within the same layer group as the current node, the search is restricted to using neighbor nodes within the same subgroup boundary.

[0347] In other words, neighbor nodes (48037, 48038) outside the bounding box (48033) of the subgroup in this disclosure cannot be neighbor candidates (i.e., neighbor nodes or neighbor points) of the current node (48030).

[0348] Additionally, the present disclosure may use layer group adapted positions in subgroup estimation and neighbor distance calculation. Considering the case of missing child subgroups, this can prevent mismatches between encoders and decoders.

[0349] In other words, for scalable transmission, the attribute encoder creates a downsampled geometry grid by sampling the remaining layers excluding one or more skipped layers, and corrects the positions of occupied nodes including neighbor search target nodes by performing upsampling using information related to the skipped layers. Then, it calculates the distance between nodes by performing NN search based on the corrected positions. Finally, attribute prediction and compression can be performed based on the NN nodes obtained in this way.

[0350] According to embodiments, a layer group adapted position means a coded position right shifted by the number of LoDs in the coded descendant subgroups, and then left shifted by the number of LoDs in the coded descendant subgroups and skipped descendant subgroups.

[0351] Meanwhile, as other embodiments of the present disclosure, when searching for at least one neighbor node in an NN search of a current point, nodes belonging to the parent slice of the slice (i.e., child subgroup) to which the current point belongs can be used as reference nodes even if they go beyond the boundary of the child slice (i.e., subgroup).

[0352] FIG. 20 is a diagram showing another example of a nearest neighbor search method according to embodiments.

[0353] The present disclosure provides an embodiment of performing an NN search by referencing nodes (48054) within a subgroup (48053) to which the current point (48050) belongs, and nodes (48041, 48043) of a parent subgroup (48040) of the subgroup (48053) to which the current point (48050) belongs. The present disclosure refers to such an NN search as an inter-layer group search. Even in this case, nodes (48052) of another subgroup (i.e., a sibling subgroup of the subgroup to which the current point (48050) belongs) (48051) of the same layer as the subgroup (48053) to which the current point (48050) belongs are not considered (or used) as reference nodes during the NN search of the current point (48050).

[0354] That is, when the current LoD(LoD N, 48055) is at the coarsest level of the current layer group, neighbor candidates may be in a different layer group. In this case, if the neighbor candidates (i.e., neighbor nodes) are within the parent subgroup boundary, it is allowed to find the neighbors across that subgroup boundary.

[0355] According to the embodiments, in the case of an inter-layer-group search boundary, if the neighbor candidate is in the parent layer-group, it is restricted to use the neighbor nodes in the parent subgroup boundary.

[0356] In Fig. 20 as well, when using layer group adapted positions, the coded position of a node within a parent node can be handled differently when the nodes are within the subgroup bounding box of the current node.

[0357] The following is an explanation of the layer group adapted position.

[0358] Nodes within the child subgroup bounding box: coded position right shifted by the number of LoDs in the coded descendant subgroups of the current subgroup, and then left shifted by the number of LoDs in the coded descendant subgroups of the current subgroup and skipped descendant subgroups.

[0359] Nodes out of the child subgroup bounding box: coded position right shifted by the number of LoDs in the coded descendant subgroups of the parent subgroup, and then left shifted by the number of LoDs in the coded descendant subgroups of the parent subgroup and skipped descendant subgroups.

[0360] FIG. 21 is a diagram showing another example of a nearest neighbor search method according to embodiments.

[0361] In FIG. 21, 48060 represents a parent subgroup, 48061 represents a neighbor candidate outside the bounding box of the subgroup (48070), 48071 represents the current point to be encoded (or decoded) within the subgroup (48070), and 48072 represents a neighbor candidate inside the bounding box of the subgroup (48070). That is, 48061 are nodes out of the child subgroup bounding box, and 48072 are nodes within the child subgroup bounding box.

[0362] According to the embodiments, when performing an NN search, if a neighbor candidate is within the subgroup bounding box (48072), the geometry location details are considered up to the finest level (e.g., bottom level or bottom layer) of the child subgroup (48070). Meanwhile, if a neighbor candidate is outside the subgroup bounding box (48061), the geometry location details are considered up to the finest level (e.g., bottom level or bottom layer) of the parent subgroup. That is, if a neighbor candidate is outside the subgroup bounding box (48061), the child subgroup is not considered when determining the location of the point during an NN search.

[0363] FIG. 22 is a drawing showing another example of a point cloud transmitting device according to embodiments. The elements of the point cloud transmitting device shown in FIG. 22 may be implemented with hardware, software, a processor and / or a combination thereof.

[0364] According to embodiments, the point cloud transmitting device may include a data input unit (51001), a signaling processing unit (51002), a geometry encoder (51003), an attribute encoder (51004), and a transmission processing unit (51005).

[0365] The geometry encoder (51003) and attribute encoder (51004) can perform some or all of the operations described in the point cloud video encoder (10002) of FIG. 1, the encoding (20001) of FIG. 2, the point cloud video encoder of FIG. 3, the point cloud video encoder of FIG. 8, and the attribute encoding of FIG. 17 and the attribute encoding of FIG. 23.

[0366] The data input unit (51001) according to the embodiments receives or acquires point cloud data. The data input unit (51001) may perform some or all of the operations of the point cloud video acquisition unit (10001) of FIG. 1, or may perform some or all of the operations of the data input unit (8000) of FIG. 8.

[0367] The data input unit (51001) outputs the positions of the points of the point cloud data to the geometry encoder (51003) and the attributes of the points of the point cloud data to the attribute encoder (51004). Additionally, parameters are output to the signaling processing unit (51002). Depending on the embodiments, parameters may be provided to the geometry encoder (51003) and the attribute encoder (51004).

[0368] The geometry encoder (51003) constructs an octree using the positions of input points and performs geometry compression based on the octree. The geometry encoder (51003) performs entropy encoding on the compressed geometry information and outputs it to the transmission processing unit (51005) in the form of a geometry bitstream.

[0369] The geometry encoder (51003) reconstructs geometry information based on positions changed through compression and outputs the reconstructed (or decoded) geometry information to the attribute encoder (51004).

[0370] According to the embodiments, the geometry encoder (51003) constructs an octree using the positions of input points, performs layer group-based slicing on the octree, selects one or more slices, and then performs compression of the geometry information of the selected one or more slices. Since the layer group-based slicing and slice-unit geometry compression according to the embodiments have been described in detail in FIGS. 11 to 16, they are omitted here to avoid redundant description.

[0371] The attribute encoder (51004) compresses attribute information based on positions where geometry encoding has not been performed and / or reconstructed geometry information. In one embodiment, the attribute information may be coded by combining one or more of RAHT coding, LOD-based predictive transformation coding, and lifting transformation coding. The attribute encoder (51004) performs entropy encoding on the compressed attribute information and outputs it to the transmission processing unit (51005) in the form of an attribute bitstream.

[0372] According to embodiments, the attribute encoder (51004) performs LoD generation and NN search as described in FIGS. 11 to 21. That is, in one embodiment, the attribute encoder (51004) detects at least one missing node of the corresponding parent subgroup (or FGS or slice) when there is a missing subgroup (or FGS of the geometry) associated with the attribute information using the corresponding geometry subgroup (or FGS of the geometry). According to embodiments, after comparing the nodes subsampled from the current child subgroups with the interim geometry slice output nodes, the missing nodes that are present in the geometry output but not in the attribute's subsampled output are appended to the LoD of the current subgroup. That is, LoD N may include nodes subsampled from the child subgroups of the current attribute and / or nodes of the geometry parent subgroup corresponding to the parent subgroup of the current attribute.

[0373] Also, when searching the current point's NN, neighbors are selected based on distance, and there may be neighbor nodes that go beyond the subgroup to which the current point belongs.

[0374] According to the embodiments, the attribute encoder (51004) does not consider a neighbor node as a neighbor node of the current point if the neighbor node extending beyond the subgroup to which the current point belongs belongs to a sibling subgroup of the subgroup, that is, a subgroup of the same level. In other words, nodes extending beyond the boundary based on the child-level subgroup boundary are not selected as neighbors. That is, when generating a predictor based on this, by restricting the use of only nodes within the same subgroup bounding box (or boundary), accurate decoding can be achieved even in the case of partial decoding for segmented slices. At this time, the root layer group may be allowed to be referenced in all cases.

[0375] According to embodiments, the attribute encoder (51004) considers a neighbor node as a neighbor node of the current point if the neighbor node that extends beyond the subgroup to which the current point belongs belongs to the parent subgroup of the subgroup.

[0376] According to the embodiments, when performing an NN search in the attribute encoder (51004), if a neighbor candidate is within the subgroup bounding box, the geometry location details are considered up to the finest level of the child subgroup (e.g., bottom level or bottom layer). Meanwhile, if a neighbor candidate is outside the subgroup bounding box, the geometry location details are considered up to the finest level of the parent subgroup (e.g., bottom level or bottom layer).

[0377] And, the attribute encoder (51004) performs attribute prediction and compression based on the NN nodes obtained as described above.

[0378] The signaling processing unit (51002) may generate and / or process signaling information necessary for encoding / decoding / rendering geometry information and attribute information, and provide it to a geometry encoder (51003), an attribute encoder (51004), and / or a transmission processing unit (51005). Alternatively, the signaling processing unit (51002) may receive signaling information generated by the geometry encoder (51003), the attribute encoder (51004), and / or the transmission processing unit (51005). The signaling processing unit (51002) may also provide information fed back from a receiving device (e.g., head orientation information and / or viewport information) to the geometry encoder (51003), the attribute encoder (51004), and / or the transmission processing unit (51005).

[0379] In this specification, signaling information (LGSI) containing layer group-based slicing information may be signaled and transmitted in units of a parameter set (SPS: sequence parameter set, GPS: geometry parameter set, APS: attribute parameter set, TPS: Tile Parameter Set (or tile inventory), etc.) and / or attribute data units (i.e., attribute slices). That is, it may be signaled and transmitted in units of coding units (or compression units or prediction units) of each image, such as slices or tiles.

[0380] The transmission processing unit (51005) may perform an operation and / or transmission method identical or similar to the operation and / or transmission method of the transmission processing unit (8012) of FIG. 8, and may perform an operation and / or transmission method identical or similar to the operation and / or transmission method of the transmitter (10003) of FIG. 1. A detailed description is omitted here and refers to the description of FIG. 1 or FIG. 8.

[0381] The transmission processing unit (51005) can multiplex the geometry bitstream output from the geometry encoder (51003), the attribute bitstream output from the attribute encoder (51004), and the signaling bitstream output from the signaling processing unit (51002) into a single bitstream and then transmit it as is or encapsulate it into a file or segment and transmit it. In this document, the file is in ISOBMFF file format as one example.

[0382] According to the embodiments, the file or segment may be transmitted to a receiving device or stored on a digital storage medium (e.g., USB, SD, CD, DVD, Blu-ray, HDD, SSD, etc.). The transmission processing unit (51005) according to the embodiments can communicate with the receiving device via wired / wireless communication through a network such as 4G, 5G, 6G, etc. Additionally, the transmission processing unit (51005) can perform necessary data processing operations according to a network system (e.g., a communication network system such as 4G, 5G, 6G, etc.). Additionally, the transmission processing unit (51005) may transmit encapsulated data according to an on-demand method.

[0383] FIG. 23 is a flowchart illustrating an example of a method for encoding point cloud data according to embodiments. More specifically, FIG. 23 is a flowchart illustrating an example of an encoding method for performing LoD-based attribute coding in the attribute encoder (51004) of FIG. 22.

[0384] The encoding of the point cloud data of FIG. 23 can be performed by the transmitting device of FIG. 1, the encoding of FIG. 2, the transmitting device / method of FIG. 3, the transmitting device / method of FIG. 8, the devices of FIG. 10, the transmitting device of FIG. 22, or a combination thereof.

[0385] The encoding method according to the embodiments generates parameters such as SPS (Sequence parameter set), GPS (Geometry parameter set), APS (Attribute parameter set), and LGSI, and constructs a layer-group structure. The construction of the layer-group structure may be performed at or before the generation of LGSI. After geometry coding is performed, LoD generation is performed based on the restored (or reconstructed) geometry node (step 58081).

[0386] In particular, step 58081 performs LoD generation and NN search as described in FIGS. 11 to 22. That is, in one embodiment, if there is a missing subgroup (or FGS or slice) associated with attribute information, step 58081 detects at least one missing node of the corresponding parent subgroup using the subgroup of the geometry (or FGS of the geometry). According to the embodiments, after comparing the subsampled nodes from the current child subgroups with the interim geometry slice output nodes, the missing nodes that are in the geometry output but not in the subsampling output are appended to the LoD of the current subgroup. In other words, LoD N is generated by nodes subsampled from LoD N+1 and / or missing nodes of the current layer group. Here, the missing nodes of the current layer group are detected from the nodes of the corresponding geometry layer group. In other words, LoD N is generated using nodes subsampled from the child subgroups of the current attribute and / or nodes of the geometry parent subgroup corresponding to the parent subgroup of the current attribute. Additionally, neighbors are selected based on distance during the NN search of the current point, and there may be neighbor nodes that extend beyond the subgroup to which the current point belongs.

[0387] According to the embodiments, the present disclosure does not consider a neighbor node of the current point as a neighbor node of the current point if the neighbor node extending beyond the subgroup to which the current point belongs belongs to a sibling subgroup of the subgroup, that is, a subgroup of the same level. In other words, nodes extending beyond the boundary based on the child-level subgroup boundary are not selected as neighbors. That is, by restricting the use of only nodes within the same subgroup bounding box when generating a predictor based on this, accurate decoding can be achieved even in the case of partial decoding of segmented slices. In this case, the root layer group may be allowed to be referenced in all cases.

[0388] According to embodiments, the present disclosure considers a neighbor node that extends beyond the subgroup to which the current point belongs as a neighbor node of the current point if the neighbor node belongs to the parent subgroup of the subgroup.

[0389] After LoD generation and NN search are performed in step 58081, the LoD is mapped to a layer group (step 58082).

[0390] That is, by applying layer group slicing to the attribute bitstream, corresponding attributes can be provided together with the geometry bitstream that is partially decoded. At this time, the attribute coding layer can be configured as follows by utilizing the fact that the layer group is configured based on the geometry coding layer. According to the embodiments, by matching the LoD based on the layer group structure configured based on the geometry coding layer, the geometry output and the attribute output can be matched when partial decoding is performed.

[0391] For example, there is a method of matching geometry coding layers and attribute coding layers one-to-one. In this case, octree-based subsampling and RAHT-based attribute coding can be performed. Other examples include a method of matching layer groups and attribute coding layers one-to-one, and a method in which multiple attribute coding layers are included in a layer group. That is, in the case of LoD-based attribute coding, the method of creating layer groups can affect compression efficiency because performance may vary as the nearest neighbor (NN) changes depending on the LoD configuration.

[0392] Then, quantization weights are calculated based on LoD (step 58083).

[0393] For example, when nodes are separated and transmitted due to layer group slicing, subgroup boundaries and layer group boundaries must also be considered for quantization weights. That is, the layer group and sub-layer group to which the node to be encoded (or to which quantization weights are to be applied) belongs are determined (steps 58084, 58085). The present disclosure may support partial decoding by restricting quantization weight updates to be performed only within the sub-group boundaries of the leaf layer group. That is, the present disclosure may align parent-child sub-group boundaries and restrict selection to neighbors only for nodes existing within the child sub-group boundaries. In this case, for layer group slicing, the root layer group does not perform subdivision, and as a method to support partial decoding, a fixed weight may be used for the root layer group. As another example, quantization weights may be applied adaptively on a sub-group basis.

[0394] Afterward, when each attribute coding layer is changed, the layer-group is checked for changes, and for each node within the attribute coding layer, the subgroup is checked for changes (step 58086). That is, since one or more attribute coding layers constitute a single layer group, when an attribute coding layer is changed, the layer group to which the changed attribute coding layer belongs may or may not change. Additionally, the subgroup to which the changed attribute coding layer belongs may or may not change. For example, the nodes to be encoded in the attribute coding layer before the change belonged to subgroup 3-1, but the nodes to be encoded in the changed attribute coding layer may belong to subgroup 3-2. Therefore, when a subgroup or layer-group changes, attribute encoder information for the previous subgroup is saved, and by using the attribute encoder for the current subgroup, continuity of context, zeroruns, etc. within the subgroup can be guaranteed, and independence from neighboring subgroups can be guaranteed (step 58087). In particular, zeroruns can provide greater compression efficiency when zeros appear consecutively, and by providing continuity for zeroruns within the same layer group and subgroup, additional compression efficiency can be provided even when the attribute coding layer changes. Once compression of nodes belonging to all attribute coding layers is completed, the encoded bitstream for each subgroup is packaged into a respective slice.

[0395] FIG. 23 is described based on LoD-based attribute coding, but the encoding according to the embodiments can be applied to other types of attribute coding such as RAHT.

[0396] The transmitting device / method according to the embodiments may perform the steps of generating an LoD (step 58081) and mapping the LoD to a layer group (step 58082), and may perform the step of deriving quantization weights (step 58083). Then, it may include the steps of determining a layer group (step 58084) and determining a subgroup (step 58085), checking whether the subgroup has been changed (step 58086), and storing and retrieving context information (step 58087) to encode attribute information (step 58088). The above-described process may be performed for each node or for each level of the LoD.

[0397] The step of generating an LoD according to the embodiments (step 58081) may include a subsampling, building predictor, or neighbor search process. In this case, the building predictor or neighbor search (i.e., NN search) in the LoD generation step may be performed based on the boundaries of a subgroup. For example, the neighbor nodes of the first node may be selected from among the nodes located within the boundaries of the subgroup to which the first node belongs.

[0398] Meanwhile, when attribute layer group slicing is applied, a delay occurs in partial decoding use cases when attribute slices are decoded after LoD generation, where all LoD layers are generated from full-depth geometry data. To solve this, the present disclosure proposes a method for generating LoDs by subgroup.

[0399] That is, the present disclosure provides an embodiment in which LoD generation is performed on a subgroup basis when attribute layer group slicing is applied. In this case, the input nodes (or points) for generating the LoD of the current subgroup may include not only the nodes of the current subgroup but also the nodes of the parent subgroup of the current subgroup. That is, the nodes of the current subgroup are input to the partial LoD generation unit. Additionally, the nodes of the parent subgroup are also used for decoding the current subgroup. In particular, the present disclosure provides an embodiment in which the nodes (parent nodes) (or parent points) belonging to the parent subgroup selected for generating the LoD of the current subgroup are nodes outside the bounding box of the current subgroup. That is, the nodes belonging to the parent subgroup selected for generating the LoD of the current subgroup are nodes that are not included within the range of the current subgroup. Here, not being included within the range of the current subgroup means being outside the boundary of the current subgroup. For example, assuming that a parent subgroup includes a first child subgroup and a second child subgroup, and the first child subgroup is the current subgroup, the second child subgroup corresponds to a subgroup that is not included within the range of the current subgroup or is outside the boundary of the current subgroup. In other words, the input to the LoD generation unit for the current subgroup consists of nodes belonging to the current subgroup and nodes belonging to the parent subgroup (current points + parent points), while duplicate nodes are excluded. That is to say, from the perspective of LoD, the nodes belonging to the bottom LoD layer of the parent subgroup (e.g., LoDn-1) are nodes subsampled from the top LoDs (i.e., nodes) of the child subgroup (e.g., LoDn).At this time, to avoid the redundant use of the nodes in both LoDs in the layer-group boundary, the node of the parent subgroup out of the current subgroup bounding box is included.

[0400] To this end, in the present disclosure, subgroup unit LoD generation may include a subgroup decoder (or referred to as the LoD generation unit of the current subgroup or the partial LoD generation unit) input generation step, a partial LoD generation step, and a parent attribute inheritance step. Afterward, a prediction or lifting transformation (or inverse transformation) is performed. In the present disclosure, subgroup LoD generation and attribute transformation (or attribute inverse transformation) are performed for all selected slices as an example.

[0401] In this disclosure, LoD generation and NN search of the current subgroup may be performed identically or differently in the encoder of the transmitting device and the decoder of the receiving device using the nodes of the current subgroup and the nodes of the parent subgroup of the current subgroup described above. For example, LoD generation and NN search may be performed in the encoder of the transmitting device on a layer group basis, and LoD generation and NN search may be performed in the decoder of the receiving device on a subgroup basis, and in this case, LoD generation and NN search of the current subgroup may be performed using the nodes of the current subgroup and the nodes of the parent subgroup of the current subgroup.

[0402] FIG. 24 is a drawing showing another example of a point cloud receiving device according to embodiments. The elements of the point cloud receiving device shown in FIG. 24 may be implemented as hardware, software, a processor and / or a combination thereof.

[0403] According to embodiments, the point cloud receiving device may include a receiving processing unit (61001), a signaling processing unit (61002), a geometry decoder (61003), an attribute decoder (61004), a geometry buffer (61005), an attribute buffer (61006), and a post-processor (61007).

[0404] The receiving processing unit (61001) according to the embodiments may receive a single bitstream, or may receive a geometry bitstream, an attribute bitstream, and a signaling bitstream, respectively. When a file and / or segment is received, the receiving processing unit (61001) according to the embodiments may decapsulate the received file and / or segment and output it as a bitstream.

[0405] A receiving processing unit (61001) according to the embodiments can, when a bitstream is received (or decapsulated), demultiplex a geometry bitstream, an attribute bitstream, and / or a signaling bitstream from the bitstream, and output the demultiplexed signaling bitstream to a signaling processing unit (61002), the geometry bitstream to a geometry decoder (61003), and the attribute bitstream to an attribute decoder (61004).

[0406] According to the embodiments, when a geometry bitstream, an attribute bitstream, and / or a signaling bitstream are each received (or decapsulated), the receiving processing unit (61001) can transmit the signaling bitstream to the signaling processing unit (61002), the geometry bitstream to the geometry decoder (61003), and the attribute bitstream to the attribute decoder (61004).

[0407] A receiving processing unit (61001) according to the embodiments separates a geometry bitstream and an attribute bitstream into slice units or subgroup units based on signaling information processed by a signaling processing unit (61002), and transmits the geometry bitstream in slice units / subgroup units to a geometry decoder (61003), and the attribute bitstream in slice units / subgroup units to an attribute decoder (61004). For example, the input of the attribute decoder (61004) may include an attribute fine granularity slice bitstream (or an attribute layer group-based slice bitstream), decoded geometry data, and a layer-group structure.

[0408] The signaling processing unit (61002) can parse and process signaling information, such as SPS, GPS, APS, TPS, metadata, etc., from an input signaling bitstream and provide it to a receiving processing unit (61001), a geometry decoder (61003), an attribute decoder (61004), a geometry buffer (61005), an attribute buffer (61006), and a post-processing unit (61007). In another embodiment, signaling information included in a geometry data unit header and / or an attribute data unit header may also be parsed in advance by the signaling processing unit (61002) before decoding the corresponding slice (or subgroup) data. In the present disclosure, the geometry buffer (61005) may store nodes belonging to the current subgroup and / or nodes belonging to the parent subgroup of the current subgroup for geometry decoding. Additionally, the attribute buffer (61006) may include nodes belonging to the current subgroup and / or nodes belonging to the parent subgroup of the current subgroup for attribute decoding. In the present disclosure, the attribute buffer (61005) may be used as an input buffer for generating LoDs.

[0409] According to the embodiments, the signaling processing unit (61002) may also parse and process information signaled in the sequence parameter set and / or attribute data unit header (e.g., layer group-based slicing related information) and provide it to the attribute decoder (61004) and attribute buffer (61006).

[0410] According to the embodiments, the geometry decoder (61003) can restore the geometry by performing the inverse process of the geometry encoder (51003) of FIG. 22 based on signaling information for the compressed geometry bitstream. The geometry information restored (or reconstructed) in the geometry decoder (61003) is provided to the attribute decoder (61004). The attribute decoder (61004) can restore the attributes by performing the inverse process of the attribute encoder (51004) of FIG. 22 based on signaling information and reconstructed geometry information for the compressed attribute bitstream.

[0411] According to the embodiments, the attribute decoder (61004) can perform LoD generation and NN search in subgroup units, and the detailed process will be explained later with reference to FIGS. 25 to 29.

[0412] According to the embodiments, the post-processing unit (61007) can reconstruct and display / render point cloud data by matching geometry information (i.e., positions) restored and output from the geometry decoder (61003) with attribute information restored and output from the attribute decoder (61004).

[0413] According to the embodiments, the attribute decoder (61004) may also include an LoD generation unit that performs LoD generation and NN search. FIG. 25 illustrates an example of a method for decoding point cloud data according to the embodiments. More specifically, FIG. 25 is a flowchart showing an example of a decoding method that performs LoD-based attribute decoding in the attribute decoder (61004) of FIG. 24.

[0414] The point cloud data decoding of FIG. 25 can be performed by the receiving device of FIG. 1, the decoding of FIG. 2, the receiving device / method of FIG. 7, the receiving device / method of FIG. 9, the devices of FIG. 10, the decoder of FIG. 24, or a combination thereof.

[0415] The input of the attribute decoder (61004) is an attribute fine granularity slice bitstream (or an attribute layer group-based slice bitstream), decoded geometry data, and a layer-group structure. After geometry decoding, LoD generation and NN search are performed based on the decoded geometry data. Here, since LoD generation and NN search have been described in detail in FIGS. 1 to 23, they will be omitted here to avoid redundant explanation. That is, LoD generation and NN search can be performed in the same manner in the encoder on the transmitting side and the decoder on the receiving side, respectively. In other words, the process of LoD generation and NN search is performed in the point cloud decoder as well as the point cloud encoder.

[0416] Then, weight derivation is performed based on the relationships between nodes according to the LoD. The information generated at this stage can be used in the subsequent attribute decoding process. The first attribute slice can operate in the same way as the previous attribute slice. Subsequently, if layer-group slicing is enabled, the dependent attribute data unit header is parsed, and the layer group identification information (dadu_layer_group_id) and subgroup identification information (dadu_subgroup_id) can be obtained. If necessary, information regarding the LoD can be signaled. Based on this, the layer group matching the current LoD can be found, and the parent subgroup can be selected. As disclosed in the present disclosure, when a layer-group structure is applied equally to geometry and attributes, reference and parent information used in geometry decoding can be used. Based on this, information of dependent attribute data units can be decoded and point cloud data can be reconstructed.

[0417] The LoD generation and weight derivation methods used in the encoder (51004) during decoding according to the embodiments may be used.

[0418] Referring to FIG. 25, the decoding method for point cloud data according to the embodiments may include a step of generating a LoD (step 62091) and a step of deriving quantization weights (step 62092). Steps 62091 and 62092 may correspond to the LoD generation, NN search, and weight derivation processes of the attribute encoder (51004) of the transmitting device. The decoding method according to the embodiments may generate a LoD and deriving quantization weights by considering the boundaries of the subgroups, similar to the LoD generation, NN search, and weight derivation methods performed during the encoding process. At this time, the step of generating a LoD may include the process of generating a predictor and searching for an NN. Since the generation of a predictor and neighbor search have been described in detail in FIGs. 17 to 23, a detailed description is omitted here.

[0419] The decoding method according to the embodiments parses an attribute data unit header (step 62093) and decodes an attribute data unit (step 62094). Then, it determines whether layer group slicing is enabled (step 62095), and if layer group slicing is enabled, it parses a dependent attribute data unit header (step 62096). Then, it maps the LoD to the layer group (step 62097), selects a parent subgroup (step 62098), and can decode the dependent attribute data unit.

[0420] In FIG. 25, step 62095 can be determined through layer_group_enabled_flag. If Layer_group_enabled_flag is 1, it indicates that layer group slicing is performed. Layer group slicing may indicate that point cloud data (geometry or attributes) is grouped into layer groups or subgroups for processing.

[0421] When parsing the dependent attribute data unit header in step 62096, the LoD and layer group are mapped (step 62097), and the parent subgroup is selected (step 62098) to decode the attributes contained in the dependent data unit.

[0422] The dependent attribute data unit header can specify layer group indices and subgroup indices by including layer group identification information (dadu_layer_group_id) and subgroup identification information (dadu_subgroup_id). Additionally, the dependent attribute data unit header may further include bounding box origin information and size information for each subgroup. Furthermore, the dependent attribute data unit header may further include information regarding the reference layer group and reference subgroup, as well as quantization weight information for the current subgroup.

[0423] According to the embodiments, dadu_layer_group_id and dadu_subgroup_id can be utilized in the step of mapping the LoD and the layer group (step 62097), and the bounding box origin information and size information of the subgroup can be used to compare bounding box information in the step of selecting the parent subgroup (step 62098).

[0424] The decoding method according to the embodiments can perform decoding by referencing context information based on layer groups and subgroups. Context information may be referred to as context state information or state information, etc. Reference of context information may be performed using signaling information such as information about reference layer groups and reference subgroups, or by deriving and referencing a parent subgroup based on the bounding box information of a subgroup.

[0425] As mentioned above, LoD-based attribute coding can be performed as follows. That is, LoDs are generated based on geometry-decoded points, and then attribute coding is performed through prediction based on neighbor relationships between nodes belonging to each LoD. In particular, LoD generation could be performed after geometry decoding was completed. Therefore, even if the geometry / attribute bitstreams consist of slices, attribute slice decoding begins only after all geometry slices of the region of interest have been decoded, which became a delay factor in rapidly decoding the slices of interest.

[0426] To address this, the present disclosure proposes a method for generating LoDs in subgroup units. That is, in the present disclosure, geometry coding, LoD generation, and attribute coding are performed in slice units / subgroup units, thereby enabling more active response to low-latency environments.

[0427] In the present disclosure, geometry coding-LoD generation-attribute coding in slice units / subgroup units is performed in the encoder of the transmitting device, and geometry decoding-LoD generation-attribute decoding in slice units / subgroup units is performed in the decoder of the receiving device.

[0428] FIG. 26 illustrates another example of a method for decoding point cloud data according to embodiments. More specifically, FIG. 26 is a flowchart showing another example of a decoding method that performs LoD-based attribute decoding in the attribute decoder (61004) of FIG. 24.

[0429] The point cloud data decoding of FIG. 26 can be performed by the receiving device of FIG. 1, the decoding of FIG. 2, the receiving device / method of FIG. 7, the receiving device / method of FIG. 9, the devices of FIG. 10, the decoder of FIG. 24, or a combination thereof.

[0430] According to embodiments, the input of the attribute decoder (61004) may include an attribute fine granularity slice bitstream (or an attribute layer group-based slice bitstream), decoded geometry data, and a layer-group structure.

[0431] Additionally, the attribute decoder (61004) may include an LoD generation unit for LoD generation and NN search on a subgroup basis. In the present disclosure, the LoD generation unit may include an input node selection unit that selects (or generates or determines) input nodes from the current subgroup and the parent subgroup of the current subgroup for LoD generation of the current subgroup, a partial LoD generation unit that generates the LoD of the current subgroup based on the selected input nodes, and a parent attribute inheritance unit for inheriting parent attributes as attributes of some nodes of the current subgroup. FIG. 26 is a flowchart showing an example of LoD generation performed in the input node selection unit, the partial LoD generation unit, and the parent attribute inheritance unit.

[0432] In the hierarchical structure (e.g., tree structure) of the present disclosure, a node may be used with the same meaning as a point. That is, depending on the position of the node within the hierarchical structure, a node may correspond to a single point, or a node may include two or more points.

[0433] That is, in FIG. 26, if layer group slicing is enabled, a LoD is generated in subgroup units, weights are derived based on the LoD generated in subgroup units, and attributes are restored by performing an attribute transform (e.g., prediction / lifting inverse transform) on the nodes within the LoD.

[0434] In addition, in FIG. 26, when corresponding geometry slices and attribute slices are transmitted alternately, if a geometry slice remains, the geometry decoder is restarted and the corresponding attribute decoder is operated. If attribute slices are transmitted after geometry slices, the entire attribute slice can be decoded after decoding the entire geometry slice.

[0435] In FIG. 26, parsing of SPS, GPS, APS, and LGSI is performed in a signaling processing unit (61002), and geometry decoding is performed in a geometry decoder of FIG. 7 or FIG. 9 or a geometry decoder (61003) of FIG. 24 based on signaling information and a geometry buffer (61005) as an embodiment. In addition, the remaining steps (e.g., steps 63010-63020), including parsing of an attribute data unit header (or dependent attribute data unit header), are performed in an attribute decoder of FIG. 7 or FIG. 9 or an attribute decoder (61004) of FIG. 24 based on an attribute buffer (61006) as an embodiment.

[0436] According to the embodiments, signaling information including layer group-based slicing related information can be signaled to at least one of SPS, GPS, APS, TPS (or tile inventory), and attribute data unit (i.e., attribute slice).

[0437] According to the embodiments, information related to layer group-based slicing may include layer_group_enabled_flag. The present disclosure indicates that if the value of layer_group_enabled_flag is 1, layer group slicing is performed, and if it is 0, layer group slicing is not performed. In the present disclosure, performing layer group slicing means that point cloud data (geometry and / or attributes) is grouped into layer groups or subgroups and processed.

[0438] According to the embodiments, in step 63010, the attribute data unit header is parsed, and in step 63011, if the value of layer_group_enabled_flag is 1, the attribute decoder (61004) generates LoDs in subgroup units.

[0439] In the present disclosure, LoD generation in subgroup units is performed in an LoD generation unit within an attribute decoder as an example. In the present disclosure, the LoD generation unit may correspond to the LoD generation unit (7008) of FIG. 7 or the prediction / lifting / RAHT inverse transformation processing unit (9009) of FIG. 9.

[0440] In the present disclosure, the LoD generation unit must first receive nodes (or points) for the subgroup in order to generate an LoD in subgroup units (step 63015). That is, if layer group slicing is enabled in step 63011 (e.g., the value of layer_group_enabled_flag is 1), step 63015, which generates a subgroup input point cloud by the input node selection unit, is performed.

[0441] According to the embodiments, in step 63015, as a method to increase the compression efficiency of subgroup-based attribute coding, at least one node (or point) of a subgroup related to the current subgroup may be used.

[0442] In one embodiment, the input point cloud of a subgroup decoder (i.e., referred to as a partial LoD generator as an LoD generator for the current subgroup) may consist of node(s) of the current subgroup and node(s) of the parent subgroup of the current subgroup. In this disclosure, node may be used interchangeably with point depending on the location of the current subgroup.

[0443] In this disclosure, the process of selecting (or determining) input nodes for generating the LOD of the current subgroup in step 63015 is referred to as a pre-processing process. Additionally, in this disclosure, step 63015 is performed by an input node selection unit (not shown) as one embodiment. The input node selection unit may be referred to as a pre-processor.

[0444] According to the embodiments, in step 63015, position correction can be performed for the nodes belonging to the current subgroup. That is, since decoding can be performed without the geometry tree depth reaching full depth, compensation can be made for the difference between the final geometry tree depth and the geometry tree depth for the current subgroup. In other words, since attributes can be decoded without decoding all the geometry, the difference between the final geometry tree depth and the maximum geometry tree depth for the current subgroup is compensated.

[0445] The present disclosure allows the positions of nodes currently input to the subgroup LoD generator (or subgroup decoder or partial LoD generator) to be corrected and input as shown in the following formula.

[0446] treeLvlGap = Final geometry tree depth - Maximum geometry tree depth for the current subgroup

[0447] For example, if the final geometry tree depth is 10 and the maximum geometry tree depth for the current subgroup is 7, then the depth of 3 is compensated for by zero padding through shifting, and then LoD generation is performed.

[0448] The following code shows an example of correcting (treeLvlGap) the positions of nodes input to the LoD generator (or subgroup decoder) of the current subgroup (curSubgroup).

[0449] if (curLayerGroup < layerGroupParams.numLayerGroupsMinus1 - _params.numSkipLayerGroups) {

[0450] auto pointCloud_subgroup_fifo = _layerGroupParams.pointCloud_tempNodes[curLayerGroup][curSubgroup];

[0451] tempPointCloud.resize(pointCloud_subgroup_fifo.getPointCount());

[0452] for (int i = 0; i < pointCloud_subgroup_fifo.getPointCount(); i++) {

[0453] tempPointCloud[i] = pointCloud_subgroup_fifo[i] << treeLvlGap;

[0454] tempIdxToPointIdx.push_back(-1);

[0455] }

[0456] tempPointCloudIdx.push_back(tempPointCloud.getPointCount());

[0457] }

[0458] According to the embodiments, step 63015 (or input node selection unit) can generate the node(s) belonging to the parent subgroup and the node(s) belonging to the current subgroup as inputs to the LoD generation unit of the current subgroup (i.e., referred to as the subgroup decoder or partial LoD generation unit) after performing position precision correction between different layer groups through the above process. This is so that when performing NN search after LoD generation, the nodes in the parent subgroup are also considered as neighbor candidates.

[0459] FIG. 27 is a drawing showing an example of points (or nodes) included in each subgroup according to the embodiments.

[0460] In FIG. 27, let the current subgroup be subgroup C, and consider subgroup A as the parent subgroup of subgroup C. In this case, subgroup A includes two child subgroups (subgroup B, subgroup C), and the two child subgroups (subgroup B, subgroup C) are siblings. At this time, the input to the partial LoD generator (i.e., subgroup decoder) for the current subgroup (e.g., subgroup C) may include nodes f, h - q belonging to the current subgroup (i.e., subgroup C) and nodes d, h, o, r belonging to the parent subgroup (i.e., subgroup A). ​​That is, nodes ae belonging to the subgroup (i.e., subgroup B) that is sibling to the current subgroup (e.g., subgroup C) are not included (i.e., excluded) in the input nodes of the partial LoD generator (i.e., subgroup decoder) for the current subgroup (e.g., subgroup C). In the present disclosure, one embodiment is provided that there is no dependency between subgroup B and subgroup C.

[0461] According to the embodiments, in the present disclosure, when step 63015 (or input node selection unit) includes in the input node(s) belonging to the parent subgroup associated with the current subgroup, only node(s) not included in the range of the current subgroup may be added. This is because, by the definition of a LoD that a lower LoD includes all node(s) of a parent LoD, the node(s) belonging to the bottom LoD (or bottom layer or bottom LoD layer) of the parent subgroup are all included in the top LoD (or top layer or top LoD layer) of the child subgroup. That is, among the nodes included in the parent subgroup, node(s) that overlap with the node(s) included in the current subgroup are not included in the input of the partial LoD generation unit (i.e., subgroup decoder) for the current subgroup (i.e., are excluded).

[0462] FIG. 28 is a diagram showing an example of LoDs generated through subsampling according to embodiments. For convenience of explanation, in this disclosure, 65011 corresponds to subgroup A of FIG. 27 and is referred to as the parent subgroup. 65012 corresponds to subgroup B of FIG. 27 and is referred to as the first child subgroup or the first subgroup, and 65013 corresponds to subgroup C of FIG. 27 and is referred to as the second child subgroup or the second subgroup. That is, the first subgroup (65012) and the second subgroup (65013) are sibling subgroups, and 65011 corresponds to the parent subgroup of the first and second subgroups (65012, 65013). In this disclosure, it is assumed that there is no dependency between the first subgroup (65012) and the second subgroup (65013). In other words, it is assumed that there is no dependency between sibling subgroups. Also, 65014 corresponds to a layer group boundary separating two layer groups, and 65015 corresponds to a subgroup boundary separating two subgroups (e.g., the first subgroup (65012) and the second subgroup (65012)). That is, the first subgroup (65012) and the second subgroup (65012) form one layer group, and the parent subgroup (65011) forms another layer group. In other words, one layer group corresponds to one subgroup, or it can be divided into two or more subgroups. Here, "first" and "second" are merely terms used to distinguish and describe two child subgroups.

[0463] Additionally, in a hierarchical structure (e.g., a tree structure) for attribute decoding, a layer group (or subgroup) can be defined as a group of consecutive layers. In this case, the layer located at the top of each group is called the top layer (or top LoD layer), and the layer located at the bottom is called the bottom layer (or bottom LoD layer). For example, in the parent subgroup (65011), 65016 corresponds to the bottom layer (or bottom LoD layer) of the parent subgroup (65011), and in the second subgroup (65013), 65016 corresponds to the top layer (top LoD layer) of the second subgroup (65013).

[0464] Also, in one subgroup, layers can correspond to LoDs. That is, if there are two layers in one subgroup, two LoDs can also be generated in that subgroup. Taking the second subgroup (65013) in FIG. 28 as an example, two LoDs (i.e., LoDn+1, LoDn) are generated in the second subgroup (65013). Similarly, two LoDs (i.e., LoDn+1, LoDn) are generated in the first subgroup (65013). This is because LoDs are generated on a subgroup basis.

[0465] In this case, when considering subsampling during the LoD generation process, some of the nodes belonging to the lower LoD are subsampled and included in the upper LoD, as shown in FIG. 28. In FIG. 28, the dotted circles represent the nodes that are subsampled from the corresponding LoD.

[0466] For example, in FIG. 28, in the first subgroup (65012), node a among nodes a, b, and c of LoDn+1 is subsampled, and node d among nodes d and e is subsampled and included in LoDn, and node d among nodes a and d of LoDn is subsampled and included in the bottom LoD of the parent subgroup (65011), i.e., LoDn-1. Similarly, in the second subgroup (65013), node f of LoDn+1, node h among nodes hk, node l among nodes ln, and node o among nodes oq are subsampled and included in LoDn, and node h among nodes f and h of LoDn and node o among nodes l and o are subsampled and included in the bottom LoD of the parent subgroup, i.e., LoDn-1. The present disclosure provides, in one embodiment, that when subsampling is performed in a tree structure, at least one of the child nodes having the same parent is subsampled.

[0467] Referring to FIG. 28, among the nodes d, h, and o belonging to the parent subgroup (65011), node d is a node subsampled from the first subgroup (65012), and nodes h and o are nodes subsampled from the second subgroup (65013).

[0468] At this time, assuming the current subgroup is the second subgroup (65013), when including nodes belonging to the parent subgroup (65011) as input to the partial LoD generation unit for the second subgroup (65013), the nodes h and o subsampled from the second subgroup (65013) are excluded.

[0469] That is, if all nodes within the parent subgroup are included without considering subsampling, nodes h and o are included redundantly. In other words, nodes h and o are included in both the second subgroup (65013) and the parent subgroup (65011). In this case, a mismatch with the encoder occurs, causing a decoding error in the attribute decoder.

[0470] Accordingly, step 63015 (or input node selection unit) is, as an example, configured to include only the node(s) outside the current subgroup bounding box among the nodes belonging to the parent subgroup, as shown in the code below, in order to generate inputs for the subgroup decoder (or partial LoD generation unit) while avoiding node duplication. That is, only the node(s) outside the current subgroup bounding box among the nodes of the parent subgroup are selected as the input nodes for the partial LoD generation unit for the current subgroup. At this time, the selected node(s) can become neighbor candidates during NN search after LoD generation. In the parent subgroup of FIG. 28, among nodes d, h, and o, node d is selected for LoD generation of the second subgroup (65013). This is to avoid duplication, as the input nodes of the partial LoD generation unit for the current subgroup (e.g., the second subgroup (65013)) include both nodes f and hq belonging to the second subgroup (65013). In step 63015 (or input node generation unit), the nodes generated for the LoD of the current subgroup are stored in an input buffer (attribute buffer of FIG. 24) for LoD generation as one embodiment. In the present disclosure, the input nodes for the current subgroup stored in the input buffer are provided to a partial LoD generation unit for LoD generation of the current subgroup as one embodiment.

[0471] According to the embodiments, the underlined part in the code below is the part that selects the node(s) outside the current subgroup bounding box among the nodes of the parent subgroup as the input nodes of the partial LoD generation part for the current subgroup.

[0472] if (curLayerGroup > 0) {

[0473] / parent subgroup nodes out of the current bbox

[0474] auto bbox_min = _layerGroupParams.subgrpBboxOrigin[curLayerGroup][curSubgroup];

[0475] auto bbox_max = bbox_min + _layerGroupParams.subgrpBboxSize[curLayerGroup][curSubgroup];

[0476] int treeLvlGap_parent = _sps->root_node_size_log2.max() - accLayer[parentLayerGroup];

[0477] auto pointCloud_subgroup_fifo_parent = _layerGroupParams.pointCloud_tempNodes[parentLayerGroup][parentSubgroup];

[0478] int pointCount_parentNonIdcm = pointCloud_subgroup_fifo_parent.getPointCount();

[0479] auto bbox_min_parent = _layerGroupParams.subgrpBboxOrigin[parentLayerGroup][parentSubgroup];

[0480] auto bbox_max_parent = bbox_min_parent + _layerGroupParams.subgrpBboxSize[parentLayerGroup][parentSubgroup];

[0481] int pointCount = tempPointCloud.getPointCount();

[0482] tempPointCloud.resize(pointCount + pointCount_parentNonIdcm);

[0483] int count = 0;

[0484] if (!(bbox_min == bbox_min_parent && bbox_max == bbox_max_parent) {

[0485] for (int i = 0; i < pointCount_parentNonIdcm; i++) {

[0486] auto pos = pointCloud_subgroup_fifo_parent[i] << treeLvlGap_parent;

[0487] if (!(pos >= bbox_min && pos < bbox_max)) {

[0488] int tempIdx = pointCount + count++;

[0489] tempPointCloud[tempIdx] = pos;

[0490] if (attr_sps.attr_num_dimensions_minus1 == 0)

[0491] tempPointCloud.setReflectance(tempIdx, pointCloud_subgroup_fifo_parent.getReflectance(i));

[0492] else if (attr_sps.attr_num_dimensions_minus1 == 2)

[0493] tempPointCloud.setColor(tempIdx, pointCloud_subgroup_fifo_parent.getColor(i));

[0494] tempIdxToPointIdx.push_back(-1);

[0495] }

[0496] }

[0497] }

[0498] else

[0499] tempPointCloud.resize(pointCount + count);

[0500] tempPointCloudIdx.push_back(tempPointCloud.getPointCount());

[0501] }

[0502] As such, when attribute layer group slicing is applied, the present disclosure may include not only the nodes of the current subgroup but also the nodes of the parent subgroup of the current subgroup as inputs for generating the LoD of the current subgroup. That is, the nodes of the current subgroup are input to the partial LoD generation unit. Additionally, the nodes of the parent subgroup of the current subgroup are also input to the partial LoD generation unit for generating the LoD of the current subgroup. In this case, as an example, the parent nodes (or parent points) belonging to the parent subgroup selected for generating the LoD of the current subgroup are nodes outside the bounding box of the current subgroup. That is, the nodes belonging to the parent subgroup selected for generating the LoD of the current subgroup are nodes that are not included within the range of the current subgroup. Here, not being included within the range of the current subgroup means being outside the boundary of the current subgroup. For example, assuming a parent subgroup includes a first child subgroup and a second child subgroup, and the first child subgroup is the current subgroup, the second child subgroup corresponds to a subgroup that is not included within the range of the current subgroup or is outside the boundary of the current subgroup. In other words, from the perspective of LoD, the nodes belonging to the bottom LoD layer of the parent subgroup (e.g., LoDn-1) are nodes subsampled from the top LoDs (i.e., nodes) of the child subgroup (e.g., LoDn). Therefore, to avoid redundant use of both LoDs in the layer group boundary, nodes of the parent subgroup outside the current subgroup bounding box are included.

[0503] According to the embodiments, the present disclosure stores the nodes of the current subgroup and the nodes of the parent subgroup in turn in an input buffer (61006) to be provided as inputs to the partial LoD generator as described above. In this case, to avoid duplicate use of the same node in the partial LoD generator, the nodes of the parent subgroup selected as inputs to the partial LoD generator for the current subgroup are nodes outside the bounding box of the current subgroup.

[0504] In this disclosure, it is assumed that the layer group structure applies equally to geometry and attributes. This means that in this disclosure, the geometry tree structure for geometry decoding and the attribute tree structure for attribute decoding are aligned. That is, the geometry coding layer structure for geometry decoding (i.e., layer group structure) and the attribute coding layer structure for attribute decoding (i.e., layer group structure) are identical. In other words, this means that the layer group / subgroup structure in the geometry tree structure is identical to the layer group / subgroup structure in the attribute tree structure.

[0505] For example, in FIG. 14, the geometry tree structure is composed of 8 geometry layers (0-7) and 3 layer groups, and then layer group 2 is divided into 2 subgroups and layer group 3 is divided into 4 subgroups, and then layer group 1, the 2 subgroups divided from layer group 2, and the 4 subgroups divided from layer group 3 each form a geometry slice. Then, the attribute tree structure is also composed of 8 attribute layers (0-7) and 3 layer groups, and then layer group 2 is divided into 2 subgroups and layer group 3 is divided into 4 subgroups, and then layer group 1, the 2 subgroups divided from layer group 2, and the 4 subgroups divided from layer group 3 each form an attribute slice.

[0506] In FIG. 14, an undivided layer group, for example, layer group 1, may be referred to as a single subgroup. Additionally, a geometry layer may be referred to as a geometry coding layer, and an attribute layer may be referred to as an attribute coding layer.

[0507] Also, even when performing scalable decoding, geometry decoding is performed first for the selected slice, so by referring to the signaling information, the layer group and subgroup to which the node being geometry decoded belongs can be determined. In this case, based on the geometry being decoded and / or the signaling information, the layer group and subgroup to which the node to be attribute decoded belongs can be determined.

[0508] In the present disclosure, an attribute decoder (61004) utilizes these features to assign an index to each node when nodes are stored in an input buffer (61006) for LoD generation. In the present disclosure, the index is referred to as a pointer. In the present disclosure, an index assigned to each node is a value that identifies the layer group and subgroup to which the node belongs.

[0509] That is, in the present disclosure, geometry decoding has already been performed, and since decoding for each subgroup and the nodes included in each subgroup has been performed in the geometry decoding, the indices of the nodes stored in the input buffer (61006) can be assigned by referring to the geometry decoding order, etc. This is an example embodiment, and any index assigned to each node is possible as long as it is a value that identifies whether the node stored in the input buffer (61006) is a node belonging to the current subgroup or a node belonging to the parent subgroup.

[0510] The present disclosure describes, in one embodiment, performing subgroup-based LoD generation and NN search based on the index of each node stored in the input buffer (61006).

[0511] In addition, when performing LoD generation and NN search based on the index value of each node stored in the input buffer (61006), the process of checking the location of each node and checking which layer group / subgroup it is based on the confirmed location can be omitted, thereby improving the attribute decoding speed.

[0512] Next, as described above, when input nodes for generating the LoD of the current subgroup are selected (or determined) in step 63015 (or input node selection unit), the partial LoD generation unit for the current subgroup generates the LoD of the current subgroup based on the selected nodes (step 63016).

[0513] That is, the input node selection unit reads the nodes of the current subgroup stored in the current subgroup storage area of ​​the input buffer (61006) and the nodes of the parent subgroup stored in the parent subgroup storage area based on the index assigned to each node, and inputs them to the partial LoD generation unit for generating the LoD of the current subgroup. At this time, in order to avoid using nodes outside the subgroup boundary, the neighbor search (i.e., NN search) is limited to nodes within the same subgroup or parent subgroup as one embodiment.

[0514] In the present disclosure, partial LoD generation is used when the start and end LoDs are changed to the LoD layer above the bottom LoD layer and the top LoD layer of the current subgroup, respectively. That is, the input (LoD generation input) of the partial LoD generation unit for the current subgroup consists of nodes belonging to the current subgroup and nodes belonging to the parent subgroup (current nodes + parent nodes). In this case, as an example, the nodes selected for the current subgroup among the nodes (parent nodes or parent points) belonging to the parent subgroup are node(s) outside the bounding box of the current subgroup. That is, the nodes belonging to the parent subgroup selected for LoD generation of the current subgroup are nodes that are not included within the range of the current subgroup. Here, not being included within the range of the current subgroup means being outside the boundary of the current subgroup. For example, assuming that a parent subgroup includes a first child subgroup and a second child subgroup, and the first child subgroup is the current subgroup, the second child subgroup corresponds to a subgroup that is not included within the scope of the current subgroup or is outside the boundary of the current subgroup.

[0515] In other words, the input to the partial LoD generation unit for the current subgroup consists of nodes belonging to the current subgroup and nodes belonging to the parent subgroup, wherein node(s) belonging to the parent subgroup that overlap with nodes belonging to the current subgroup are not selected.

[0516] And, if the input of the partial LoD generation unit for the current subgroup consists of nodes belonging to the current subgroup and nodes belonging to the parent subgroup, the output of the partial LoD generation unit may consist of the parent subgroup's bottom LoD and the current subgroup's LoDs (parent bottom LoD + current LoDs).

[0517] That is, through the pre-processing performed in step 63015 (or input node selection unit), the input (or subgroup LoD generation input) of the LoD generation unit for each subgroup includes all nodes (or current points) of the current subgroup and nodes (or parent points) of the parent subgroup that exist outside the current subgroup boundary. Then, the node(s) newly included in each LoD through LoD generation are included in indexes, and prior to performing a neighbor search, only points belonging within the subgroup boundary are selected to perform a neighbor search.

[0518] According to embodiments, a partial LoD generation unit for a current subgroup generates one or more LoDs of a current subgroup using the node(s) of the current subgroup and the node(s) of the parent subgroup that are outside the boundary of the current subgroup, which are provided by the input node selection unit based on the index of each node in the input buffer (61006). In one embodiment, the node(s) of the parent subgroup that are outside the boundary of the current subgroup include node(s) subsampled from the sibling subgroup of the current subgroup.

[0519] The present disclosure performs a neighbor search (referred to as neighbor search or NN search) for each subgroup based on the generated LoD when a LoD is created for each subgroup.

[0520] At this time, prior to performing a neighbor search, a neighbor search (i.e., NN search) is performed by selecting only the nodes (or points) belonging within the subgroup boundary as shown in the code below. Additionally, as an example, the point position resolution considers the geometry resolution of the current subgroup.

[0521] The code below includes code to find the starting position of a neighbor search (i.e., NN search) when LoDs are generated and sorted by subgroup.

[0522] That is, if the position of the node (or point) currently to be decoded is equal to or greater than the minimum value of the bounding box and smaller than the maximum value of the bounding box (pos >= bbox_min && pos < bbox_max), NN search is started from the current bounding box.

[0523] for (int i = startIndex; i < endIndex; i++) {

[0524] int packedVoxelIdx = indexes[i];

[0525] int pointIndex = packedVoxel[packedVoxelIdx].index;

[0526] auto pos = pointCloud[pointIndex];

[0527] if (pos >= bbox_min && pos < bbox_max)

[0528] indexes_subgroup.push_back(packedVoxelIdx);

[0529] }

[0530] for (int k = 0; k < indexes_subgroup.size(); k++) {

[0531] auto point = pointCloud[packedVoxel[indexes_subgroup[k]].index];

[0532] biasedPos_indexes.push_back(times((point >> shiftLayerGroup) << (shiftLayerGroup + treeLvlGap), aps.lodNeighBias));

[0533] }

[0534] In addition, nodes existing in the parent LoD during the subsampling process are included in retained. The present disclosure provides, as an example, that only the node(s) included in the boundary of the subgroup to which the parent LoD belongs are selectively used for NN search (or neighbor search), as shown in the code below. As another method, the present disclosure can determine whether to use all parent LoDs for NN search based on the bounding box of the parent subgroup.

[0535] for (int i = 0; i < retained.size(); i++) {

[0536] int packedVoxelIdx = retained[i];

[0537] int pointIdx = packedVoxel[packedVoxelIdx].index;

[0538] auto pos = pointCloud[pointIdx];

[0539] if (pos >= parent_bbox_min && pos < parent_bbox_max)

[0540] retained_subgroup.push_back(packedVoxelIdx);

[0541] }

[0542] According to the embodiments, geometry precision can be used for node(s) that are outside the bounding box of the current subgroup, as shown in the code below, by using the geometry precision of the parent subgroup. Taking FIG. 28 as an example, the underlined part in the code below corresponds to the case of nodes h and o, and the bold part corresponds to node d.

[0543] for (int k = 0; k < retained_subgroup.size(); k++) {

[0544] auto point = pointCloud[packedVoxel[retained_subgroup[k]].index];

[0545] if (prtLayerGroup != curLayerGroup) {

[0546] if (pos >= cur_bbox_min && pos.x() < cur_bbox_max)

[0547] biasedPos_retained.push_back(times((point >> shiftLayerGroup) << (shiftLayerGroup + treeLvlGap), aps.lodNeighBias));

[0548] else

[0549] biasedPos_retained.push_back(times((point >> shiftPrtLayerGroup) << (shiftPrtLayerGroup + treeLvlGap), aps.lodNeighBias));

[0550] }

[0551] else

[0552] biasedPos_retained.push_back(times((point >> shiftLayerGroup) << (shiftLayerGroup + treeLvlGap), aps.lodNeighBias));

[0553] }

[0554] Next, as described above, when LoD generation and NN search are performed in subgroup units at step 63016 (or LoD generation unit), at least one node of the current subgroup may inherit attributes of at least one node of the parent subgroup (step 63017). That is, in this disclosure, the process in which at least one node of the current subgroup inherits attributes of at least one node of the parent subgroup in step 63017 is referred to as the post-processing process. Furthermore, in this disclosure, step 63017 is performed in an attribute inheritance unit (not shown) as one embodiment. Also, the attribute inheritance unit may be referred to as a post-processor.

[0555] According to the embodiments, by the definition of a LoD that a lower LoD includes all nodes of a parent LoD, the node(s) belonging to the bottom LoD of the parent subgroup are all included in the top LoD of the child subgroup. Conversely, some of the nodes belonging to the top LoD of the child subgroup match the nodes of the bottom LoD of the parent subgroup. In this case, the attributes of the nodes belonging to the top LoD of the child subgroup can inherit the attributes of the corresponding nodes belonging to the bottom LoD of the parent subgroup.

[0556] That is, considering the subsampling of LoD generation, some nodes belonging to the top LoD of the current subgroup are matched with nodes belonging to the bottom LoD of the parent subgroup. At this time, to provide linkage between LoD layers at the layer group boundary, the attributes of the decoded nodes of the parent subgroup are inherited by the child nodes of the top LoD layer of the current subgroup. At this time, the matching is performed by considering the sampling direction in LoDn as shown in Fig. 29.

[0557] FIG. 29 is a diagram showing an example of an attribute inheritance process according to embodiments. For convenience of explanation, in this disclosure, 65011 corresponds to subgroup A of FIG. 27 and is referred to as the parent subgroup. 65012 corresponds to subgroup B of FIG. 27 and is referred to as the first child subgroup or the first subgroup, and 65013 corresponds to subgroup C of FIG. 27 and is referred to as the second child subgroup or the second subgroup. That is, the first subgroup (65012) and the second subgroup (65013) are sibling subgroups, and 65011 corresponds to the parent subgroup of the first and second subgroups (65012, 65013). In this disclosure, it is assumed that there is no dependency between the first subgroup (65012) and the second subgroup (65013). In other words, it is assumed that there is no dependency between the current subgroups.

[0558] For example, in Fig. 29, among the nodes d, h, and o belonging to the bottom layer (or bottom LoD) of the parent subgroup, the node(s) that match the nodes f, h, i, and o belonging to the top layer (or top LoD) of the current subgroup (e.g., subgroup C, 65013) are nodes h and o. In this case, based on the subsampling relationship, the decoded attributes of nodes h and o are matched as indicated by the arrows in 67001 and 67002. That is, based on the current subgroup (65013), the parent subgroup (65011) is already in a state where attributes have been decoded. Therefore, the decoded attributes of the nodes h and o of the parent subgroup (65011) are matched (or inherited) as attributes of the nodes h and o of the current subgroup (65013), and the decoding process of the attributes of the nodes h and o of the current subgroup (65013) is omitted.

[0559] To do this, as shown in the code below, for nodes within the parent subgroup's bottom layer (or bottom LoD) that are within the current subgroup's bounding box, the attributes of the corresponding nodes in the current subgroup can be found by referencing the parent subgroup's attributes for nodes whose positions match those of nodes within the current subgroup's top layer (or top LoD).

[0560] if (curLayerGroup > 0) {

[0561] int parentLayerGroup = curLayerGroup - 1;

[0562] int parentSubgroup = layerGroupParams.parentSubgroupId[curLayerGroup][curSubgroup];

[0563] int accLayer = 0;

[0564] for (int i = 0; i <= parentLayerGroup; i++)

[0565] accLayer += layerGroupParams.numLayersPerLayerGroup[i];

[0566] int treeLvlGap_parent = sps.root_node_size_log2.max() - accLayer;

[0567] auto bbox_min = layerGroupParams.subgrpBboxOrigin[curLayerGroup][curSubgroup];

[0568] auto bbox_max = bbox_min + layerGroupParams.subgrpBboxSize[curLayerGroup][curSubgroup];

[0569] std::vector <int>pointIndexInTheBbox;

[0570] auto pointCloud_subgroup_fifo_parent = layerGroupParams.pointCloud_tempNodes[parentLayerGroup][parentSubgroup];

[0571] int currentSubgroupIdxEnd = tempPointCloudIdx[layerGroupParams.numLayersPerLayerGroup[curLayerGroup]];

[0572] for (int i = 0; i < _lods.numPointsInLod[0]; i++) {

[0573] int pointIdx = _lods.indexes[i];

[0574] if (pointIdx < currentSubgroupIdxEnd)

[0575] pointIndexInTheBbox.push_back(pointIdx);

[0576] }

[0577] int numParentNodesInTheBbox = pointIndexInTheBbox.size();

[0578] int sampledNodeIdx = numParentNodesInTheBbox - 1;

[0579] for (int fifoIdx = 0; fifoIdx < pointCloud_subgroup_fifo_parent.getPointCount(); fifoIdx++) {

[0580] pcc::Vec3 <int>pos_parent = pointCloud_subgroup_fifo_parent[fifoIdx] << treeLvlGap_parent;

[0581] if (pos_parent >= bbox_min && pos_parent < bbox_max)

[0582] int pointIdx = pointIndexInTheBbox[sampledNodeIdx];

[0583] auto pos_lod0 = (pointCloud[pointIdx] >> treeLvlGap_parent) << treeLvlGap_parent;

[0584] if (mortonAddr(pos_lod0) == mortonAddr(pos_parent)) {

[0585] if (attr_desc.attr_num_dimensions_minus1 == 0)

[0586] pointCloud.setReflectance(pointIdx, pointCloud_subgroup_fifo_parent.getReflectance(fifoIdx));

[0587] else if (attr_desc.attr_num_dimensions_minus1 == 2)

[0588] pointCloud.setColor(pointIdx, pointCloud_subgroup_fifo_parent.getColor(fifoIdx));

[0589] if (!sampledNodeIdx)

[0590] break;

[0591] else

[0592] sampledNodeIdx--;

[0593] }

[0594] else {

[0595] fifoIdx--;

[0596] sampledNodeIdx--;

[0597] }

[0598] The attributes found through the above process can be referenced as neighbors in the subsequent attribute transform process.

[0599] For example, among the nodes fq of the current subgroup (65013), an attribute transformation process is performed for the remaining nodes excluding the nodes h and o that inherited attributes from the parent subgroup (65011).

[0600] According to the embodiments, after the process is performed in step 63017 (or attribute inheritance section) in which at least one node of the current subgroup inherits an attribute from at least one node of the parent subgroup (i.e., a node at the same location), quantization weights are derived on a subgroup basis (step 63018), and attribute transformation (e.g., prediction / lifting inverse transformation) can be performed on the remaining nodes of the current subgroup (step 63019). That is, attribute transformation, i.e., attribute decoding, is performed on a subgroup basis to restore the attributes of the remaining nodes of the current subgroup.

[0601] Then, the decoded attributes are stored in subgroup units (step 63020).

[0602] According to the embodiments, when the corresponding geometry slice and attribute slice are alternately transmitted in FIG. 26, if a geometry slice remains, the geometry decoder is restarted and the corresponding attribute decoder is operated. If the attribute slices are transmitted after the geometry slices, the entire attribute slice can be decoded after decoding the entire geometry slice.

[0603] After going through the aforementioned process, an output point cloud is generated, and geometry decoding and attribute decoding are completed.

[0604] Meanwhile, the present disclosure generates an LoD based on the restored geometry when layer group slicing is not enabled (step 63012), derives weights (step 63013), and performs an attribute transformation (e.g., prediction / lifting inverse transformation) (step 63015). Steps 63012 and 63013 may correspond to the LoD generation, NN search, and weight derivation processes of the attribute encoder (51004) of the transmitting device.

[0605] According to the embodiments, LoD generation, NN search, and attribute transformation may be performed in the same way in the encoder of the transmitting device and the decoder of the receiving device, or they may be performed in different ways.

[0606] For example, the encoder of the transmitting device and the decoder of the receiving device can perform LoD generation, NN search, and attribute transformation on a subgroup basis based on FIGS. 26 to 29 and each code. As another example, the encoder of the transmitting device can perform LoD generation, NN search, and attribute transformation in the same way as in FIG. 23, and the decoder of the receiving device can perform LoD generation, NN search, and attribute transformation on a subgroup basis based on FIGS. 26 to 29 and each code.

[0607] FIG. 30 illustrates an example of a bitstream structure of point cloud data for transmission / reception according to embodiments. According to embodiments, the bitstream output from any one of the point cloud video encoders of FIG. 1, FIG. 2, FIG. 3, FIG. 8, and FIG. 22 may be in the form of FIG. 30.

[0608] According to the embodiments, the bitstream of point cloud data provides tiles or slices so that the point cloud data can be divided and processed by region. Each region of the bitstream according to the embodiments may have different importance. Accordingly, when the point cloud data is divided into tiles, different filters (encoding methods) and different filter units can be applied to each tile. Additionally, when the point cloud data is divided into slices, different filters and different filter units can be applied to each slice.

[0609] A transmitting device according to the embodiments can transmit point cloud data according to the structure of a bitstream such as FIG. 30, thereby enabling the application of different encoding operations depending on importance and providing a method to use a high-quality encoding method in important areas. In addition, it can support efficient encoding and transmission according to the characteristics of point cloud data and provide attribute values ​​according to user requirements.

[0610] A receiving device according to the embodiments receives point cloud data according to the structure of a bitstream such as FIG. 30, thereby enabling different filtering (decoding methods) to be applied to different regions (regions divided into tiles or slices) instead of using a complex decoding (filtering) method for the entire point cloud data depending on the capacity of the receiving device. Accordingly, better image quality and appropriate system latency can be guaranteed in areas important to the user.

[0611] When a geometry bitstream, an attribute bitstream, and / or a signaling bitstream (or signaling information) according to the embodiments is composed of a single bitstream (or G-PCC bitstream) as in FIG. 30, the bitstream may include one or more sub-bitstreams. The bitstream according to the embodiments may include a Sequence Parameter Set (SPS) for sequence-level signaling, a Geometry Parameter Set (GPS) for signaling geometry information coding, one or more Attribute Parameter Sets (APS0, APS1) for signaling attribute information coding, a Tile Inventory (or TPS) for tile-level signaling, and one or more slices (slice 0 to slice n). That is, the bitstream of point cloud data according to the embodiments may include one or more tiles, and each tile may be a group of slices including one or more slices (slice 0 to slice n). A tile inventory (i.e., TPS) according to the embodiments may include information regarding each tile for one or more tiles (e.g., coordinate information of a tile bounding box and height / size information, etc.). Each slice may include one geometry bitstream (Geom0) and / or one or more attribute bitstreams (Attr0, Attr1). For example, slice 0 includes one geometry bitstream (Geom0 0 ) and one or more attribute bitstreams (Attr0 0 , Attr1 0 It may include ).

[0612] The geometry bitstream within each slice may consist of a geometry slice header (geom_slice_header) and geometry slice data (geom_slice_data). According to embodiments, the geometry bitstream within each slice may be referred to as a geometry data unit, the geometry slice header as a geometry data unit header, and the geometry slice data as geometry data unit data. The geometry slice header (or geometry data unit header) according to embodiments may include identification information of a parameter set included in a geometry parameter set (GPS) (geom_parameter_set_id), a tile identifier (geom_tile_id), a slice identifier (geom_slice_id), and information regarding data included in the geometry slice data (geom_slice_data) (geomBoxOrigin, geom_box_log2_scale, geom_max_node_size_log2, geom_num_points), etc. geomBoxOrigin is geometry box origin information representing the box origin of the geometry slice data, geom_box_log2_scale is information representing the log scale of the geometry slice data, geom_max_node_size_log2 is information representing the size of the root geometry octree node, and geom_num_points is information related to the number of points of the geometry slice data. The geometry slice data (or geometry data unit data) according to the embodiments may include geometry information (or geometry data) of the point cloud data within the slice.

[0613] Each attribute bitstream within each slice may consist of an attribute slice header (attr_slice_header) and attribute slice data (attr_slice_data). According to embodiments, the attribute bitstream within each slice may be referred to as an attribute data unit, the attribute slice header as an attribute data unit header, and the attribute slice data as attribute data unit data. The attribute slice header (or attribute data unit header) according to embodiments may include information regarding the corresponding attribute slice data (or the corresponding attribute data unit), and the attribute slice data may include attribute information of the point cloud data within the slice (or referred to as attribute data or attribute value). If there are multiple attribute bitstreams within a single slice, each may include different attribute information. For example, one attribute bitstream may contain attribute information corresponding to color, and another attribute stream may contain attribute information corresponding to reflectance.

[0614] According to the embodiments, parameters required for encoding and / or decoding point cloud data may be newly defined in parameter sets of point cloud data (e.g., SPS, GPS, APS, and TPS (or tile inventory), etc.) and / or in the header of the corresponding slice. For example, when performing encoding and / or decoding of geometry information, they may be added to the geometry parameter set (GPS), and when performing tile-based encoding and / or decoding, they may be added to the tile and / or slice header.

[0615] According to the embodiments, layer group-based slicing related information (e.g., LGSI) can be signaled to a sequence parameter set and / or an attribute parameter set.

[0616] According to the embodiments, layer group-based slicing information may be signaled in a tile parameter set and / or attribute data unit header.

[0617] According to the embodiments, if the syntax element defined below can be applied to multiple point cloud data streams as well as the current point cloud data stream, layer group-based slicing related information can be conveyed through a parameter set of a higher concept.

[0618] According to the embodiments, information related to layer group-based slicing may be defined in a corresponding location or a separate location depending on the application or system, allowing for different application scopes, application methods, etc. The term "field," used in the syntax of this specification described below, may have the same meaning as "parameter" or "syntactic element."

[0619] According to the embodiments, a parameter (which may be referred to in various ways, such as metadata, signaling information, etc.) containing layer group-based slicing information may be generated in a metadata processing unit (or metadata generator) or a signaling processing unit of a transmitting device and transmitted to a receiving device to be used in a decoding / reconstruction process. For example, a parameter generated and transmitted by a transmitting device may be obtained from a metadata parser of a receiving device.

[0620] FIG. 31 is a diagram showing an example of the syntax structure of a sequence parameter set (seq_parameter_set()) (SPS) according to the present specification. The SPS may include sequence information of a point cloud data bitstream, and in particular, shows an example including information related to layer group-based slicing.

[0621] The syntax of FIG. 31 is included in the bitstream of FIG. 30, is generated by a point cloud encoder according to the embodiments, and can be decoded by a point cloud decoder.

[0622] In FIG. 31, the simple_profile_compatibility_flag field may indicate whether the bitstream follows the main profile. For example, if the value of the simple_profile_compatibility_flag field is 1, it may indicate that the bitstream follows the simple profile. For example, if the value of the simple_profile_compatibility_flag field is 0, it may indicate that the bitstream follows a profile other than the simple profile.

[0623] If the value of the unique_point_positions_constraint_flag field is 1, all output points in each point cloud frame referenced by the current SPS can have unique positions. If the value of the unique_point_positions_constraint_flag field is 0, two or more output points in any point cloud frame referenced by the current SPS can have the same position. For example, even if all points are unique in each slice, points different from the slices within the frame may overlap. In that case, the value of the unique_point_positions_constraint_flag field is set to 0.

[0624] The level_idc field indicates the level that the bitstream follows.

[0625] The sps_seq_parameter_set_id field provides an identifier for the SPS for reference by other syntax elements.

[0626] The sps_num_attribute_sets field indicates the number of coded attributes in the bitstream.

[0627] The SPS according to the embodiments includes a loop that repeats as many times as the value of the sps_num_attribute_sets field. In one embodiment, i is initialized to 0 and increases by 1 each time the loop is executed, and the loop repeats until the value of i becomes the value of the sps_num_attribute_sets field. This loop may include the attribute_dimension_minus1[i] field and the attribute_instance_id[i] field. attribute_dimension_minus1[i] plus 1 represents the number of components of the i-th attribute.

[0628] The attribute_instance_id[i] field represents the instance identifier of the i-th attribute.

[0629] The known_attribute_label_flag[i] field indicates whether the known_attribute_label[i] field or the attribute_label_four_bytes[i] field is signaled for the i-th attribute. For example, if the value of the known_attribute_label_flag[i] field is 0, it indicates that the known_attribute_label[i] field is signaled for the i-th attribute, and if the value of the known_attribute_label_flag[i] field is 1, it indicates that the attribute_label_four_bytes[i] field is signaled for the i-th attribute.

[0630] The known_attribute_label[i] field indicates the type of the i-th attribute. For example, if the value of the known_attribute_label[i] field is 0, it indicates that the i-th attribute is color; if the value of the known_attribute_label[i] field is 1, it indicates that the i-th attribute is reflectance; and if the value of the known_attribute_label[i] field is 2, it indicates that the i-th attribute is frame index. Additionally, if the value of the known_attribute_label[i] field is 4, it indicates that the i-th attribute is transparency; and if the value of the known_attribute_label[i] field is 5, it indicates that the i-th attribute is normals.

[0631] The axis_coding_order field indicates the correspondence between the three position components in the reconstructed point cloud RecPic [pointidx] [axis] with X, Y, Z output axis labels and axis=0..2.

[0632] If the value of the bypass_stream_enabled_flag field is 1, it indicates that the bypass coding mode is used to read the bitstream. As another example, if the value of the bypass_stream_enabled_flag field is 0, it indicates that the bypass coding mode is not used to read the bitstream.

[0633] In FIG. 31, the sps_extension_flag field indicates whether the sps_extension_data syntax structure exists in the corresponding SPS syntax structure. For example, if the value of the sps_extension_present_flag field is 1, it indicates that the sps_extension_data syntax structure exists in this SPS syntax structure, and if it is 0, it indicates that it does not exist.

[0634] The following are examples of layer group-based slicing information included in sps_extension_data when the value of the sps_extension_present_flag field is 1.

[0635] If layer_group_enabled_flag is 1, it indicates that the geometry (or attribute) bitstream of a slice is contained in multiple slices that match the coding layer group or its subgroups. If layer_group_enabled_flag is 0, it indicates that the geometry (or attribute) bitstream is contained in a single slice.

[0636] If layer_group_enabled_flag is 1, num_layer_groups_minus1 plus 1 represents the number of layer groups representing a group of consecutive tree layers that are part of a geometry coding tree structure. num_layer_groups_minus1 is in the range of 0 to the number of coding tree layers.

[0637] A loop that iterates as many times as num_layer_groups_minus1 may include the fields layer_group_id[i], num_layers_minus1[i], and subgroup_enabled_flag[i].

[0638] layer_group_id[i] represents the identifier of the i-th layer group. The range of layer_group_id is from 0 to num_layer_groups_minus1.

[0639] num_layers_minus1[i] plus 1 represents the number of coding layers included in the i-th layer group. The total number of layer groups can be derived by adding all (num_layers_minus1[i] + 1) from i 0 to num_layer_groups_minus1.

[0640] If subgroup_enabled_flag[i] is 1, it indicates that the i-th layer group is divided into two or more subgroups. In this case, the point sets in the subgroups are identical to the point sets in the layer group. When subgroup_enabled_flag[i] of the i-th layer group is 1, if j is greater than or equal to i, the subgroup_enabled_flag of the j-th layer group will be 1. If subgroup_enabled_flag is 0, it indicates that the current layer group is not divided into multiple subgroups and is contained in a single slice.

[0641] If the above layer_group_enabled_flag is 1, the SPS may additionally include subgroup_bbox_origin_bits_minus1 and subgroup_bbox_size_bits_minus1.

[0642] subgroup_bbox_origin_bits_minus1 plus 1 indicates the bit length of the syntax element (i.e., field) subgroup_bbox_origin.

[0643] subgroup_bbox_size_bits_minus1 plus 1 indicates the bit length of the syntax element subgroup_bbox_size.

[0644] According to the embodiments, if layer_group_enabled_flag is 1, the SPS may further include root_subgroup_bbox_origin and root_subgroup_bbox_size.

[0645] root_subgroup_bbox_origin can specify the location of the origin (origin information) of the subgroup bounding box of the root subgroup.

[0646] root_subgroup_bbox_size can specify the size of the subgroup bounding box of the root subgroup.

[0647] The SPS according to the embodiments may further include the sps_extension_data_flag field if the value of the sps_extension_flag field is 1. The sps_extension_data_flag field may have any value.

[0648] FIG. 32 is a diagram showing an example of the syntax structure of a dependent attribute data unit header (dependent_attribute_data_unit_header()) according to embodiments. FIG. 32 shows an example in which layer group-based slicing related information is included in the dependent attribute data unit header.

[0649] The syntax of FIG. 32 is included in the bitstream of FIG. 30, is generated by a point cloud encoder according to the embodiments, and can be decoded by a point cloud decoder.

[0650] According to the embodiments, a dependent attribute data unit header may be included in an attribute data unit. The attribute data unit may be used interchangeably with a dependent attribute data unit or an attribute slice.

[0651] According to the embodiments, the dependent attribute data unit header may be included in at least one of SPS, APS, GPS, and TPS.

[0652] In FIG. 32, dadu_attribute_parameter_set_id represents the active APS indicated by aps_attr_parameter_set_id. The value of dgdu_attribute_parameter_set_id is the same as the value of adu_attribute_parameter_set_id of the corresponding slice (corresponding slice).

[0653] dadu_sps_attr_idx identifies the coded attribute by its index into the active SPS attribute list.

[0654] dadu_slice_id specifies the attribute slice to which the current dependent attribute data unit belongs.

[0655] dadu_layer_group_id can represent an indicator of a slice's layer group. The range of dadu_layer_group_id can be from 0 to num_layer_groups_minus1. If it does not exist, it is presumed to be 0.

[0656] dadu_subgroup_id indicates the subgroup of the layer group referenced by dadu_layer_group_id. The range of dadu_subgroup_id can be from 0 to num_subgroups_minus1[dadu_layer_group_id]. dadu_subgroup_id can indicate the order of slices with the same dadu_layer_group_id. If it does not exist, it is presumed to be 0.

[0657] As described above, LoD-based attribute coding / decoding can be performed by generating LoDs based on decoded geometry points and then predicting based on neighbor relationships between nodes belonging to each LoD. In this case, if LoD generation is performed after geometry decoding is completed, even if the geometry / attribute bitstream consists of slices, attribute slice decoding begins only after all geometry slices of the region of interest have been decoded, which becomes a delay factor in rapidly decoding the slices of interest.

[0658] In the apparatus and method according to the embodiments, geometry coding / decoding - LoD generation - attribute coding / decoding are performed in slice units / subgroup units through subgroup unit LoD generation, thereby enabling more active response to low-latency environments. In the present disclosure, attribute coding is performed in the encoder of the transmitting device, and attribute decoding or attribute slice decoding is performed in the decoder of the receiving device. At this time, the LoD generation process is performed in the decoder as well as in the encoder.

[0659] According to the embodiments, the FGS geometry decoding process is exemplified by the geometry data being decoded in units of geometry data units (i.e., GDU or DGDU) identified by layer_group_id and subgroup_id, and in this process, startDepth and endDepth, representing the start depth and end depth of the occupancy tree, are set corresponding to the subgroup. Accordingly, the decoded geometry results are stored in SubgroupNodePos and SubgroupNodeCnt as node location information and node count information at the subgroup level.

[0660] Then, based on the geometry decoding results formed at the subgroup level as described above, Level of Detail (LoD) generation is performed. At this time, LodMinLevel (or referred to as the minimum LoD level) and LodMaxLevel (or referred to as the maximum LoD level), which are the minimum and maximum detail levels used for LoD generation, are calculated based on a partial occupancy tree limited to the startDepth and endDepth, rather than the entire occupancy tree. Accordingly, the LoD subsampling process is performed independently within the scope of the subgroup corresponding to the FGS, and each subgroup has its own LoD structure.

[0661] Subsequently, during the attribute decoding process, attribute data units (i.e., ADU or DADU) with specific layer_group_id and subgroup_id are decoded only after geometry data units (i.e., GDU or DGDU) with the same identifier have been decoded. In this process, AttrPos, which is point coordinate information for attribute decoding, is defined to directly reference SubgroupNodePos, which is the geometry decoding result of the corresponding subgroup. Thus, the geometry decoding result, the LoD generation result, and the attribute decoding process are directly linked within the same subgroup range.

[0662] In this disclosure, a layer group refers to a group of consecutive tree levels of an occupancy tree. A subgroup is a spatial subset defined within a layer group, wherein the bounding box of the subgroup does not overlap with the bounding box of other subgroups belonging to the same layer group. Furthermore, an occupancy tree refers to an octal tree of occupancy tree nodes representing the geometry of a slice. In this disclosure, the terms occupancy tree and octree are used interchangeably. Additionally, among the layer groups, a root layer group refers to a layer group containing the root node of the occupancy tree. Furthermore, a parent subgroup refers to a subgroup located in a layer group above the current subgroup, and a child subgroup is a subgroup belonging to a layer group adjacent to the maximum depth of the current subgroup, wherein the bounding box of the child subgroup is a subset of the bounding box of the current subgroup.

[0663] In the present disclosure, a fine-granularity slice (FGS) refers to a subset of slices that conveys geometry or attribute data corresponding to a subgroup within a layer group. That is, it is a data unit that includes only geometry information or attribute information belonging to a specific subgroup within a slice.

[0664] In the present disclosure, a slice may include a plurality of FGSs, and each FGS is mapped one-to-one to a single subgroup within a layer-group. A slice composed of FGSs is identified by a common slice identifier (slice_id). Additionally, FGSs are identified by a pair consisting of a layer-group index (layer_group_id) and a subgroup index (subgroup_id).

[0665] In the present disclosure, FGS includes FGS geometry and (if present) FGS attributes, which are identified by pairs of the same layer-group index (layer_group_id) and subgroup index (subgroup_id).

[0666] All FGS geometry includes a GDU or DGDU that codes the partial slice geometry, and all FGS attributes include an ADU or DADU that codes the partial slice attributes. In this case, the first FGS geometry within the slice is a GDU, and the FGS geometry may be followed by a DGDU that depends on the previously decoded GDU and DGDU. Additionally, the first FGS attribute within the slice is an ADU, and the FGS attribute may be followed by a DADU that depends on the previously decoded ADU and DADU.

[0667] The following is a detailed description of the process in which geometry coding / decoding - LoD creation - attribute coding / decoding are performed at the slice unit / subgroup unit through LoD creation at the subgroup unit.

[0668] FGS (Fine Granularity Slice) Default Attribute Generation Method

[0669] FIG. 33 shows the fgs attribute raw (fgs_attribute_raw) syntax according to the embodiments.

[0670] FGS default attribute generation can be applied when the attribute coding type (attr_coding_type) is 3, that is, when raw attribute decoding is performed. This is one example and can also be applied when raw attribute coding is performed.

[0671] In the present disclosure, attr_coding_type is a parameter (or referred to as a field or syntax element) included in an attribute parameter set (APS) and specifies an attribute coding method. For example, if the value of attr_coding_type is 0, it indicates that attribute coding is performed based on RAHT, and if it is 1 or 2, it indicates that attribute coding is performed based on LoD. In this case, if the value of attr_coding_type is 1, it is a method using predictive transformation, and if it is 2, it is a method using lifting transformation. And, if the value of attr_coding_type is 3, it indicates that attribute coding is performed in the form of raw attribute data without attribute transformation or prediction.

[0672] As an example, the fgs attribute raw (fgs_attribute_raw) syntax of FIG. 33 is included in an attribute data unit. Referring to FIG. 33, attribute information is processed sequentially for each point in correspondence with the number of attribute nodes included in a subgroup identified by the layer group index layerGroupIdx and the subgroup index subgroupIdx (SubgroupNodeAttrCnt[layerGroupIdx][subgroupIdx]). Then, for each point, attribute values ​​are sequentially included for each component (c) corresponding to the number of dimensions (attrDim) of the attribute. The number of attribute nodes can be referred to as the number of coded points or the number of decoded points.

[0673] In Fig. 33, raw_attr_width_present is a parameter included in APS that indicates whether raw attribute values ​​use the same fixed-length encoding for all syntax elements or use a length per syntax element.

[0674] fgs_raw_attr_component_length specifies the length of each syntax element fgs_raw_attr_value in bytes, if present.

[0675] fgs_raw_attr_value[ptIdx][c] specifies the attribute value for the c-th component of the ptIdx-th point according to canonical decoding order. In this case, the bit length of each syntax element is specified by the expression RawAttrValueBits. That is, the decoder uses the value stored in fgs_raw_attr_value[ptIdx][c] as the attribute value directly, without conversion or prediction.

[0676] The attribute values ​​according to the embodiments are set to be identical to the corresponding raw_attr_value syntax element as follows.

[0677] for (ptIdx = 0; ptIdx < SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx]; ptIdx++)

[0678] for (c = 0; c < AttrDim; c++)

[0679] PointAttr[ptIdx][c] = raw_attr_value[ptIdx][c]

[0680] That is, it iterates as many times as the number of attribute nodes included in the subgroup, and for each point (ptIdx), for each component (c) corresponding to the attribute dimension (AttrDim), the raw attribute value contained in raw_attr_value[ptIdx][c] is stored in the attribute storage array PointAttr[ptIdx][c].

[0681] In this way, since the attribute values ​​of each point defined at the subgroup level are signaled independently by component, attribute data can be directly transmitted to the receiving device and decoder without performing transformation-based attribute coding.

[0682] The following is an explanation of the LoD minimum level (LoDMinLevel) and LoD maximum level (LoDMaxLevel).

[0683] LoD minimum level (LoDMinLevel) and LoD maximum level (LoDMaxLevel)

[0684] In the process of generating Levels of Detail (LoDs) in the attribute decoding process, the subsampling process is performed from the finest detail level to the coarest detail level. In Fine Granularity Slices (FGSs), the subsampling process is performed on partial occupancy trees, and the finest detail level and the coarest detail level are defined as LodMinLevel and LodMaxLevel, respectively.

[0685] However, conventionally, LodMinLevel and LodMaxLevel were calculated in the opposite way as shown below.

[0686] LodMinLevel = occtreeMaxDepthMinus1 - (startDepth-1)

[0687] LodMaxLevel = LodMinLevel+num_layers_minus1[layer_group_id]+1

[0688] To avoid confusion, the embodiments define LodMinLevel and LodMaxLevel as follows, based on startDepth and endDepth, which are used to describe the range of the partial occupancy tree during the geometry decoding process.

[0689] According to the embodiments, when fgs_layer_group_enabled is 1, the minimum level of the LoD is specified in the variable LodMinLevel. The maximum level of the LoD can be set to overlap with the minimum level of the LoD of the parent FGS. Here, fgs_layer_group_enabled is a parameter (or field or syntax element) included in the SPS that indicates whether a slice contains multiple FGSs (fine granularity slices) for partial slice geometry or partial slice attributes. If fgs_layer_group_enabled is 0, it indicates that a slice is not composed of FGSs, and if it is 1, it indicates that a slice is composed of FGSs.

[0690] According to the embodiments, the finest detail level can be identified by the detail level index LoDMinLevel. LodMinLevel may be the log2 quantized node size of the finest level of the partial occupancy tree of the FGS geometry.

[0691] According to the embodiments, the coarest detail level can be identified by the detail level index LodMaxLevel. LodMaxLevel may be the log2 quantized node size of the coarseest level of the partial occupancy tree of the FGS geometry.

[0692] Detail levels are iteratively subsampled starting from the finest detail level until a single point remains or a subsampled detail level identified by LoDMaxLevel is generated. The variable Lvl identifies the detail level to be subsampled.

[0693] According to the embodiments, as follows, the minimum level of LoDs for an FGS attribute identified as LodMinLevel can be calculated as the difference between the maximum depth of the full occupancy tree minus 1 (occtreeMaxDepthMinus1) and the end depth of the partial occupancy tree of the FGS geometry corresponding to the FGS attribute (i.e., LodMinLevel = occtreeMaxDepthMinus1 - endDepth). According to the embodiments, as shown below, the maximum level of LoDs for an FGS attribute identified by LodMaxLevel can be calculated as the difference between the maximum depth of the full occupancy tree minus 1 (occtreeMaxDepthMinus1) and the starting depth (startDepth) of the partial occupancy tree of the FGS geometry corresponding to the FGS attribute (i.e., LodMaxLevel = occtreeMaxDepthMinus1 - startDepth).

[0694] LodMinLevel = occtreeMaxDepthMinus1 - endDepth

[0695] LodMaxLevel = occtreeMaxDepthMinus1 - startDepth

[0696] if(layer_group_id>0)

[0697] LodMaxLevel++

[0698]

[0699] Lvl = LodMinLevel

[0700] for (; Lvl < LodMaxLevel; Lvl++) {

[0701] if (LodPtCnt[Lvl] == 1)

[0702] break

[0703] … / * subsample LodPtIdx[Lvl] * /

[0704] }

[0705] LodCnt = Lvl + 1

[0706] And, the coarsest detail level can be identified by the detail level index LodCnt-1. All points belonging to the coarsest detail level are assigned to the coarsest level's refinement list.

[0707] According to embodiments, LoDs may be specified by the following state variables: namely, the index lvl identifies the detail level, and the variable LodCnt specifies the maximum number of detail levels generated in the FGS geometry.

[0708] The following is an explanation of the FGS decoding process.

[0709] FGS decoding process

[0710] When fgs_layer_group_enabled is 1, the FGS within the coded point cloud frame is decoded as follows:

[0711] 1. Point positions are decoded from one geometry data unit (GDU) and zero or more dependent geometry data units (DGDU).

[0712] 2. The default attribute value is set for each attribute.

[0713] 3. Point attributes are decoded in one attribute data unit (ADU) and zero or more dependent attribute data units (DADU). The ADU and DADU are decoded after the decoding of the GDU and DGDU, which are represented by the same layer_group_id and subgroup_id pairs.

[0714] 4. The decoded point position is offset and the output point count is increased.

[0715] According to embodiments, FGS decoding may be specified by the following state variables:

[0716] The variable startDepth represents the starting depth of the tree level within the data unit.

[0717] The variable endDepth represents the end depth of the tree level within the data unit.

[0718] The following is an explanation of the FGS geometry decoding process during the FGS decoding process.

[0719] In the present disclosure, a geometry data unit (GDU) is decoded before all dependent geometry data units (DGDU) within a slice. The DGDU of a child subgroup is decoded after the DGDU of a parent subgroup.

[0720] As described above, a root layer group includes one subgroup, and the FGS geometry for the said subgroup may include a geometry data unit (GDU). Additionally, a layer group excluding the root layer group may include multiple subgroups, and the FGS geometry for each subgroup may include a dependent geometry data unit (DGDU).

[0721] According to the embodiments, when decoding the GDU, startDepth and endDepth can be set to 0 and (num_layers_minus1[0] + 1), respectively.

[0722] According to the embodiments, when decoding DGDU, startDepth may be set to the cumulative value of (num_layers_minus1[k] + 1) where k is in the range from 0 to layer_group_id - 1. endDepth may be set to the cumulative value of (num_layers_minus1[k] + 1) where k is in the range from 0 to layer_group_id.

[0723] According to embodiments, SubgroupNodePos[layerGroupIdx][subgroupIdx][nodeIdx][k] is an alias for the position of a node at the end depth of a subgroup identified by a layer group index and a subgroup index, where layerGroupIdx is equal to layer_group_id and subgroupIdx is equal to subgroup_id.

[0724] According to the embodiments, the k-th position (SubgroupNodePos[layerGroupIdx][subgroupIdx][nodeIdx][k]) of a node in the end depth of an occupancy tree included in a subgroup identified by a layer group index and a subgroup index can be assigned to be identical to the k-th position component of the node coded as nodeIdx in the tree level traversal order of the end depth of the occupancy tree as follows.

[0725] SubgroupNodePos[layerGroupIdx][subgroupIdx][nodeIdx][k] := OccNodeLoc[endDepth][nodeIdx][k]

[0726] According to the embodiments, SubgroupNodeCnt[layerGroupIdx][subgroupIdx] is an alias for the number of nodes at the end depth of a subgroup identified by a layer group index and a subgroup index.

[0727] According to the embodiments, the number of nodes at the end depth included in the occupancy tree of a subgroup identified by the layer group index and the subgroup index (SubgroupNodeCnt[layerGroupIdx][subgroupIdx]) can be assigned to be equal to the number of nodes at the end depth of the occupancy tree as follows.

[0728] SubgroupNodeCnt[layerGroupIdx] [subgroupIdx] := OccNodeCnt[endDepth]

[0729] According to embodiments, SubgroupBBoxMin[layerGroupIdx][subgroupIdx] and SubgroupBBoxMax[layerGroupIdx][subgroupIdx] are aliases for the minimum and maximum point positions of the bounding box of a subgroup identified by the layer group index and the subgroup index.

[0730] According to the embodiments, the minimum point position of the bounding box of a subgroup (SubgroupBBoxMin[layerGroupIdx][subgroupIdx][k]) can be assigned to the origin value of the subgroup bounding box (subgroup_bbox_origin[k]) as shown below, and the maximum point position of the bounding box of a subgroup (SubgroupBBoxMax[layerGroupIdx][subgroupIdx][k]) can be assigned to the value obtained by adding the size value of the subgroup bounding box (subgroup_bbox_size[k]) to the origin value of the subgroup bounding box (subgroup_bbox_origin[k]) as shown below.

[0731] SubgroupBBoxMin[layerGroupIdx][subgroupIdx][k] := subgroup_bbox_origin[k]

[0732] SubgroupBBoxMax[layerGroupIdx][subgroupIdx][k] := subgroup_bbox_origin[k] + subgroup_bbox_size[k]

[0733] According to embodiments, the sparse array SubgroupOccNeighPatEq0[CurrLayerGroupIdx][CurrSubgroupIdx][ns][nt][nv] identifies whether the identified node of the parent subgroup does not have a node in the occupied neighborhood pattern.

[0734] According to the embodiments, the sparse array SubgroupOccNodeChildCnt[CurrLayerGroupIdx][CurrSubgroupIdx][k][ns][nt][nv] identifies the number of child nodes of a parent subgroup.

[0735] According to embodiments, SubgroupDirectNodePointCnt[layerGroupIdx][subgroupIdx] is an alias for the number of points of direct nodes at the end depth of a subgroup identified by a layer group index and a subgroup index.

[0736] According to embodiments, when the layer group ID (layer_group_id) is equal to num_layer_groups_minus1, the position of the node within the subgroup (SubgroupNodePos[layerGroupIdx][subgroupIdx][i][k]) is copied to the output point cloud as follows ((PointPos[PointCnt][k])).

[0737] if (layer_group_id == num_layer_groups_minus1) {

[0738] for (i = 0; i < SubgroupNodeCnt[layerGroupIdx][subgroupIdx]; i++, PointCnt++)

[0739] for (k = 0; k < 3; k++)

[0740] PointPos[PointCnt][k] = SubgroupNodePos[layerGroupIdx][subgroupIdx][i][k]

[0741] }

[0742] According to the embodiments, node positions are decoded and reconstructed.

[0743] The following is an explanation of the FGS attribute decoding process during the FGS decoding process.

[0744] In the present disclosure, an attribute data unit (ADU) is decoded before all dependent attribute data units (DADU) within a slice. The DADU of a child subgroup is decoded after the DADU of a parent subgroup.

[0745] As described above, a root layer group includes one subgroup, and an FGS attribute for said subgroup may include an attribute data unit (ADU). Additionally, a layer group excluding the root layer group may include multiple subgroups, and an FGS attribute for each subgroup may include a dependent attribute data unit (DADU).

[0746] According to embodiments, ADU and DADU are decoded, and the reconstructed attribute values ​​are stored in the corresponding output point cloud attributes or in the leaf nodes of the occupancy tree within the subgroup.

[0747] When decoding the ADU in the present disclosure, startDepth and endDepth are set to 0 and (num_layers_minus1

[0000] + 1), respectively.

[0748] And, when decoding DADU, startDepth is set to the cumulative value of (num_layers_minus1[ k ] + 1) where k is in the range from 0 to layer_group_id - 1. endDepth is set to the cumulative value of (num_layers_minus1[ k ] + 1) where k is in the range from 0 to layer_group_id.

[0749] According to embodiments, DirectNodePointCnt is set to the number of coded points in the direct nodes of each subgroup as follows.

[0750] DirectNodePointCnt := SubgroupDirectNodePointCnt[layerGroupIdx][subgroupIdx]

[0751] According to the embodiments, SlicePointAttr[ptIdx][c] is an alias for an array of output point cloud attributes of points within a slice.

[0752] According to the embodiments, the c-th attribute value of the ptIdx-th point in the slice (SlicePointAttr[ptIdx][c]) may be assigned as the c-th attribute value of the attribute identified as RecCloudPointCnt + AttrIdx of the ptIdx-th point in the attribute array of the entire restored point cloud frame as follows.

[0753] SlicePointAttr[ptIdx][c] := RecCloudAttr[RecCloudPointCnt + ptIdx][AttrIdx][c]

[0754] According to embodiments, SubgroupNodeAttr[layerGroupIdx][subgroupIdx][ptIdx][c] is an alias for an array of attributes of a subgroup identified by a layer group index and a subgroup index, where layerGroupIdx is equal to layer_group_id and subgroupIdx is equal to subgroup_id.

[0755] According to embodiments, SubgroupNodeAttr[layerGroupIdx][subgroupIdx][ptIdx][c] may be assigned the value of PointAttr[ptIdx][c], which is an alias of the point attribute array currently decoded within the FGS, as follows.

[0756] SubgroupNodeAttr[layerGroupIdx][subgroupIdx][ptIdx][c] := pointAttr[ptIdx][c]

[0757] According to embodiments, SubgroupNodeAttrCnt[layerGroupIdx][subgroupIdx] is an alias for the number of direct coded nodes and occupancy tree generated nodes at the end depth of the subgroup identified by the layer group index and the subgroup index.

[0758] According to the embodiments, SubgroupNodeAttrCnt[layerGroupIdx][subgroupIdx] can be set (or assigned) to the value obtained by adding SubgroupNodeCnt[layerGroupIdx][subgroupIdx] and SubgroupDirectNodePointCnt[layerGroupIdx][subgroupIdx] as follows.

[0759] SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx] := SubgroupNodeCnt[layerGroupIdx][subgroupIdx] + SubgroupDirectNodePointCnt[layerGroupIdx][subgroupIdx]

[0760] According to the embodiments, when FGS attribute decoding is finished, the attributes within the subgroup are copied to the output point cloud as follows.

[0761] Referring to the code below, whenever decoding of each layer group of FGS is finished, 1) if it is the root layer group (layer_group_id is 0), the output attribute point count is initialized to 0, 2) if it is an intermediate layer group (layer_group_id is less than num_layer_groups_minus1), only the attributes of the direct node are copied to SlicePointAttr, and 3) if it is the last layer group (layer_group_id is equal to num_layer_groups_minus1), the attributes of all subgroup nodes including the direct node are copied to SlicePointAttr.

[0762] if(layer_group_id == 0)

[0763] AttrPointCnt = 0

[0764] if (layer_group_id < num_layer_groups_minus1)

[0765] numNodes = SubgroupDirectNodePointCnt[layerGroupIdx][subgroupIdx]

[0766] else

[0767] numNodes = SubgroupNodeCnt[layerGroupIdx][subgroupIdx]

[0768] for (i = 0; i < numNodes; i++, AttrPointCnt++)

[0769] for (c = 0; c < 3; c++)

[0770] SlicePointAttr[AttrPointCnt][c] = SubgroupNodeAttr[layerGroupIdx][subgroupIdx][i][c]

[0771] According to the embodiments, point attributes can be decoded and reconstructed.

[0772] According to the embodiments, AttrPos[ptIdx][k] specifies the coordinates of each point for attribute coding. And, AttrPos is identical to SubgroupNodePos, which is the FGS geometry in the coordinate system of the slice as follows.

[0773] AttrPos[ptIdx][k] := SubgroupNodePos[ptIdx][k]

[0774] In this case, if there is an IDCM node, AttrPos includes the IDCM node as well as SubgroupNodePos. To this end, the embodiments may include a method of first selecting the IDCM node belonging to the current subgroup and including it in AttrPos, and then adding SubgroupNodePos. In this case, regarding the process of matching SubgroupNodeAttr to SlicePointAttr, a process of matching the position of the IDCM node with the attribute of the corresponding node may be added through a separate process of matching the index corresponding to the IDCM node among each node position in PointPos with the index of the corresponding node in AttrPos.

[0775] The following is an explanation of partial density decoding during the FGS decoding process.

[0776] According to the embodiments, the decoder can generate a slice point cloud of lower density.

[0777] In the present disclosure, lower density FGS point clouds may be specified by the following variables.

[0778] The variable SkippedLayerGroup specifies the application-specific number of layer groups to be skipped for partial decoding in the direction of the density. The value of SkippedLayerGroup ranges from 0 to num_layer_groups_minus1.

[0779] The variable MinNodeSizeLog2 specifies the minimum occupancy tree node size specified by SkippedLayerGroup.

[0780] The array SubgroupNodePos[layerGroupIdx][subgroupIdx][ptIdx][k] specifies the subgroup output nodes for layer group index layerGroupIdx and subgroup index subgroupIdx.

[0781] The array SubgroupNodeCnt[layerGroupIdx][subgroupIdx] specifies the number of nodes in the subgroup output nodes for layer group index layerGroupIdx and subgroup index subgroupIdx.

[0782] The following is an explanation of FGS selection during the partial density decoding process.

[0783] According to the embodiments, if SkippedLayerGroup is greater than 0, a layer group having an index in the range from 0 to OutLayerGroup may be selected to be decoded. In the present disclosure, the maximum layer group index value OutLayerGroup for partial decoding may be specified as the value obtained by subtracting SkippedLayerGroup from the total number of layer groups as follows.

[0784] OutLayerGroup := num_layer_groups_minus1 - SkippedLayerGroup

[0785] Referring to the code below, if it is the root layer group (layer_group_id is 0), GDU or ADU can be decoded; if layer_group_id is less than or equal to the maximum layer group index value OutLayerGroup for partial decoding, DGDU or DADU can be decoded; and if layer_group_id is greater than the maximum layer group index value OutLayerGroup for partial decoding, DGDU or DADU can be skipped.

[0786] if (layer_group_id == 0)

[0787] decode GDU or ADU

[0788] else if (layer_group_id ≤ OutLayerGroup)

[0789] decode DGDU or DADU

[0790] else

[0791] skip DGDU or DADU

[0792] Consequently, the geometry occupancy tree depth of partial decoding PartialDepth can be inferred as the sum of the number of layers in each layer group with indices ranging from 0 to OutLayerGroup as follows.

[0793] PartialDepth = 0

[0794] for (i=0; I ≤ OutLayerGroup; i++)

[0795] PartialDepth += num_layers_minus1[i] + 1

[0796] The following is an explanation of geometry position compensation during the partial density decoding process.

[0797] According to the embodiments, the maximum depth of the geometry occupancy tree when decoding all layer groups, TotalDepth, can be inferred as the sum of the number of layers of each layer group with an index ranging from 0 to num_layer_groups_minus1, as follows.

[0798] TotalDepth = 0

[0799] for (i=0; i< num_layer_groups_minus1; i++)

[0800] TotalDepth += num_layers_minus1[i] + 1

[0801] And, MinNodeSizeLog2 can be inferred as the difference between occtreeMaxDepthMinus1 and PartialDepth as follows.

[0802] MinNodeSizeLog2 = occtreeMaxDepthMinus1 + 1 - PartialDepth

[0803] If MinNodeSizeLog2 is greater than 1, the pointer is located in the center of the corresponding block as follows.

[0804] for (ptIdx = 0; ptIdx < SubgroupNodeCnt [layerGroupIdx][subgroupIdx]; ptIdx++)

[0805] for (k = 0; k < 3; k++)

[0806] SubgroupNode[layerGroupIdx][subgroupIdx][ptIdx][k] |= (MinNodeSizeLog2 > 1) << (MinNodeSizeLog2 - 1)

[0807] The following is an explanation of output generation during the partial density decoding process.

[0808] According to the embodiments, when the layer group ID (layer_group_id) is the same as OutLayerGroup, the location of the node within the subgroup SubgroupNodePos[layerGroupIdx][subgroupIdx][i][k] can be copied to the output point cloud (output point cloud, PointPos[PointCnt][k]) as follows.

[0809] if (layer_group_id == OutLayerGroup) {

[0810] for (i = 0; i < SubgroupNodeCnt[layerGroupIdx][subgroupIdx]; i++, PointCnt++)

[0811] for (k = 0; k < 3; k++)

[0812] PointPos[PointCnt][k] = SubgroupNodePos[layerGroupIdx][subgroupIdx][i][k]

[0813] }

[0814] According to the embodiments, when the layer group ID (layer_group_id) is the same as OutLayerGroup, attributes within the subgroup can be copied to the output point cloud as follows.

[0815] if(layer_group_id == 0)

[0816] AttrPointCnt = 0

[0817] if (layer_group_id < num_layer_groups_minus1)

[0818] numNodes = SubgroupDirectNodePointCnt[layerGroupIdx][subgroupIdx]

[0819] else

[0820] numNodes = SubgroupNodeCnt[layerGroupIdx][subgroupIdx]

[0821]

[0822] for (i = 0; i < numNodes; i++, AttrPointCnt++)

[0823] for (c = 0; c < 3; c++)

[0824] SlicePointAttr[AttrPointCnt][c] = SubgroupNodeAttr[layerGroupIdx][subgroupIdx][i][c]

[0825] In other words, once attribute decoding is complete, the decoded attribute values ​​of the subgroups are stored in the slice's output attribute array and reflected in the final output. At this time, AttrPointCnt, a cumulative index pointing to the location within the slice where attributes will be stored, is initialized to 0 when layer_group_id is 0 (root layer group). This corresponds to the process of initializing the cumulative counter to sequentially fill the slice attributes starting from the root layer group. Additionally, numNodes, the number of nodes (or points) to be stored as output, is determined based on whether the current layer group is the last layer group. Specifically, if layer_group_id is less than num_layer_groups_minus1 (i.e., not the last layer group), SubgroupDirectNodePointCnt[layerGroupIdx][subgroupIdx] is set to numNodes. On the other hand, if layer_group_id corresponds to the last layer group (num_layer_groups_minus1), set SubgroupNodeCnt[layerGroupIdx][subgroupIdx] to numNodes. This is because in the last layer group, the last restored nodes correspond to the output points, so the unit and number of output targets are different.

[0826] Next, i is incremented from 0 to numNodes-1, and attribute values ​​for each node (or point) are sequentially stored in the slice output array. In each iteration, AttrPointCnt is incremented by 1 to continuously update the position of the next attribute to be recorded within the slice. Additionally, for each node (or point), attributes are stored for three components (c = 0..2, e.g., RGB components), and consequently, the restored attribute values ​​stored in SubgroupNodeAttr[layerGroupIdx][subgroupIdx][i][c] are mapped to SlicePointAttr[AttrPointCnt][c] and reflected as slice output attributes.

[0827] Meanwhile, as previously mentioned, it was noted that LodMinLevel and LodMaxLevel are calculated in a manner inconsistent with the meaning of startDepth and endDepth (i.e., LodMinLevel = occtreeMaxDepthMinus1 - (startDepth-1), LodMaxLevel = LodMinLevel+num_layers_minus1[layer_group_id]+1), which may cause confusion during the implementation and interpretation process. As another embodiment to correct this error and prevent confusion in interpretation, the present disclosure newly defines LodMinLevel and LodMaxLevel as follows, based on startDepth and endDepth, which are used to describe the depth range of the occupancy tree of FGS geometry. Accordingly, the LoD range directly corresponds to the actual depth range of the partial occupancy tree, ensuring consistency in implementation.

[0828] LodMinLevel = occtreeMaxDepthMinus1 +1 - endDepth

[0829] LodMaxLevel = occtreeMaxDepthMinus1 +1 - startDepth

[0830] That is, the minimum level of LoDs for an FGS attribute identified by LodMinLevel is calculated as the difference between the maximum depth of the full occupancy tree (occtreeMaxDepthMinus1+1) and the end depth (endDepth) of the partial occupancy tree of the FGS geometry corresponding to the FGS attribute (i.e., LodMinLevel = occtreeMaxDepthMinus1 + 1 - endDepth). And, the maximum level of LoDs for an FGS attribute identified by LodMaxLevel is calculated as the difference between the maximum depth of the full occupancy tree (occtreeMaxDepthMinus1+1) and the start depth (startDepth) of the partial occupancy tree of the FGS geometry corresponding to the FGS attribute (i.e., LodMaxLevel = occtreeMaxDepthMinus1 + 1 - startDepth).

[0831] The following describes the LoD generation update process when FGS is enabled, based on the newly defined LodMinLevel and LodMaxLevel as described above.

[0832] According to the embodiments, when fgs_layer_group_enabled is 1, the minimum level of the LoD is specified in the variable LodMinLevel. The maximum level of the LoD can be set to overlap with the minimum level of the LoD of the parent FGS. Here, fgs_layer_group_enabled is a parameter (or field or syntax element) included in the SPS that indicates whether a slice contains multiple FGSs (fine granularity slices) for partial slice geometry or partial slice attributes. If fgs_layer_group_enabled is 0, it indicates that a slice is not composed of FGSs, and if it is 1, it indicates that a slice is composed of FGSs.

[0833] According to the embodiments, the finest detail level is identified by the detail level index LodMinLevel. LodMinLevel is the log2 quantized node size of the finest level of the partial occupancy tree of the FGS geometry.

[0834] According to the embodiments, the coarsest detail level is identified by the detail level index LodMaxLevel. In one embodiment, when layer_group_id is 0 (i.e., root layer group), LodMaxLevel is set to the log2 quantized node size of the coarsest level of the FGS geometry. And, when layer_group_id is greater than 0 (i.e., not root layer group), LodMaxLevel is set to the log2 quantized node size of the coarsest level of the FGS geometry plus 1.

[0835] In this disclosure, detail levels are iteratively subsampled starting from the finest detail level until a single point remains or a subsampled detail level identified by LoDMaxLevel is generated. The variable Lvl identifies the detail level to be subsampled.

[0836] In the LoD generation process according to the embodiments, if the layer group is not the root layer group, i.e., if layer_group_id is greater than 0, LodMaxLevel, which represents the maximum detail level, is set to increase by 1 as follows (=LodMaxLevel++). This is intended to adjust the coarsest detail level generated in the current layer group by taking into account the overlap of LoD ranges with the upper layer group. Subsequently, the variable Lvl, which represents the current detail level for LoD subsampling, is initialized to LodMinLevel, which is the minimum detail level. Then, iterative subsampling is performed while gradually increasing the detail level until Lvl reaches LodMaxLevel, i.e., until the coarsest detail level is reached.

[0837] For each detail level, if the number of points included in that level (LodPtCnt[Lvl]) is 1, meaningful subsampling is no longer possible, so the LoD generation process is terminated. Conversely, if there are two or more points in that detail level, subsampling is performed on the set of point indices (LodPtIdx[Lvl]) corresponding to that detail level to generate the next detail level.

[0838] When this iterative process is completed, the actual number of generated LoDs is set to the value obtained by adding 1 to the final processed detail level index Lvl, and this value is defined as LodCnt. In other words, LodCnt represents the total number of detail levels generated in the current FGS.

[0839] if(layer_group_id>0)

[0840] LodMaxLevel++

[0841]

[0842] Lvl = LodMinLevel

[0843] for (; Lvl < LodMaxLevel; Lvl++) {

[0844] if (LodPtCnt[Lvl] == 1)

[0845] break

[0846] … / * subsample LodPtIdx[Lvl] * /

[0847] }

[0848] LodCnt = Lvl + 1

[0849] And, the coarsest detail level can be identified by the detail level index LodCnt-1. All points belonging to the coarsest detail level are assigned to the coarsest level's refinement list.

[0850] Meanwhile, in the present disclosure, PointCnt is defined as a cumulative count of decoded points. However, in FGS environments, the attribute decoding process is performed in subgroup units, and the number of output attributes is not the total number of points, but the number of nodes or points generated by the FGS geometry decoding process. Therefore, it is not appropriate to use PointCnt as is in the attribute decoding process of FGS.

[0851] This disclosure defines SubgroupAttrNodeCnt, which explicitly indicates the number of attribute outputs at the subgroup level, to resolve mismatches that occur when using PointCnt during the FGS attribute decoding process. In this disclosure, SubgroupAttrNodeCnt is defined as the sum of the number of nodes generated based on the Occupancy tree and the number of directly coded points. That is, SubgroupAttrNodeCnt can be defined as the sum of the number of points corresponding to nodes generated by the Occupancy tree and the number of points generated from directly coded nodes. Subsequently, SubgroupAttrNodeCnt is used instead of PointCnt in various attribute processing steps, such as raw attribute decoding, calculation of transform factor weights, lifting transformation, and calculation of quantization weights. As another example, SubgroupAttrNodeCnt may also be used in an encoder for various attribute processing steps, such as raw attribute encoding, calculation of transform factor weights, lifting transformation, and calculation of quantization weights.

[0852] The following is an explanation of the FGS attribute decoding process based on SubgroupAttrNodeCnt.

[0853] SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx] is an alias for the number of direct coded and occupancy tree generated nodes at the endDepth-th depth of a subgroup identified by layerGroupIdx and subgroupIdx, as shown below. That is, SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx] is an alias for a value representing the sum of the number of nodes generated through the occupancy tree (SubgroupNodeCnt) and the number of points contained in the direct-coded nodes (SubgroupDirectNodePointCnt) at the endDepth depth of the subgroup identified by layerGroupIdx and subgroupIdx.

[0854] SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx] := SubgroupNodeCnt[layerGroupIdx][subgroupIdx] + SubgroupDirectNodePointCnt[layerGroupIdx][subgroupIdx]

[0855] The following is a description of the raw attribute decoding, transform coefficient weights-based processing, lifting transform-based processing, and point quantization weights-based processing to which SubgroupAttrNodeCnt[layerGroupIdx ][ subgroupIdx ] is applied.

[0856] Raw attribute decoding

[0857] When attr_coding_type is 3, the attribute value is set directly by raw_attr_value without transformation or prediction. In this case, the attribute values ​​are set identically to the corresponding raw_attr_value syntax elements as follows. That is, the following code is the process of setting attribute values ​​corresponding to each point or node subject to attribute decoding for the subgroup identified by the layer group index layerGroupIdx and the subgroup index subgroupIdx. At this time, the total number of targets for which attribute values ​​must be set—that is, the number of points or nodes subject to attribute decoding for the subgroup identified by the layer group index layerGroupIdx and the subgroup index subgroupIdx—is specified by SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx].

[0858] for (ptIdx = 0; ptIdx < SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx]; ptIdx++)

[0859] for (c = 0; c < AttrDim; c++)

[0860] PointAttr[ptIdx][c] = raw_attr_value[ptIdx][c]

[0861] To explain the code above in more detail, for each point index ptIdx included in SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx], the attribute consists of multiple components equal to the number of dimensions defined by AttrDim, and each component index c is processed independently. For each attribute component of each point, the raw attribute value raw_attr_value[ptIdx][c] parsed from the bitstream is selected. The selected raw attribute value is then assigned as is to the attribute storage location of the corresponding point, and the result is stored in the attribute array PointAttr[ptIdx][c].

[0862] As such, the present disclosure sets each attribute component value to correspond one-to-one with the raw attribute value for all points defined in subgroup units, thereby allowing the raw attribute data to be directly reflected in the decoding result.

[0863] Transform coefficient weights

[0864] According to the embodiments, coefficient weights represent the relative significance of the coefficients. The larger the weight value of a coefficient, the greater the influence that coefficient has on the attribute value being decoded.

[0865] At this time, the array CoeffWeight, which stores the coefficient weights, is initialized by setting all elements to 256. That is, in the initial state, all elements of the array CoeffWeight are set to the same value (e.g., 256).

[0866] According to embodiments, initialization is performed based on SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx], which is the number of all points (or nodes) requiring attribute processing, for a subgroup identified by layer group index layerGroupIdx and subgroup index subgroupIdx as follows. In other words, the same initial weight (e.g., 256) is assigned to all attribute targets included in the subgroup.

[0867] for (i = 0; i < SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx]; i++)

[0868] CoeffWeight[i] = 256

[0869] Subsequently, the derivation of coefficient weights depends on whether LoD scalability is enabled.

[0870] The following is an explanation of the derivation of transformation coefficient weights in the case of FGS.

[0871] According to the embodiments, if fgs_layer_group_enabled is 1, coefficient weights are calculated cumulatively sequentially from the finest detail level of the FGS to the coarsest detail level.

[0872] At this time, the accumulated coefficient weights of each refinement point at the detail level are distributed to the points of the corresponding predictor set as follows. The distribution is proportional to each predictor weight.

[0873] for (lvl = LodMinLevel; lvl < LodCnt - 1; lvl++)

[0874] for (rfmtIdx = 0; rfmtIdx < LodRfmtPtCnt[lvl]; rfmtIdx++) {

[0875] ptIdx = LodRfmtPtIdx[lvl][rfmtIdx]

[0876] coeffW = CoeffWeight[ptIdx]

[0877] for (ni = 0; ni < PredCnt[ptIdx]; ni++) {

[0878] if (!PredPtRef[ptIdx][ni]){

[0879] predW = PredWeight[ptIdx][ni]

[0880] CoeffWeight[PredPtIdx[ptIdx][ni]] += DivExp2Up(coeffW × predW, 8)

[0881] }

[0882] }

[0883] }

[0884] In other words, the code above represents the process for cumulatively calculating CoeffWeights in an FGS environment, moving from finer to coarser levels of the LoD. More specifically, the index variable lvl, which identifies the detail level, is initialized to LodMinLevel, which corresponds to the finest detail level. Then, processing is performed sequentially for each detail level as lvl is incremented until lvl reaches LodCnt 1. That is, within the range excluding the coarsest detail level, the cumulative calculation of transformation CoeffWeights is performed by proceeding from the finest detail level to the coarser detail level.

[0885] At this time, for each detail level lvl, refinement points are sequentially selected up to the number of refinement points included in that level, LodRfmtPtCnt[lvl]. The actual point index ptIdx of each refinement point is obtained from LodRfmtPtIdx[lvl][rfmtIdx]. Then, for the selected refinement point ptIdx, the transformation coefficient weight CoeffWeight[ptIdx] currently set for that point is retrieved and set as coeffW. Subsequently, prediction relationships are sequentially processed up to the number of prediction points included in the predictor set of the point ptIdx, PredCnt[ptIdx]. Additionally, for each prediction relationship, a cumulative update of the transformation coefficient weight CoeffWeight[ptIdx] is performed only if the prediction reference flag PredPtRef[ptIdx][ni] is not set. If it is to be updated, the prediction weight PredWeight[ptIdx][ni] corresponding to the prediction relationship is taken as predW.

[0886] Subsequently, calculate the product of the refinement point's transformation coefficient weight coeffW and prediction weight predW, and 2 this value 8 The function DivExp2Up(coeffW × predW, 8), which scales and rounds up to an integer, is applied to calculate the weight increment to be propagated to the prediction point. The calculated increment is accumulated in the transformation coefficient weight CoeffWeight of the point identified by the index of the corresponding prediction point, PredPtIdx[ptIdx][ni].

[0887] Consequently, according to the code-based transformation coefficient weight derivation process described above, the transformation coefficient importance of refinement points located at fine detail levels is gradually accumulated and propagated to adjacent points following the prediction relationship. Through this, the transformation coefficient weights are updated to reflect the relationship between the prediction structure and detail levels between points, and the relative influence of each point on the final attribute value can be effectively reflected during the subsequent attribute transformation and restoration process.

[0888] lifting transform

[0889] According to the embodiments, when attr_coding_type is 2, i.e., when a lifting transformation is applied, the transform update operator redistributes coefficient values ​​to predicting points at a coarser detail level. That is, the update operation is performed based on SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx], which is the number of all points (or nodes) requiring attribute processing, for a subgroup identified by the layer group index layerGroupIdx and the subgroup index subgroupIdx as follows. In other words, the update operation is intended to redistribute coefficient values ​​of points at a finer detail level to predicting points located at a coarser detail level.

[0890] for (ptIdx = 0; ptIdx < SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx]; ptIdx++)

[0891] updateN[ptIdx] = updateD[ptIdx] = 0

[0892] for (rfmtIdx = 0; rfmtIdx < LodRfmtPtCnt[Lvl]; rfmtIdx++) {

[0893] rfmtPtIdx = LodRfmtPtIdx[Lvl][rfmtIdx]

[0894] coeffW = CoeffWeight[rfmtPtIdx]

[0895] for (ni = 0; ni < PredCnt[rfmtPtIdx]; ni++) {

[0896] if (!PredPtRef[ptIdx][ni]){

[0897] nPtIdx = PredPtIdx[rfmtPtIdx][ni]

[0898] nWeight = DivExp2Up(PredWeight[rfmtPtIdx][ni] × coeffW, 8)

[0899] updateD[nPtIdx] += nWeight

[0900] for (c = 0; c < AttrDim; c++)

[0901] updateN[nPtIdx][c] += nWeight × PointAttr[rfmtPtIdx][c]

[0902] }

[0903] }

[0904] }

[0905] for (ptIdx = 0; ptIdx < SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx]; ptIdx++)

[0906] if (updateD[ptIdx])

[0907] PointAttr[ptIdx] -= Div(updateN[ptIdx], updateD[ptIdx], 0)

[0908] According to the code above, first, for all attribute target points included in the subgroup, the cumulative numerator (updateN) and cumulative denominator (updateD) for the update are initialized to 0. This initialization is also performed as many times as defined by SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx]. Next, iterate through the refinement points included in the current detail level (Lvl) being processed, and retrieve the coefficient weights of each refinement point.

[0909] Then, among the prediction points referenced by each refinement point, if the prediction reference flag is not set, a weight is calculated for that prediction point. This weight is the result of multiplying the prediction weight and the coefficient weight, dividing by the specified bit precision, and rounding up. The calculated weight is added to the denominator accumulation value (updateD) for the prediction point, and simultaneously, for each attribute component of that prediction point, the attribute value of the refinement points multiplied by the weight is added to the numerator accumulation value (updateN). When processing for all refinement points is complete, if the denominator accumulation value for each point is not zero, a transformation update is performed by subtracting the result of dividing the accumulated numerator value by the denominator value from the attribute value of that point.

[0910] Accordingly, the update operation of the present disclosure initializes updateN / updateD for the entire set of attribute output targets of the current subgroup defined by SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx], accumulates the numerator and denominator so that the refinement points of the LoD level Lvl contribute to the points of the set through a prediction relationship, and then updates the PointAttr of each point within the same set using the accumulated result (numerator / denominator).

[0911] Point quantization weights

[0912] According to the embodiments, point quantization coefficient weights represent predictive relationships between points. Points with larger quantization weights have a greater influence on the prediction process.

[0913] At this time, the array QuantWeight, which stores the point quantization weights, is initialized by setting all elements to 256. That is, in the initial state, all elements of the array QuantWeight are set to the same value (e.g., 256).

[0914] According to embodiments, initialization is performed based on SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx], which is the number of all points (or nodes) requiring attribute processing, for a subgroup identified by layer group index layerGroupIdx and subgroup index subgroupIdx as follows. That is, for the current subgroup identified by layer group index layerGroupIdx and subgroup index subgroupIdx, the total number of points subject to output attribute decoding is defined by SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx]. Accordingly, for each point index i included in the subgroup, QuantWeight[i] is set to the same initial value of 256.

[0915] for (i = 0; i < SubgroupAttrNodeCnt[layerGroupIdx][subgroupIdx]; i++)

[0916] QuantWeight[i] = 256

[0917] The following is an explanation of quantization weights derivation.

[0918] According to the embodiments, the index variable lvl representing the current detail level is initialized to LodMinLevel, which corresponds to the finest detail level. Then, iterative processing is performed for each detail level as shown in the code below while increasing lvl until lvl reaches LodCnt - 1, that is, just before the coarsest detail level (final level).

[0919] for (lvl = LodMinLevel; lvl < LodCnt - 1; lvl++)

[0920] for (rfmtIdx = 0; rfmtIdx < LodRfmtPtCnt[lvl]; rfmtIdx++) {

[0921] ptIdx = LodRfmtPtIdx[lvl][rfmtIdx]

[0922] coeffW = QuantWeight[ptIdx]

[0923] for (ni = 0; ni < PredCnt[ptIdx]; ni++) {

[0924] if (!PredPtRef[ptIdx][ni]){

[0925] QuantWeight[PredPtIdx[ptIdx][ni]] +=

[0926] DivExp2Inf(coeffW × quant_neigh_weight[ni], 8)

[0927] }

[0928] }

[0929] }

[0930] According to the code above, for each detail level lvl, refinement points are sequentially selected up to the number of refinement points included in that detail level, LodRfmtPtCnt[lvl]. Specifically, the actual point index ptIdx of each refinement point is obtained from LodRfmtPtIdx[lvl][rfmtIdx]. Then, for the selected refinement point ptIdx, the quantization weight currently set at that point, QuantWeight[ptIdx], is taken as coeffW. Subsequently, the prediction relationships are traversed up to the number of prediction points constituting the predictor set for the point ptIdx, PredCnt[ptIdx].

[0931] Then, for each prediction relationship, cumulative updates of quantization weights are performed only when the prediction reference flag PredPtRef[ptIdx][ni] is not set (i.e., only when it is not treated as a reference and excluded from the update target). If it is an update target, the index of the ni-th prediction point of ptIdx, PredPtIdx[ptIdx][ni], is identified, and the quantization weight of that prediction point, QuantWeight[PredPtIdx[ptIdx][ni]], is increased.

[0932] In this case, the increment is calculated based on the product of the refinement point's quantization weight (coeffW) and the neighbor weight (quant_neigh_weight[ni]) corresponding to the prediction relationship, and the product is 2 8 It is calculated by the function DivExp2Inf(coeffW × quant_neigh_weight[ni], 8), which scales by and then rounds down to an integer. Therefore, the larger the quantization weight of the refinement point, and the larger the neighbor weight of the corresponding prediction relationship, the larger the quantization weight of the prediction point accumulates.

[0933] In this way, the code-based point quantization weight derivation process described above starts from a fine detail level and proceeds toward a coarser detail level, accumulating and propagating the quantization weight of each refinement point to prediction points along the prediction relationship. Through this, the prediction relationship between points is reflected in the quantization weight, and subsequently, the relative influence of each point can be appropriately adjusted during the prediction-based attribute restoration process.

[0934] According to embodiments, if fgs_layer_group_enabled is 1 and subgroup_weight_adjustment_enabled or dadu_subgroup_weight_adjustment_enabled is 1, the quantization weights of the subgroup are adjusted to mitigate the missing information out of the layer group boundary. According to embodiments, the array NumRefNodes represents the number of nodes that reference a node as a neighbor, and the array NumRefNodes is initialized by setting all elements to 0.

[0935] Here, as an example, subgroup_weight_adjustment_enabled is signaled to the attribute data unit (ADU) and dadu_subgroup_weight_adjustment_enabled is signaled to the dependent attribute data unit (DADU).

[0936] When subgroup_weight_adjustment_enabled is 1, it indicates that subgroup weight adjustment coefficients subgroup_weight_adj_coeff_a and subgroup_weight_adj_coeff_b exist for the current FGS. When subgroup_weight_adjustment_enabled is 0, there are no subgroup weight adjustment coefficients, and subgroup_weight_adj_coeff_a and subgroup_weight_adj_coeff_b are estimated to be 0.

[0937] When dadu_subgroup_weight_adjustment_enabled is 1, it indicates that subgroup weight adjustment coefficients dadu_subgroup_weight_adj_coeff_a and dadu_subgroup_weight_adj_coeff_b exist for the current FGS. When dadu_subgroup_weight_adjustment_enabled is 0, there are no subgroup weight adjustment coefficients, and dadu_subgroup_weight_adj_coeff_a and dadu_subgroup_weight_adj_coeff_b are estimated to be 0.

[0938] The code below shows the process of adjusting the QuantWeight of a subgroup to mitigate the missing information out of the layer group boundary when fgs_layer_group_enabled is 1 and subgroup_weight_adjustment_enabled or dadu_subgroup_weight_adjustment_enabled is 1.

[0939] maxRefNodes = 0

[0940] numPointsInSubgroup = SubgroupNodeCnt[dadu_layer_group_id][dadu_subgroup_id] + SubgroupDirectNodePointCnt[dadu_layer_group_id][dadu_subgroup_id]

[0941] for (i = 0; i < numPointsInSubgroup; i++) {

[0942] NumRefNodes[i] = 0

[0943] }

[0944] for (lvl = LodMinLevel; lvl < LodCnt - 1; lvl++)

[0945] for (rfmtIdx = 0; rfmtIdx < LodRfmtPtCnt[lvl]; rfmtIdx++) {

[0946] ptIdx = LodRfmtPtIdx[lvl][rfmtIdx]

[0947] for (ni = 0; ni < PredCnt[ptIdx]; ni++) {

[0948] if (!PredPtRef[ptIdx][ni]) {

[0949] NumRefNodes[PredPtIdx[ptIdx][ni]]++

[0950] if (maxRefNodes < NumRefNodes[PredPtIdx[ptIdx][ni]])

[0951] maxRefNodes = NumRefNodes[PredPtIdx[ptIdx][ni]]

[0952] }

[0953] }

[0954] }

[0955] if(maxRefNodes > 0) {

[0956] for(i = 0; i < numPointsInSubgroup; i++){

[0957] QuantWeight[i] += (NumRefNodes[i]* subgroup_weight_adj_coeff_a) / maxRefNodes + subgroup_weight_adj_coeff_b

[0958] }

[0959] }

[0960] According to the code above, the maximum reference count variable maxRefNodes is first initialized to 0. Additionally, numPointsInSubgroup, the total number of points included in the current processing target subgroup, is calculated. Here, numPointsInSubgroup is defined as the sum of SubgroupNodeCnt[dadu_layer_group_id][dadu_subgroup_id], the number of nodes generated based on the Occupancy tree, and SubgroupDirectNodePointCnt[dadu_layer_group_id][dadu_subgroup_id], the number of points generated from direct-coded nodes. In other words, numPointsInSubgroup represents the total number of all points in the current subgroup to which attribute and quantization weight corrections are applied.

[0961] Next, increment index i from 0 to numPointsInSubgroup - 1, and initialize NumRefNodes[i] to 0.

[0962] Next, NumRefNodes and maxRefNodes are calculated using the prediction relationship defined based on the LoD level. Specifically, the process is repeated for each detail level starting from the detail level index lvl at LodMinLevel until lvl reaches LodCnt - 1, i.e., just before the coarsest detail level (final level). For each detail level lvl, refinement points are iterated through as many times as LodRfmtPtCnt[lvl], which is the number of refinement points included in that level. The actual point index ptIdx for each refinement point is obtained from LodRfmtPtIdx[lvl][rfmtIdx].

[0963] Then, for each refinement point ptIdx, iterate through the prediction relationship as many times as PredCnt[ptIdx], the number of prediction points included in the predictor set of that point. For each prediction relationship, accumulate the reference count only if the prediction reference flag PredPtRef[ptIdx][ni] is not set. In this case, identify the index of the prediction point PredPtIdx[ptIdx][ni] in the prediction relationship, and increment NumRefNodes[PredPtIdx[ptIdx][ni]] by 1, which represents the number of times that prediction point has been referenced as a neighbor. After incrementing the reference count, if NumRefNodes[PredPtIdx[ptIdx][ni]] is greater than the maximum reference count observed so far maxRefNodes, update maxRefNodes to that value.

[0964] After the reference count (NumRefNodes) of each point within the subgroup and the maximum reference count (maxRefNodes) within the subgroup are calculated through the above process, quantization weight adjustment is performed only when maxRefNodes is greater than 0. That is, if no points are actually referenced as neighbors, no adjustment is performed, and the adjustment is applied only when one or more reference relationships exist. When adjustment is performed, the quantization weight QuantWeight[i] of each point is increased while iterating through index i from 0 to numPointsInSubgroup - 1. The increment amount consists of a term obtained by normalizing the value of the reference count NumRefNodes[i] of the corresponding point by the coefficient subgroup_weight_adj_coeff_a to maxRefNodes, and the sum of the constant term subgroup_weight_adj_coeff_b.

[0965] The following is a description of fgs_occupancy_tree(startDepth, endDepth) and dependent_geometry_data_unit_header() included in the FGS dependent data unit. fgs_occupancy_tree(startDepth, endDepth) may be included in the geometry data unit when fgs_layer_group_enabled is 1. fgs_occupancy_tree(startDepth, endDepth) and dependent_geometry_data_unit_header() are referenced during the geometry decoding process and / or the geometry decoding process.

[0966] FIG. 34 is a diagram showing an example of an FGS occupancy tree syntax (fgs_occupancy_tree(startDepth, endDepth)) according to embodiments.

[0967] In Fig. 34, the variable OccQpSubtreeDepth is calculated by adding 1 to the value of occtree_depth_minus1.

[0968] The value obtained by adding 1 to fgs_occtree_depth_minus1 represents the number of maximum tree levels existing in the partial occupancy tree within the GDU of the FGS. According to embodiments, the variable OccQpSubtreeDepth may identify tree levels where occ_subtree_qp_offset_present is 1, and occupancy tree scaling may be specified based on the variable OccQpSubtreeDepth.

[0969] Afterwards, for each depth (Dpth) from startDepth to endDepth, the occupancy tree level (occupancy_tree_level(Dpth)) corresponding to that depth is processed sequentially.

[0970] If the next level (Dpth + 1) of the depth level currently being processed exceeds the maximum depth (OcctreeEntropyStreamDepth) at which entropy coding is performed for the occupancy tree, the end of the entropy stream for the occupancy tree (occtree_end_of_entropy_stream) is explicitly indicated at that point. That is, occtree_end_of_entropy_stream is a non-coded syntax element used to specify the end point of the arithmetic decoder at the end of the entropy stream.

[0971] FIG. 35 is a diagram showing an example of a dependent geometry data unit header syntax (dependent_geometry_data_unit_header()) according to embodiments.

[0972] In FIG. 35, if subgroup_context_reference_indication_enabled is enabled, the loop is executed with variable i starting from the value of layer_group_id plus 1 and increasing by 1 until (including) reaching num_layer_groups_minus1. The loop according to the embodiments may include num_subsequent_subgroups[i].

[0973] If subgroup_context_reference_indication_enabled is 1 (i.e., enabled), it indicates that the context state of the current data unit is used to initialize one or more subsequent data units. If subgroup_context_reference_indication_enabled is 0, it indicates that the context state of the current data unit is not used to initialize subsequent data units.

[0974] The value obtained b...

Claims

1. A step of decoding geometry data of point cloud data within a bitstream; and A decoding method comprising the step of decoding attribute data of the above point cloud data.

2. In Paragraph 1, The geometry data and the attribute data are each decoded in units of fine segmentation slices (FGS), and Each of the above FGS corresponds one-to-one with a spatially partitioned subgroup within a layer group defined as a group of consecutive tree levels of an occupancy tree, and Each of the above FGS is a decoding method identified by a combination of a layer group index for identifying the layer group and a subgroup index for identifying a subgroup within the layer group.

3. In claim 2, the step of decoding the attribute data is, For a specific FGS, a step of generating Levels of Detail (LoDs) based on a partial occupancy tree corresponding to the FGS, and It includes a step of restoring attribute data of the FGS based on the above LoDs, Based on the start depth information and end depth information of the above-mentioned Occupancy Tree, LoD minimum level information and LoD maximum level information are obtained, and The above LoD minimum level information identifies the finest detail level among the above LoDs, and the above LoD maximum level information identifies the coarsest detail level among the above LoDs, and The step of generating the above LoDs is, A decoding method for generating LODs by subsampling points in the direction of the coarse detail level, starting from the finest detail level.

4. In Paragraph 3, The above LoD minimum level information is obtained based on the maximum depth information of the full occupancy tree and the end depth information of the partial occupancy tree, and A decoding method in which the above LoD maximum level information is obtained based on the maximum depth information of the entire occupancy tree and the starting depth information of the partial occupancy tree.

5. In Paragraph 3, A decoding method in which the above LoD minimum level information is set to the log2 quantized node size of the finest level of the above partial occupancy tree, the above LoD maximum level information is set to the log2 quantized node size of the coarsest level of the above partial occupancy tree, and if the above layer group is not a root layer group, the above LoD maximum level information is set to the value obtained by adding 1 to the log2 quantized node size of the coarsest level of the above partial occupancy tree.

6. In claim 3, the step of restoring the attribute data of the FGS A decoding method that performs at least one of raw attribute decoding, transform-based decoding, coefficient-weight-based processing, and quant-weight-based processing based on a range corresponding to the number of output attributes of the above FGS.

7. In Paragraph 5, A decoding method in which the number of output attributes is the sum of the number of nodes generated by the partial occupancy tree and the number of points generated from the direct-coded nodes.

8. Memory; and At least one processor connected to the memory; comprising, wherein the at least one processor: Decoding geometry data of point cloud data within a bitstream; and Decoding attribute data of the above point cloud data; A decoding device configured to do so.

9. In Paragraph 8, The geometry data and the attribute data are each decoded in units of fine segmentation slices (FGS), and Each of the above FGS corresponds one-to-one with a spatially partitioned subgroup within a layer group defined as a group of consecutive tree levels of an occupancy tree, and Each of the above FGS is a decoding device identified by a combination of a layer group index for identifying the layer group and a subgroup index for identifying a subgroup within the layer group.

10. In claim 2, the at least one processor is, For a specific FGS, Levels of Detail (LoDs) are generated based on a partial occupancy tree corresponding to the FGS, and attribute data of the FGS is restored based on the LoDs. Based on the start depth information and end depth information of the above-mentioned Occupancy Tree, LoD minimum level information and LoD maximum level information are obtained, and The above LoD minimum level information identifies the finest detail level among the above LoDs, and the above LoD maximum level information identifies the coarsest detail level among the above LoDs, and A decoding device that generates LODs by subsampling points in the direction of the coarse detail level, starting from the finest detail level.

11. In Paragraph 10, The above LoD minimum level information is obtained based on the maximum depth information of the entire occupancy tree and the end depth information of the above partial occupancy tree, and A decoding device that obtains the above LoD maximum level information based on the maximum depth information of the entire occupancy tree and the starting depth information of the partial occupancy tree.

12. In claim 10, the at least one processor A decoding device that performs at least one of raw attribute decoding, transform-based decoding, coefficient-weight-based processing, and quant-weight-based processing based on a range corresponding to the number of output attributes of the above FGS.

13. A step of encoding the geometry data of the point cloud data; and An encoding method comprising the step of encoding attribute data of the above point cloud data.

14. Memory; and At least one processor connected to the memory; comprising, wherein the at least one processor: Encoding the geometry data of the point cloud data; and An encoding device configured to encode attribute data of the above point cloud data.

15. Step for acquiring a bitstream for point cloud data, The bitstream is generated based on the step of encoding geometry data of the point cloud data; and the step of encoding attribute data of the point cloud data; and A method comprising the step of transmitting data including the bitstream above.

Images