Mesh data encoding device, mesh data encoding method, mesh data decoding device, and mesh data decoding method

Abstract

A method according to embodiments may comprise the steps of: decoding a base mesh within a bitstream; decoding atlas within the bitstream; and decoding an attribute within the bitstream. A method according to embodiments may comprise the steps of: encoding a base mesh of mesh data; encoding atlas of the mesh data; and encoding an attribute of the mesh data.

Description

Mesh data encoding device, mesh data encoding method, mesh data decoding device, and mesh data decoding method

[0001] The embodiments provide a method for providing Point Cloud content to provide users with various services such as Virtual Reality (VR), Augmented Reality (AR), Mixed Reality (MR), and autonomous driving services.

[0002] A point cloud is a collection of points in 3D space. The sheer number of points in 3D space makes it difficult to generate point cloud data.

[0003] Mesh data refers to a data format in which connectivity information between mesh vertices is added to point cloud data.

[0004] There is a problem that a lot of processing is required to transmit and receive dynamic mesh data.

[0005] The technical problem according to the embodiments is to provide a point mesh data transmission device, transmission method, mesh data reception device and reception method for efficiently transmitting and receiving mesh data in order to solve the problems described above.

[0006] The technical problem according to the embodiments is to provide a point mesh transmission device, a transmission method, a mesh data reception device, and a reception method for resolving latency and encoding / decoding complexity.

[0007] However, the scope of the embodiments is not limited to the aforementioned technical tasks, and the scope of the embodiments may be expanded to other technical tasks that can be inferred by a person skilled in the art based on the entire contents of this document.

[0008] To achieve the above-described object and other advantages, a method according to embodiments may include a step of decoding a basemesh within a bitstream; a step of decoding an atlas within the bitstream; and a step of decoding an attribute within the bitstream. A method according to embodiments may include a step of encoding a basemesh of mesh data; a step of encoding an atlas of mesh data; and a step of encoding an attribute of the mesh data.

[0009] The mesh data transmission method, transmission device, mesh data reception method, and reception device according to the embodiments can provide a quality mesh service.

[0010] The mesh data transmission method, transmission device, mesh data reception method, and reception device according to the embodiments can achieve various video codec methods.

[0011] The mesh transmission method, transmission device, mesh data reception method, and reception device according to the embodiments can provide general-purpose mesh content such as autonomous driving services.

[0012] The drawings are included to further understand the embodiments, and the drawings illustrate the embodiments together with the description related to the embodiments. For a better understanding of the various embodiments described below, reference should be made to the following description of the embodiments in conjunction with the following drawings, in which like reference numerals correspond to corresponding parts throughout the drawings.

[0013] Figure 1 illustrates a V-DMC based encoder and decoder according to embodiments.

[0014] Figure 2 illustrates a system for providing dynamic mesh content according to embodiments.

[0015] Figure 3 shows a V-MESH compression method according to embodiments.

[0016] Figure 4 illustrates pre-processing of V-MESH compression according to embodiments.

[0017] Figure 5 illustrates a mid-edge subdivision method according to embodiments.

[0018] Figure 6 shows a displacement generation process according to embodiments.

[0019] Figure 7 shows a V-DMC encoding process according to embodiments.

[0020] Figure 8 shows a lifting conversion process for displacement according to embodiments.

[0021] Figure 9 illustrates a process of packing transformation coefficients according to embodiments into a 2D image.

[0022] Fig. 10 shows an attribute transfer process of a V-MESH compression method according to embodiments.

[0023] Figure 11 illustrates a V-DMC decoding process according to embodiments.

[0024] Figure 12 illustrates a V-DMC encoding process according to embodiments.

[0025] Figure 13 illustrates a V-DMC decoding process according to embodiments.

[0026] Figure 14 shows a bitstream according to embodiments.

[0027] Figure 15 shows the payload of the V3C unit according to embodiments.

[0028] Figure 16 shows a mesh patch data decryption process according to embodiments.

[0029] Figure 17 illustrates an atlas data decoding process depending on the presence or absence of a displacement vector according to embodiments.

[0030] Fig. 18 shows a dynamic mesh encoder according to embodiments.

[0031] Figure 19 shows a displacement vector conversion process according to embodiments.

[0032] Figure 20 shows a displacement vector conversion process according to embodiments.

[0033] Figure 21 shows a lifting transformation update process according to embodiments.

[0034] Figure 22 shows an atlas data encoding process depending on the presence or absence of a displacement vector according to embodiments.

[0035] Figure 23 shows a dynamic mesh decoder according to embodiments.

[0036] Figure 24 shows an atlas data decoding process depending on the presence or absence of a displacement vector according to embodiments.

[0037] Figure 25 illustrates a process of interpolating or calculating a subdivided vertex normal using restored vertex information according to embodiments.

[0038] Figure 26 shows a displacement vector decoding process according to embodiments.

[0039] Figure 27 shows a lifting inverse transformation update process according to embodiments.

[0040] Figures 28a and 28b illustrate ASPS VDMC extension syntax according to embodiments.

[0041] Figures 29a and 29b illustrate ASPS VDMC extension syntax according to embodiments.

[0042] Figures 30a and 30b illustrate AFPS VDMC extension syntax according to embodiments.

[0043] Figures 31a and 31b illustrate AFPS VDMC extension syntax according to embodiments.

[0044] Figures 32a and 32b illustrate AFPS VDMC extension syntax according to embodiments.

[0045] Figures 33a, 33b and 33c illustrate mesh patch data unit syntax according to embodiments.

[0046] Figures 34a, 34b and 34c illustrate mesh patch data unit syntax according to embodiments.

[0047] Figures 35a, 35b and 35c illustrate mesh patch data unit syntax according to embodiments.

[0048] Figure 36 illustrates a merge mesh patch data unit syntax according to embodiments.

[0049] Figure 37 illustrates a merge mesh patch data unit syntax according to embodiments.

[0050] Figure 38 illustrates a merge mesh patch data unit syntax according to embodiments.

[0051] Figures 39a and 39b illustrate inter-mesh patch data unit syntax according to embodiments.

[0052] Figures 40a and 40b illustrate inter-mesh patch data unit syntax according to embodiments.

[0053] Figures 41a and 41b illustrate inter-mesh patch data unit syntax according to embodiments.

[0054] Figures 42a, 42b, 42c and 42d illustrate mesh patch data unit syntax according to embodiments.

[0055] Figures 43a and 43b illustrate merge mesh patch data unit syntax according to embodiments.

[0056] Figures 44a, 44b and 44c illustrate inter-mesh patch data unit syntax according to embodiments.

[0057] Figure 45 shows a mesh data encoding method according to embodiments.

[0058] Figure 46 shows a mesh data decryption method according to embodiments.

[0059] Preferred embodiments of the embodiments are described in detail, examples of which are illustrated in the accompanying drawings. The following detailed description, with reference to the accompanying drawings, is intended to illustrate preferred embodiments of the embodiments, rather than merely show embodiments that can be implemented according to the embodiments. The following detailed description includes details to provide a thorough understanding of the embodiments. However, it will be apparent to those skilled in the art that the embodiments may be practiced without these details.

[0060] While most of the terms used in the examples are commonly used in the field, some terms were arbitrarily selected by the applicant, and their meanings are described in detail in the following descriptions as needed. Therefore, the examples should be understood based on the intended meaning of the terms, not simply their names or meanings.

[0061] Figure 1 illustrates a V-DMC based encoder and decoder according to embodiments.

[0062] The basic structure of the currently in-progress V-DMC (v-mesh) is shown in Figure 1. The encoder and decoder according to Figure 1 perform the encoding and decoding process of media representing dynamic meshes using V3C technology. The preprocessor converts the input dynamic mesh representation into several V3C components: a base mesh, a set of displacements, a 2D representation of attributes, and an atlas. The original mesh is simplified into a base mesh. The base mesh can be encoded using any mesh codec. Displacement vectors can be encoded into V3C geometric video components using any video codec, either indicated by a profile or using SEI messages. For example, depending on the profile, the displacement vectors (displacement data) can be encoded using arithmetic coding. The attribute data can include additional attributes. For example, texture or material information can be included as additional attributes and can be encoded using any video codec. The atlas data contains information on how to perform inverse reconstruction and is provided to the V3C decoding and / or rendering system. For example, atlas data may include how to perform subdivision of a base mesh, how to apply displacement vectors to subdivided mesh vertices, how to apply attributes to the reconstructed mesh, etc.

[0063] The encoder may comprise a memory and at least one processor connected to the memory. The at least one processor may be configured to perform operations such as a preprocessor, an atlas encoder, a basemesh encoder, a displacement vector encoder, a video encoder, and a multiplexer.

[0064] The atlas encoding unit encodes the atlas of mesh data to generate an atlas bitstream. The basemesh encoding unit encodes the basemesh of mesh data to generate a basemesh bitstream. The displacement vector encoding unit encodes the displacement vector of mesh data to generate a displacement vector bitstream. The video encoding unit encodes the properties (attributes) of mesh data to generate an attribute bitstream. The encoder generates parameter information (which may be referred to as signaling information, metadata, etc.) related to each encoding. The encoder may generate a bitstream including parameter information, atlas, basemesh, displacement vector, and / or attribute.

[0065] The decoder may be configured with a memory and at least one processor connected to the memory. The at least one processor may be configured to perform operations such as a demultiplexing unit, an atlas decoding unit, a basemesh decoding unit, a displacement vector decoding unit, and a video decoding unit.

[0066] The atlas decoding unit decodes the atlas within the bitstream. The basemesh decoding unit decodes the basemesh within the bitstream. The displacement vector decoding unit decodes the displacement vector within the bitstream. The video decoding unit decodes the attributes within the bitstream. The decoder can perform each decoding operation based on parameter information within the bitstream. The decoder can reconstruct dynamic mesh data based on the atlas, displacement vector, attributes, and base mesh.

[0067] Below, the operation of the V-DMC encoder and decoder of Fig. 1 is described in more detail.

[0068] Figure 2 illustrates a system for providing dynamic mesh content according to embodiments.

[0069] The system of FIG. 2 includes a point cloud data transmission device (100) and a point cloud data reception device (110) according to embodiments. The point cloud data transmission device may include a dynamic mesh video acquisition unit (101), a dynamic mesh video encoder (102), a file / segment encapsulator (103), and a transmitter (104). The point cloud data reception device (110) may include a reception unit (111), a file / segment decapsulator (112), a dynamic mesh video decoder (113), and a renderer (114). Each component of FIG. 1 may correspond to hardware, software, a processor, and / or a combination thereof. Hereinafter, the point cloud data transmission device according to embodiments may be interpreted as a term referring to the transmission device (100) or a dynamic mesh video encoder (hereinafter, referred to as an encoder) (102). The point cloud data receiving device according to the embodiments may be interpreted as a term referring to a receiving device (110) or a dynamic mesh video decoder (hereinafter, decoder) (113).

[0070] The system of FIG. 2 can perform video-based dynamic mesh compression and decompression.

[0071] Advances in 3D capture, modeling, and rendering have enabled users to consume diverse forms of 3D content, such as AR, XR, metaverse, and holograms, across multiple platforms and devices. 3D content increasingly represents objects with greater precision and realism, enabling users to enjoy immersive experiences. To achieve this, the creation and use of 3D models requires a significant amount of data. Among various types of 3D content, 3D meshes are widely used for efficient data utilization and realistic object representation. Embodiments include a series of processing steps in a system that utilizes such mesh content.

[0072] First, the method of compressing dynamic mesh data starts with the V-PCC (Video-based point cloud compression) standard technology. Point cloud data is data that contains color information at the vertex coordinates (X, Y, Z). Mesh data refers to data in which connectivity information between vertices is added to this vertex information. When creating content, it can be created in the form of mesh data from the beginning. By adding connectivity information to point cloud data, it can be converted into mesh data and used.

[0073] Currently, the MPEG standards body defines two types of dynamic mesh data: Category 1: Mesh data with texture maps as color information. Category 2: Mesh data with vertex colors as color information.

[0074] Mesh coding standards for Category 1 data are currently under development, and work on Category 2 data standards is also planned for the future. The overall process for providing mesh content services may include acquisition, encoding, transmission, decoding, rendering, and / or feedback, as shown in Figure 1.

[0075] To provide mesh content services, 3D data acquired through multiple cameras or specialized cameras can be processed into mesh data types through a series of processes and then converted into video. The generated mesh video is then transmitted through a series of processes, and the receiving end can then reprocess the received data into mesh video and render it. This allows mesh video to be presented to users, who can then interact with the mesh content according to their intended intent.

[0076] A mesh compression system may include a transmitting device and a receiving device. The transmitting device can encode mesh video to output a bitstream, which can be delivered to the receiving device via digital storage media or a network in the form of a file or streaming segment. The digital storage media may include various storage media, such as USB, SD, CD, DVD, Blu-ray, HDD, or SSD.

[0077] The transmitting device may roughly include a mesh video acquisition unit, a mesh video encoder, and a transmitting unit. The receiving device may roughly include a receiving unit, a mesh video decoder, and a renderer. The encoder may be referred to as a mesh video / video / picture / frame encoding device, and the decoder may be referred to as a mesh video / video / picture / frame decoding device. The transmitter may be included in the mesh video encoder. The receiver may be included in the mesh video decoder. The renderer may include a display unit, and the renderer and / or the display unit may be configured as separate devices or external components. The transmitting device and the receiving device may further include separate internal or external modules / units / components for a feedback process.

[0078] Mesh data represents the surface of an object as a number of polygons. Each polygon is defined by its vertices in 3D space and connection information that describes how those vertices are connected. It can also contain vertex properties such as vertex color and normal. Mapping information that allows the surface of the mesh to be mapped to a 2D planar area can also be included as a mesh property. The mapping is typically described as a set of parametric coordinates, called UV coordinates or texture coordinates, associated with the mesh vertices. Meshes contain 2D attribute maps, which can be used to store high-resolution attribute information such as textures, normals, and displacement.

[0079] The mesh video acquisition unit may include processing 3D object data acquired through a camera, etc. into a mesh data type with the properties described above through a series of processes and generating a video composed of such mesh data. The mesh video may have properties of the mesh, such as vertices, polygons, connection information between vertices, colors, normals, etc., that may change over time. A mesh video with properties and connection information that change over time can be expressed as a dynamic mesh video.

[0080] A mesh video encoder can encode an input mesh video into one or more video streams. A single video can include multiple frames, and a single frame can correspond to a still image / picture. In this document, a mesh video can include a mesh image / frame / picture, and the mesh video can be used interchangeably with the mesh image / frame / picture. A mesh video encoder can perform a Video-based Dynamic Mesh (V-Mesh) Compression procedure. A mesh video encoder can perform a series of procedures such as prediction, transformation, quantization, and entropy coding for compression and coding efficiency. The encoded data (encoded video / image information) can be output in the form of a bitstream.

[0081] The encapsulation processing unit (file / segment encapsulation module) can encapsulate encoded mesh video data and / or mesh video-related metadata in the form of a file, etc. Here, the mesh video-related metadata may be received from the metadata processing unit, etc. The metadata processing unit may be included in the mesh video encoder, or may be configured as a separate component / module. The encapsulation processing unit may encapsulate the corresponding data in a file format such as ISOBMFF, or process it in the form of other DASH segments, etc. The encapsulation processing unit may include mesh video-related metadata in the file format according to an embodiment. The mesh video metadata may be included in boxes at various levels in the ISOBMFF file format, for example, or may be included as data in a separate track within the file. According to an embodiment, the encapsulation processing unit may encapsulate mesh video-related metadata itself in a file.

[0082] The transmission processing unit can process encapsulated mesh video data for transmission according to the file format. The transmission processing unit can be included in the transmission unit, or can be configured as a separate component / module. The transmission processing unit can process mesh video data according to any transmission protocol. The processing for transmission can include processing for transmission through a broadcast network or processing for transmission through broadband. According to an embodiment, the transmission processing unit can receive not only mesh video data but also mesh video-related metadata from the metadata processing unit and process the same for transmission.

[0083] The transmission unit can transmit encoded video / image information or data output in the form of a bitstream to the receiving unit of a receiving device via a digital storage medium or network in the form of a file or streaming. The digital storage medium can include various storage media such as USB, SD, CD, DVD, Blu-ray, HDD, SSD, etc. The transmission unit can include an element for generating a media file via a predetermined file format and can include an element for transmission via a broadcasting / communication network. The receiving unit can extract the bitstream and transmit it to a decoding device.

[0084] The receiver can receive mesh video data transmitted by a mesh video transmission device. Depending on the transmission channel, the receiver can receive mesh video data via a broadcast network, via broadband, or via digital storage media.

[0085] The receiving processing unit can perform processing on the received mesh video data according to a transmission protocol. The receiving processing unit can be included in the receiving unit, or can be configured as a separate component / module. In response to the processing performed for transmission on the transmitting side, the receiving processing unit can perform the reverse process of the aforementioned transmitting processing unit. The receiving processing unit can transfer the acquired mesh video data to the decapsulation processing unit, and transfer the acquired mesh video-related metadata to a metadata parser. The mesh video-related metadata acquired by the receiving processing unit can be in the form of a signaling table.

[0086] A decapsulation processing unit (file / segment decapsulation module) can decapsulate mesh video data in file format received from a receiving processing unit. The decapsulation processing unit can decapsulate files according to ISOBMFF, etc., to obtain a mesh video bitstream or mesh video-related metadata (metadata bitstream). The obtained mesh video bitstream can be transmitted to a mesh video decoder, and the obtained mesh video-related metadata (metadata bitstream) can be transmitted to a metadata processing unit. The mesh video bitstream may include metadata (metadata bitstream). The metadata processing unit may be included in the mesh video decoder, or may be configured as a separate component / module. The mesh video-related metadata obtained by the decapsulation processing unit may be in the form of a box or track within a file format. If necessary, the decapsulation processing unit may receive metadata required for decapsulation from the metadata processing unit. Mesh video related metadata can be passed to a Mesh video decoder for use in the Mesh video decoding process, or passed to a renderer for use in the Mesh video rendering process.

[0087] A mesh video decoder can receive a bitstream and perform operations corresponding to those of a mesh video encoder to decode video / images. The decoded mesh video can be displayed via a display unit. Users can view all or part of the rendered result via a VR / AR display or a standard display.

[0088] The feedback process may include a process of transmitting various feedback information that may be acquired during the rendering / display process to the transmitter or to the decoder on the receiver. Interactivity may be provided in mesh video consumption through the feedback process. Depending on the embodiment, head orientation information, viewport information indicating the area that the user is currently viewing, etc. may be transmitted during the feedback process. Depending on the embodiment, the user may interact with things implemented in the VR / AR / MR / autonomous driving environment, in which case information related to the interaction may be transmitted to the transmitter or the service provider during the feedback process. Depending on the embodiment, the feedback process may not be performed.

[0089] Head orientation information can refer to information about the user's head position, angle, and movement. Based on this information, information about the area the user is currently viewing within the mesh video, i.e. viewport information, can be calculated.

[0090] Viewport information can be information about the area the user is currently viewing in the mesh video. This can be used to perform gaze analysis to determine how the user consumes the mesh video, which area of ​​the mesh video they are gazing at, and for how long. Gaze analysis can be performed on the receiving side and transmitted to the transmitting side through a feedback channel. Devices such as VR / AR / MR displays can extract the viewport area based on the user's head position / orientation, the vertical or horizontal FOV supported by the device, etc.

[0091] Depending on the embodiment, the aforementioned feedback information may not only be transmitted to the transmitter but may also be consumed by the receiver. That is, the aforementioned feedback information may be utilized to perform decoding, rendering, and other processes on the receiver. For example, head orientation information and / or viewport information may be utilized to preferentially decode and render only the mesh video for the area currently being viewed by the user.

[0092] This document relates to dynamic mesh video compression as described above. The method / embodiment disclosed in this document can be applied to the Video-based Dynamic Mesh Compression (V-Mesh) standard of the Moving Picture Experts Group (MPEG) or the next-generation video / image coding standard. Dynamic mesh video compression is a method for processing mesh connection information and properties that change over time, and it can perform lossy and lossless compression for various applications such as real-time communication, storage, free-view video, and AR / VR.

[0093] The dynamic mesh video compression method described below is based on MPEG's V-Mesh method.

[0094] In this document, picture / frame can generally mean a unit representing one video of a specific time period.

[0095] A pixel or pel can refer to the smallest unit that constitutes a picture (or image). Additionally, the term "sample" can be used as a counterpart to a pixel. A sample can generally represent a pixel or a pixel value, and can represent only the pixel / pixel value of the luma component, only the pixel / pixel value of the chroma component, or only the pixel / pixel value of the depth component.

[0096] A unit may represent a basic unit of image processing. A unit may include at least one of a specific region of a picture and information related to the region. In some cases, the term "unit" may be used interchangeably with terms such as "block" or "area." In general, an MxN block may include a set (or array) of samples (or sample array) or transform coefficients consisting of M columns and N rows.

[0097] The encoding process of Figure 2 is as follows.

[0098] Video-based dynamic mesh compression (V-Mesh) compression methods can provide a method for compressing dynamic mesh video data based on 2D video codecs such as HEVC and VVC. The V-Mesh compression process receives the following data as input and performs compression.

[0099] Input mesh: Contains the 3D coordinates (geometry) of the vertices that make up the mesh, normal information for each vertex, mapping information that maps the mesh surface to a 2D plane, and connection information between the vertices that make up the surface. The mesh surface can be expressed as triangles or more polygons, and connection information between the vertices that make up each surface is stored according to a set shape. The input mesh can be saved in the OBJ file format.

[0100] Attribute map: (Hereinafter, texture map is also used in the same meaning): Contains information about the properties (color, normal, displacement, etc.) of the mesh, and stores data in the form of a mapping of the surface of the mesh onto a 2D image. Mapping which part (surface or vertex) of the mesh each data of this attribute map corresponds to is based on the mapping information contained in the input mesh. Since the attribute map has data for each frame of the mesh video, it can also be expressed as an attribute map video (or attribute for short). The attribute map in the V-Mesh compression method mainly contains the color information of the mesh, and is saved in an image file format (PNG, BMP, etc.).

[0101] Material Library File: Contains information about the material properties used in a mesh, particularly information that links the input mesh to its corresponding attribute map. It is saved in the Wavefront Material Template Library (MTL) file format.

[0102] In the V-Mesh compression method, the following data and information can be generated through the compression process.

[0103] Base mesh: The input mesh is simplified (decimated) through a preprocessing process, and the objects of the input mesh are expressed using the minimum number of vertices determined by the user's standards.

[0104] Displacement: This is displacement information used to express the input mesh as similarly as possible to the base mesh, and is expressed in the form of 3D coordinates.

[0105] Atlas information: This is the metadata required to reconstruct a mesh using base mesh, displacement, and attribute map information. It can be created and utilized as sub-mesh units (such as patches) that make up the mesh.

[0106] Referring to FIGS. 3 to 7, a method for encoding mesh position information (vertex) is described, and referring to FIGS. 7-10, etc., a method for encoding attribute information (attribute map) by restoring mesh position information is described.

[0107] Figure 3 shows a V-MESH compression method according to embodiments.

[0108] Fig. 3 illustrates the encoding process of Fig. 2, and the encoding process may include a pre-processing process and an encoding process. The encoder of Fig. 2 may include a pre-processor (200) and an encoder (201) as in Fig. 3. The transmitting device of Fig. 2 may be broadly referred to as an encoder, and the dynamic mesh video encoder of Fig. 2 may be referred to as an encoder. The V-Mesh compression method may include a pre-processing (200) and an encoding (201) process as in Fig. 3. The pre-processor of Fig. 3 may be located in front of the encoder of Fig. 3. The pre-processor and the encoder of Fig. 3 may be referred to as a single encoder.

[0109] The preprocessor can receive a static dynamic mesh and / or an attribute map. The preprocessor can generate a base mesh and / or displacement through preprocessing. The preprocessor can receive feedback information from the encoder and generate the base mesh and / or displacement based on the feedback information.

[0110] The encoder can receive a base mesh, displacement mesh, static dynamic mesh, and / or attribute map. The encoder can encode mesh-related data to generate a compressed bitstream.

[0111] Figure 4 illustrates pre-processing of V-MESH compression according to embodiments.

[0112] Figure 4 shows the configuration and operation of the pre-processor of Figure 3.

[0113] Fig. 3 shows a process of performing preprocessing on an input mesh. The preprocessing process (200) can be broadly divided into four steps: 1) Group of Frame (GoF) generation, 2) Mesh Decimation, 3) UV parameterization, and 4) Fitting subdivision surface (300). The preprocessor (200) can receive an input mesh, generate a displacement and / or base mesh, and transmit the generated displacement and / or base mesh to the encoder (201). The preprocessor (200) can transmit GoF information related to GoF generation to the encoder (201).

[0114] Below, each step of Fig. 4 is described.

[0115] GoF Generation: This is the process of generating a reference structure for mesh data. If the number of vertices, number of texture coordinates, vertex connection information, and texture coordinate connection information of the mesh of the previous frame and the current mesh are all the same, the previous frame can be set as the reference frame. In other words, if only the vertex coordinate values ​​are different between the current input mesh and the reference input mesh, inter-frame encoding can be performed. Otherwise, the frame performs intra-frame encoding.

[0116] Mesh Decimation: This process simplifies the input mesh to create a simplified mesh, or base mesh. Vertices to be removed from the original mesh are selected based on user-defined criteria, and the selected vertices and the triangles connected to them can be removed.

[0117] In the process of performing mesh simplification (Mesh decimation), the input mesh (voxelized), target triangle ratio (TTR), and minimum triangle component (CCCount) information are passed as input, and the simplified mesh (decimated mesh) can be obtained as output. In this process, connected triangle components smaller than the set minimum triangle component (CCCount) can be removed.

[0118] UV parameterization: This is the process of mapping a 3D surface of a decimated mesh into a texture domain. Parameterization can be performed using the UVAtlas tool. This process generates mapping information, which indicates where each vertex of the decimated mesh can be mapped to on a 2D image. This mapping information is expressed and stored as texture coordinates, and through this process, the final base mesh is created.

[0119] OrthoAtlas technology generates texture coordinates using orthographic projection. OrthoAtlas technology sequentially generates patches and packs them. First, adjacent triangles are divided to generate Connected Components (CCs), and then the optimal CCs are merged using a cost function to generate patches. The cost function can measure the cost based on the degree of distortion that occurs when orthogonally projecting patches in each direction. By packing the patch that minimizes the cost function into the texture domain, the texture coordinates can be ultimately calculated. In the case of orthoAtlas technology, texture coordinates and texture connection information can be derived from the base mesh decoder without compressing them during the base mesh encoding process.

[0120] Fitting subdivision surface: This is the process of performing subdivision on a simplified mesh. The subdivision method can be a user-defined method, such as the mid-edge method. The fitting process ensures that the input mesh and the subdivision mesh are similar to each other.

[0121] This is the process of fitting a mesh that has undergone subdivision on a base mesh so that its surface resembles that of the input mesh. User-defined subdivision methods, such as the mid-edge method (Figure 5), the loop method, or the LS3 method, can be applied.

[0122] Figure 5 illustrates a mid-edge subdivision method according to embodiments.

[0123] Figure 5 illustrates the mid-edge method of the fitting subdivision surface described in Figure 4. Referring to Figure 5, an original mesh containing four vertices is subdivided to create a sub-mesh. A sub-mesh can be created by creating a new vertex midway between the edges between the vertices.

[0124] When a fitted subdivided mesh (hereinafter referred to as a fitted subdivided mesh) is generated, displacement is calculated using this result and a pre-compressed and decrypted base mesh (hereinafter referred to as a reconstructed base mesh). That is, the reconstructed base mesh is subdivided in the same way as the fitting subdivision surface. The difference in position of each vertex between this result and the fitted subdivided mesh is the displacement for each vertex. Since displacement represents a position difference in three-dimensional space, it is also expressed as a value in the (x, y, z) space of a Cartesian coordinate system. Depending on the user input parameters, the (x, y, z) coordinate values ​​can be converted to (normal, tangential, bi-tangential) coordinate values ​​of the local coordinate system.

[0125] Figure 6 shows a displacement generation process according to embodiments.

[0126] FIG. 6 illustrates in detail the displacement calculation method of the fitting subdivision surface (300) as described in FIG. 5.

[0127] An encoder and / or pre-processor according to embodiments may include 1) a subdivision unit, 2) a local coordinate system calculation unit, and 3) a displacement calculation unit. The subdivision unit may receive a reconstructed base mesh and generate a subdivided reconstructed base mesh. The local coordinate system calculation unit may receive a fitted subdivision mesh and a subdivided reconstructed base mesh, and transform a coordinate system of the mesh into a local coordinate system. The local coordinate system calculation operation may be optional. The displacement calculation unit may calculate a positional difference between the fitted subdivision mesh and the subdivided reconstructed base mesh. For example, a positional difference value between vertices of two input meshes may be generated. The vertex positional difference value becomes a displacement.

[0128] The method and device for transmitting point cloud data according to the embodiments can encode the point cloud as follows. The point cloud data (which may be referred to as a point cloud for short) according to the embodiments can refer to data including vertex coordinates and color information. The term "point cloud" includes mesh data, and in this document, point cloud and mesh data can be used interchangeably.

[0129] The V-Mesh compression (reconstruction) method according to the embodiments may include intra frame encoding (Fig. 6) and inter frame encoding (Fig. 7).

[0130] Based on the results of the GoF generation described above, intra-frame encoding or inter-frame encoding is performed. In the case of intra-encoding, the data to be compressed may be a base mesh, displacement, attribute map, etc. In the case of inter-encoding, the data to be compressed may be a displacement, attribute map, and a motion field between a reference base mesh and the current base mesh.

[0131] Figure 7 shows a V-DMC encoding process according to embodiments.

[0132] The encoding process of Fig. 7 details the encoding of Figs. 1 and 2.

[0133] The preprocessor can receive an input mesh and perform the preprocessing described above. The preprocessing can generate a base mesh and / or a fitted subdivided mesh. The quantizer can quantize the base mesh and / or the fitted subdivided mesh. The static mesh encoder can encode the static mesh. The static mesh encoder can generate a bitstream including the encoded base mesh. The motion encoder can encode a motion vector for the base mesh based on inter-frame motion estimation and motion compensation for inter-prediction. The atlas encoder can encode an atlas for the vertices of the base mesh. The encoded base mesh can be reconstructed and inversely quantized through a dequantizer. The displacement calculation unit can receive the reconstructed mesh and generate displacement, which is a position difference, based on the fitted subdivided mesh. The lifting transform can receive the displacement and generate lifting coefficients. A quantizer can quantize lifting coefficients. Depending on the encoding method, an image packing unit can pack an image based on the quantized lifting coefficients. A video encoder can encode the packed image. Depending on the encoding method, inter-prediction can be applied to the quantized lifting coefficients, and the predicted lifting coefficients can be encoded using an arithmetic encoding method. A mesh restoration unit restores a deformed mesh using the restored displacement and the restored base mesh. Displacement data is restored, and the deformed mesh is restored based on the restored displacement data and the restored base mesh and provided to an attribute transfer unit. The attribute transfer unit receives an input mesh and / or an input attribute map, and generates an attribute map based on the restored deformed mesh. A push-pull padding unit can pad data in the attribute map based on a push-pull method. A color space transformation unit can transform a space of a color component, which is an attribute. The video encoder can encode the attribute.A multiplexer can generate a bitstream by multiplexing compressed base meshes, compressed displacements, and compressed attributes.

[0134] Base Mesh Encoding: The base mesh compression method can be divided into INTRA type, INTER type, and SKIP type depending on the base mesh type, and encoding can be performed in different ways for each. If the base mesh is INTRA type, it can be encoded using the static mesh encoding method. If the base mesh is INTER type, the motion field between the reference base mesh and the current base mesh can be encoded. If the current base mesh is SKIP type, the reference base mesh can be derived as the current base mesh.

[0135] After encoding in the encoder, the decoded base mesh can be subdivided into a subdivided mesh through a subdivision process. Subdivision algorithms such as mid-point subdivision and loop subdivision can be used.

[0136] Static Basemesh Encoding (Intra Basemesh Encoding): When performing Intra encoding on the current basemesh, the base mesh generated in the preprocessing process can be encoded using static mesh compression technology after going through a quantization process. Static mesh compression applies MPEG EdgeBreaker (MEB) technology, and the vertex position information, mapping information (texture coordinates), vertex connection information, and normals of the base mesh are compressed.

[0137] Technology for compressing connection information can be encoded using the edgebreaker algorithm. The edgebreaker algorithm sequentially traverses triangles according to rules, mapping symbols based on the characteristics of each triangle, and then encoding the corresponding symbols.

[0138] A technique for compressing vertex position information can encode the residual value, which is the difference between the current vertex and the predicted value, after obtaining the predicted value based on a prediction technique such as multiple parallelogram prediction.

[0139] A technique for compressing mapping information (texture coordinates) can encode the residual value, which is the difference between the current mapping information (texture coordinates) and the predicted value, after obtaining the predicted value based on a prediction technique such as stretch.

[0140] Techniques for compressing normals can encode residual values, which are the differences between the current normal and the predicted values, after obtaining predicted values ​​based on prediction techniques such as delta coding, multiple parallelogram prediction, and cross product-based prediction.

[0141] Motion Field Encoding (Inter Basemesh Encoding): Inter Basemesh encoding can be performed when a one-to-one correspondence exists between the reference mesh and the current input mesh, and only the vertex position information differs. When performing Inter encoding, instead of compressing the base mesh, the difference between the vertices of the reference base mesh and the current base mesh, i.e. the motion field, can be calculated and this information can be encoded. The reference base mesh is the result of quantizing the already decoded base mesh data and is determined by the reference frame index.

[0142] The motion field can be encoded as is, or the predicted motion field can be calculated by averaging the motion fields of the reconstructed vertices among the vertices connected to the current vertex, and the residual motion field, which is the difference between the predicted motion field value and the motion field value of the current vertex, can be encoded. This value can be encoded using entropy coding.

[0143] Displacement Encoding: After encoding the base mesh, it is restored and dequantized to generate a Recon. The base mesh is then subdivided to calculate the displacement between the results and the fitted subdivided mesh. For effective encoding, a data transform process such as the Wavelet transform can be applied to the displacement information, and Figure 7 shows the process of transforming the displacement information using the Lifting transform in V-Mesh. The transform coefficients generated through the transform process are quantized, and the quantized transform coefficients can be compressed using a video codec or through arithmetic encoding, depending on the compression method.

[0144] When compressed through a video codec, it is packed into a 2D image as shown in Figure 8. The transform coefficients are organized into one block for each N^2(N*N) unit, and each block can be packed in z-scan order. The horizontal number of blocks is fixed to N, but the vertical number of blocks can be determined according to the number of vertices of the subdivided base mesh. Within one block, the transform coefficients can be packed by sorting them with Morton code. The packed images generate a displacement video for each GoF unit, and this displacement video can be encoded using an existing video compression codec.

[0145] When compressed through arithmetic coding, inter-frame prediction can be performed on the quantized displacement vector transform coefficients. When inter-frame prediction is performed on the current quantized displacement vector transform coefficients, the residual value, which is the difference between the current displacement vector transform coefficients and the reference displacement vector transform coefficients, can be encoded, and information about the reference target can be encoded. Depending on the displacement vector type, if it is an INTRA type, the quantized displacement vector transform coefficients can be arithmetic-coded, and if it is an INTER type, the residual value can be arithmetic-coded. Arithmetic coding can be performed based on Context Adaptive Binary Arithmetic Coding (CABAC). The CABAC process can first binarize the displacement vector data and map it to a bin string. The bin string can be a binarized output of 0 and 1, and each 0 or 1 can be a bin. Each bin can be arithmetic-coded using context information selected from a context model, and a process of updating the probability can be performed.

[0146] Figure 8 shows a lifting conversion process for displacement according to embodiments.

[0147] Figure 9 illustrates a process of packing transformation coefficients according to embodiments into a 2D image.

[0148] Figures 8-9 show the process of converting the displacement of the encoding process of Figure 7 and the process of packing the conversion coefficients, respectively.

[0149] The encoding method according to the embodiments includes displacement encoding.

[0150] After encoding the base mesh through base mesh encoding and / or motion field encoding, a reconstructed base mesh is generated through restoration and dequantization, and the displacement between the result of performing subdivision on the reconstructed base mesh and the fitted subdivided mesh generated through the fitting subdivision surface can be calculated. For effective encoding, a data transform process such as wavelet transform can be applied to the displacement information.

[0151] Fig. 8 shows the process of transforming displacement information using lifting transform in V-Mesh. The transform coefficients generated through the transform process are quantized and then packed into a 2D image as shown in Fig. 9. The transform coefficients are organized into one block for every 256 (=16X16) units, and each block can be packed in z-scan order. The horizontal number of blocks is fixed to 16, but the vertical number of blocks can be determined according to the number of vertices of the subdivided base mesh. The transform coefficients can be packed by sorting them with Morton code within a block. The packed images generate a displacement video for each GoF unit, and this displacement video can be encoded using an existing video compression codec.

[0152] Referring to FIG. 8, the base mesh (original) may include vertices and edges for LoD0. A first subdivision mesh generated by dividing the base mesh includes vertices generated by further dividing the edges of the base mesh. The first subdivision mesh includes vertices for LoD0 and vertices for LoD1. LoD1 includes the subdivided vertices and the vertices of the base mesh (LoD0). A second subdivision mesh may be generated by dividing the first subdivision mesh. The second subdivision mesh includes LoD2. LoD2 includes the base mesh vertices (LoD0), LoD1 including the vertices additionally generated from LoD0, and the vertices additionally divided from LoD1. LoD is a level indicating the degree of detail (Level of Detail), and as the level index increases, the distance between vertices becomes closer and the level of detail increases. LoD N includes the vertices included in the previous LoDN-1 as they are. When a vertex is further divided through subdivision, considering the previous vertices v1, v2 and the subdivided vertex v, the mesh can be encoded based on a prediction and / or update method. Instead of still encoding information about the current LoD N, a residual value between the previous LoD N-1 can be generated, and the mesh can be encoded using the residual value to reduce the size of the bitstream. The prediction process means the operation of predicting the current vertex v using the previous vertices v1, v2. Since adjacent subdivision meshes have similar data, efficient encoding can be achieved by utilizing this property. The current vertex position information is predicted as the residual for the previous vertex position information, and the previous vertex position information is updated using the residual.

[0153] Referring to Figure 9, the vertices have coefficients generated through the lifting transformation. The coefficients of the vertices related to the lifting transformation can be encoded by packing them into an image.

[0154] Fig. 10 shows an attribute transfer process of a V-MESH compression method according to embodiments.

[0155] Figure 10 shows the detailed operation of attribute transfer of the encoding of Figure 7.

[0156] Encoding according to embodiments includes attribute map encoding.

[0157] Information about the input mesh is compressed through base mesh encoding, motion field encoding, and displacement encoding. In the encoding process, the compressed input mesh is restored through base mesh decoding (intra frame), motion field decoding (inter frame), and displacement video decoding processes, and the restored result, the reconstructed deformed mesh (hereinafter referred to as Recon. deformed mesh), is used to compress the input attribute map as shown in FIGS. 6 and 7. The reconstructed deformed mesh (Recon. deformed mesh) has vertex position information, texture coordinates, and corresponding connection information, but does not have color information corresponding to the texture coordinates. Therefore, as shown in Fig. 10, in the V-Mesh compression method, a new attribute map having color information corresponding to the texture coordinates of the reconstructed deformed mesh is created through the attribute transfer process.

[0158] Attribute transfer first checks whether each point P(u, v) in the 2D texture domain belongs to a texture triangle of the reconstructed deformed mesh, and if it is in a texture triangle T, then the barycentric coordinate (α, α) of P(u, v) according to the triangle T is calculated. , γ) is calculated. And the 3D vertex positions of triangle T and (α, , γ) to compute the 3D coordinates M(x, y, z) of P(u, v). Find the vertex coordinates M'(x', y', z') and the triangle T' containing this point that corresponds to the most similar position to the computed M(x, y, z) in the input mesh domain. Then, in this triangle T', the center of mass coordinates (α', ', γ') are calculated. The texture coordinates corresponding to the three vertices of Triangle T' and (α', ', γ') is used to calculate the texture coordinates (u', v'), and the color information corresponding to these coordinates is found in the input attribute map. The color information found in this way is immediately assigned to the pixel location (u, v) of the new attribute map. If P(u, v) does not belong to any triangle, the pixel at that location in the new attribute map can be filled with a color value using a padding algorithm such as the push-pull algorithm.

[0159] The new attribute map generated through attribute transfer is grouped into GoF units to form an attribute map video, which is then compressed using a video codec.

[0160] Atlas Encoding: Atlas information may be transmitted during the aforementioned process. The Atlas consists of information required for mesh decoding and / or rendering, and may include information required for subdivision, displacement decoding, base mesh decoding, tile information, patch information, and other information. Atlas data may be encoded using methods such as Exp-Golomb coding.

[0161] Referring to Figure 10, the reference relationship between the input mesh, input attribute map, restored mesh, and generated attribute map can be seen.

[0162] The decoding process of Fig. 1 can perform the reverse process of the corresponding encoding process of Fig. 1. The specific decoding process is as follows.

[0163] Figure 11 illustrates a VV-DMC decoding process according to embodiments.

[0164] Fig. 11 shows the configuration and operation of a decoder of a receiving device such as Fig. 1.

[0165] The input bitstream can be separated into a basemesh sub-stream, a displacement sub-stream, an attribute map sub-stream, and an atlas sub-stream.

[0166] Atlas sub-streams can be decoded through Exp-Golomb coding, etc., and as a result, information necessary for decoding, such as tile information and patch information, can be obtained.

[0167] If the Basemesh sub-stream is of INTRA type according to the Basemesh type, it can be decoded through a static mesh decoder based on MEB (MPEG EdgeBreaker) technology, and as a result, the connection information, vertex geometry information, and vertex mapping information (texture coordinates) of the Basemesh can be restored.

[0168] When the texture parameterization method in the encoder is orthoAtlas, the decoder can derive mapping information (texture coordinates) and attribute information (texture) connection information using vertex coordinates. The process of deriving mapping information (texture coordinates) and connection information can generate mapping information (texture coordinates) and attribute information (texture) connection information by calculating the homography transform of each face and then projecting the vertices based on this.

[0169] If the Basemesh type is INTER, motion information can be decoded through entropy decoding and inverse prediction. The reconstructed motion information is combined with the reference Basemesh, which has already been reconstructed and stored in the buffer, to create a Reconstructed Quantized Basemesh for the current frame. The reconstructed Basemesh can then undergo an inverse quantization process.

[0170] If the displacement sub-stream is compressed through a video codec according to the compression method used in encoding, it is decoded into displacement video through the decoder of the video compression codec, and then the image unpacking process is performed.

[0171] When compressed through arithmetic coding, the displacement vector bitstream can decode the binarized syntax elements through arithmetic decoding, and a contextual probability model (CPM) can be adaptively determined according to each bin of the syntax elements, and the occurrence probability of the bin can be predicted through the CPM to perform arithmetic decoding. The binarized syntax elements can be decoded through inverse binarization. The quantized displacement vector transform coefficients can be derived from the decoded syntax elements. If the displacement information type is INTER, an inverse inter prediction process is performed using reference information for the quantized displacement coefficients (if inter prediction is performed).

[0172] The quantized displacement coefficient is restored as displacement information for each vertex through inverse quantization, inverse transform, and coordinate system transformation processes.

[0173] The restored base mesh and restored displacement information are combined to generate the final decoded mesh. The attribute map sub-stream is decoded through the decoder of the video compression codec used in encoding, and then restored to the final attribute map through processes such as color format conversion.

[0174] The restored Decoded mesh and Decoded attribute map can be utilized by the receiver as final mesh data that can be utilized by the user.

[0175] The atlas decoder decodes the atlas data within the bitstream.

[0176] The motion decoder derives the motion field of the base mesh of the current frame through motion estimation and compensation based on the base mesh in the reference frame, if the mesh data in the bitstream is encoded based on inter prediction. The spatial decoder decodes the base mesh, if the mesh data in the bitstream is encoded based on intra prediction. Depending on the encoding method, the displacement data is decoded by applying arithmetic encoding decoding or video decoding. The video decoder decodes the attribute data in the bitstream.

[0177] The decoding method of Fig. 11 can follow the reverse process of the encoding method according to the embodiments.

[0178] Figure 12 illustrates a V-DMC encoding process according to embodiments.

[0179] Fig. 12 illustrates the configuration and operation of the encoder of the transmitting device of Figs. 1 and 2. Each component of Fig. 12 corresponds to hardware, software, a processor, and / or a combination thereof.

[0180] Figure 12 shows the encoding process of V-Mesh technology.

[0181] The mesh preprocessing unit receives the original mesh as input and generates a simplified mesh (decimated mesh). Simplification can be performed based on the target number of vertices or the target number of polygons that constitute the mesh. Parameterization can be performed on the simplified mesh to generate mapping information (texture coordinates) and attribute information (texture) connection information per vertex. Additionally, quantization of floating-point mesh information into fixed-point information can be performed. This result can be encoded as a base mesh through a static mesh encoding unit. The mesh preprocessing unit can perform mesh subdivision on the base mesh to generate additional vertices. Depending on the subdivision method, vertex connection information, texture coordinates, and texture coordinate connection information including the added vertices can be generated. The subdivided mesh can be fitted by adjusting the vertex positions to resemble the original mesh, thereby generating a fitted subdivided mesh.

[0182] The base mesh generated through the mesh preprocessing unit can perform intra-encoding or inter-encoding depending on the base mesh type. If the base mesh frame performs intra-encoding, it can be compressed through the static mesh encoding unit. In this case, encoding can be performed on the connection information, vertex geometry information, vertex texture information, normal information, etc. of the base mesh. If the base mesh frame performs inter-encoding, a motion vector encoding unit is performed, which can use the base mesh and the reference reconstruction base mesh as input to calculate the motion vector between the two meshes and encode the value. The motion vector encoding unit can perform connection information-based prediction using the previously encoded / decoded motion vector as a predictor, and can encode the residual motion vector obtained by subtracting the predicted motion vector from the current motion vector. The base mesh bitstream generated through the base mesh encoding unit is transmitted to the multiplexing unit.

[0183] The encoded base mesh bitstream can generate a restored base mesh through a base mesh restoration unit.

[0184] The displacement vector calculation unit can perform mesh refinement on the restored base mesh. The displacement vector can be calculated as the difference in vertex positions between the refined restored base mesh and the fitted subdivision mesh generated in the preprocessing unit. As a result, the displacement vector can be calculated as many times as the number of vertices of the refined mesh. The displacement vector calculation unit can convert the displacement vector calculated in the 3D Cartesian coordinate system into a local coordinate system based on the normal vector of each vertex.

[0185] The displacement vector processing unit can transform the displacement vector for effective encoding. The transform can be performed by a lifting transform, a wavelet transform, etc. depending on the embodiment. In addition, quantization can be performed on the transformed displacement vector value, i.e., the transform coefficient. Different quantization parameters can be applied to each axis of the transform coefficient, and the quantization parameters can be derived according to the agreement of the encoder / decoder. The quantized displacement vector transform coefficients calculated by the displacement vector processing unit can be encoded through a displacement vector video encoding unit or a displacement vector arithmetic encoding unit depending on the compression method.

[0186] The displacement vector video encoding unit can pack displacement vector information that has undergone transformation and quantization into a 2D image. The packed 2D images can be bundled for each frame to generate a displacement vector video, and the displacement vector video can be generated for each GoF (Group of Frame) unit of the input mesh. The generated displacement vector video can be encoded using a video compression codec. The generated displacement vector video bitstream is transmitted to the multiplexing unit.

[0187] The displacement vector arithmetic encoding unit can perform inter-screen prediction on the quantized displacement vector transform coefficients if the displacement vector type is INTER. The inter-screen prediction process may be a process of obtaining a residual value, which is the difference between the current transform coefficient and the reference transform coefficient. The displacement vector transform coefficient or the residual value can be encoded through an arithmetic encoding process.

[0188] The displacement vector restored through the displacement vector restoration unit and the base mesh restored through the base mesh restoration unit and refined are restored through the mesh restoration unit, and the restored mesh has restored vertices, connection information between vertices, texture coordinates, and connection information between texture coordinates.

[0189] The attribute information (texture map) of the original mesh can be regenerated as attribute information (texture map) for the restored mesh through the attribute information (texture map) video generation unit. The color information per vertex of the texture map of the original mesh can be assigned to the texture coordinates of the restored mesh. The regenerated texture maps for each frame can be bundled by GoF unit to generate a texture map video.

[0190] The generated texture map video can be encoded using a video compression codec through a texture map video encoding unit. The texture map video bitstream generated through encoding is transmitted to a multiplexing unit.

[0191] The atlas encoding unit can encode atlases, which are additional information required for mesh decoding and rendering. The generated atlas bitstream is transmitted to the multiplexing unit.

[0192] The generated base mesh bitstream, displacement vector bitstream, texture map bitstream, and atlas bitstream can be multiplexed into a single bitstream and transmitted to a receiver via a transmitter. Alternatively, the generated base mesh bitstream, displacement vector bitstream, texture map bitstream, and atlas bitstream can be generated into a file with one or more track data or encapsulated into segments and transmitted to a receiver (decoder) via a transmitter.

[0193] The data input unit can receive an original mesh and / or an original texture map ('attribute'). The mesh preprocessing unit can simplify the original mesh to generate a base mesh and fit it to generate a refined mesh. The motion vector encoding unit can generate a motion vector (motion field) by referring to a reconstructed base mesh within a previously processed reference frame when the mesh encoding method is inter-prediction, and can encode it based on a motion estimation and compensation method. The static mesh encoding unit can encode the base mesh within the frame when the mesh encoding method is intra-prediction. The displacement vector calculation unit can calculate a displacement vector for a vertex from the fitted refined mesh based on the reconstructed base mesh. The displacement vector processing unit can process the displacement vector into a form suitable for encoding. Depending on the encoding method for the displacement vector, the displacement vector can be encoded based on a video method or an arithmetic encoding method. The displacement vector can be reconstructed and provided to the mesh restoration unit together with the reconstructed base mesh. Based on the restored mesh, the attribute (texture map) video generation unit can generate a video for encoding the texture map using the original mesh and the texture map for the original mesh. The attribute is encoded based on the video method. The atlas is encoded by the atlas encoding unit.

[0194] Figure 13 illustrates a V-DMC decoding process according to embodiments.

[0195] Fig. 13 corresponds to the decoders of Figs. 1 to 3. Each component of Fig. 13 corresponds to hardware, software, a processor, and / or a combination thereof.

[0196] The bitstream of the received Mesh is demultiplexed into a compressed base mesh bitstream, a displacement vector bitstream, an attribute information (texture map) bitstream, and an atlas bitstream after file / segment decapsulation.

[0197] If the current mesh has inter-frame encoding applied according to the frame header information, the motion vector decoding unit can perform decoding on the base mesh bitstream. The final motion vector can be reconstructed by adding the previously decoded motion vector to the residual motion vector decoded from the bitstream using the previously decoded motion vector as a predictor. The current base mesh can be reconstructed by adding the decoded motion vector to the reference base mesh.

[0198] If the current mesh has been encoded within the screen according to the frame header information, the base mesh bitstream can be used to restore the connection information, vertex geometry information, texture coordinates, normal information, etc. of the base mesh through the static mesh decoder.

[0199] The base mesh restoration unit can perform inverse quantization on the decoded base mesh to generate a restored base mesh.

[0200] Depending on the encoding codec type, the displacement vector bitstream may be decoded using a video codec and then subjected to a depacking process. If encoded using arithmetic coding, arithmetic decoding may be performed using a displacement vector arithmetic decoding unit. If inter-screen prediction is performed, the current displacement vector transform coefficient may be generated by adding a residual value to the reference displacement vector transform coefficient through inter-screen prediction.

[0201] The displacement vector restoration unit restores the displacement vector by inverse quantization and inverse transformation of the decoded displacement vector transform coefficients. If the restored displacement vector is a value in the local coordinate system, a process of inverse transformation to the Cartesian coordinate system can be performed.

[0202] The mesh restoration unit can generate additional vertices by performing subdivision on the restored base mesh. Subdivision can generate vertex connection information, texture coordinates, and texture coordinate connection information, including the added vertices. The subdivided restored base mesh can be combined with the restored displacement vector to generate the final restored mesh.

[0203] The texture map bitstream can be decoded as a video bitstream using a video codec in a texture map video decoding unit. The restored texture map contains color information for each vertex contained in the restored mesh, and the color value of each vertex can be obtained from the texture map using the texture coordinates of the corresponding vertex.

[0204] The atlas bitstream can be decrypted by the atlas decryptor.

[0205] The restored mesh and texture map are displayed to the user through a rendering process using a mesh data renderer, etc.

[0206] The decoder receives an encoded bitstream and decodes the base mesh, displacement vectors, attributes, and atlas within the bitstream based on parameter information (which may be referred to as signaling information, metadata, etc.) contained within the bitstream. The decoding process may follow the reverse process of the encoding process. Based on the decoded atlas, a mesh is reconstructed from the reconstructed base mesh and the reconstructed displacement mesh. The mesh can be rendered based on the reconstructed mesh and the reconstructed attributes.

[0207] A point cloud data encoding device and method according to embodiments can encode mesh data and transmit a bitstream including the encoded mesh data. A point cloud data decoding device and method according to embodiments can receive a bitstream including mesh data and decode the mesh data. The point cloud data encoding / decoding method / device according to embodiments may be referred to as the method / device according to embodiments. The point cloud data encoding / decoding method / device according to embodiments may also be referred to as the mesh data encoding / decoding method / device according to embodiments. In addition, the term encoding / decoding method / device may be used in this document for short.

[0208] The encoding method and device according to the embodiments may include and perform a transmitting device (100) of FIG. 1, a mesh encoder (102), a file / segment encapsulator (103), a transmitter (104), a pre-processor of FIG. 2, FIG. 3, FIG. 4, FIG. 6, and FIG. 7, an encoder, an encoder of FIG. 12, bitstream and syntax generation of FIG. 14 to FIG. 15, encoding of FIG. 18 to FIG. 22, syntax generation of FIG. 28a and FIG. 28b to FIG. 44a, FIG. 44b, and FIG. 44c, and an encoding method of FIG. 45.

[0209] The decryption method / device according to the embodiments may include and perform the receiving device (110) of FIG. 1, the receiving unit (111), the file / segment decapsulator (112), the mesh decoder (113), the renderer (114), the decoder of FIG. 11 and FIG. 13, the bitstream and syntax parsing of FIG. 14 to FIG. 15, the decoding of FIG. 16 to FIG. 17, the decoding of FIG. 23 to FIG. 27, the syntax acquisition of FIG. 28a and FIG. 28b to FIG. 44a, FIG. 44b and FIG. 44c, and the decryption method of FIG. 46.

[0210] The method and apparatus according to the embodiments may include and perform an atlas decoding method for displacement vector data of a dynamic mesh.

[0211] The embodiments relate to V-DMC (Video-based Dynamic Mesh Compression), a method for compressing three-dimensional dynamic mesh data using a 2D video codec. Atlas data of V-DMC includes information necessary for the process of performing decoding and restoration. The embodiments include a method for omitting atlas syntax related to displacement vector data depending on the presence or absence of displacement vector data in the atlas data. If the displacement vector data does not exist, unnecessary information related to the displacement vector data can be omitted, thereby reducing the bit rate of the atlas data.

[0212] The embodiments relate to V-DMC, a method for compressing 3D dynamic mesh data using a 2D video codec, and include a method for omitting atlas syntax related to displacement vector data among atlas data of a dynamic mesh depending on the presence or absence of displacement vector data, and syntax and semantics information related thereto.

[0213] Recently, V-DMC technology is in the CD stage as of July 2024, and active standardization is in progress. In the current V-DMC standard, displacement vector data does not exist in situations such as lossless compression or when segmentation is not performed. However, even when displacement vector data does not exist in the process of configuring atlas data, which is information required for the dynamic mesh compression process, information related to displacement vector data is compressed. Embodiments include a method for omitting atlas syntax related to displacement vector data by considering the presence or absence of displacement vector data, and syntax and semantics information. Embodiments can reduce the atlas data bit rate when displacement vector data does not exist.

[0214] Embodiments can reduce the amount of atlas data by omitting atlas syntax associated with displacement vector data when displacement vector data does not exist.

[0215] Figure 14 shows a bitstream according to embodiments.

[0216] The encoding method / device according to the embodiments can encode mesh data and generate parameter information (which can be referred to as signaling information, syntax elements, etc.) regarding the mesh data, thereby generating a bitstream as in Fig. 14. The decoding method / device according to the embodiments can receive a bitstream as in Fig. 14 and decode the mesh data based on syntax elements in the bitstream.

[0217] The term V-DMC can also be referred to as V-Mesh, and the two terms are used interchangeably. Dynamic mesh content can be encoded with a bitstream structure as shown in Figure 14. The bitstream can be generated based on the sample stream data unit used when encoding V3C content in the V3C codec specification (ISO / IEC 23090-5).

[0218] The definitions of abbreviations referring to data included in the bitstream are as follows: VPS: V3C / V-DMC Parameter Set, AD: Atlas Data, BMD: Base Mesh Data, DD: Displacement Data (Displacement data may be encoded with arithmetic coding), GVD: Geometry Video Data (Displacement data may be encoded based on a video codec), AVD: Attribute Video Data (Attribute data may be encoded based on video coding), PVD: Packing Video Data (Packing data may be encoded based on video coding), CAD: Common Atlas Data, OVD: Accuracy Video Data, ADD: Arithmetic Coded Displacement Data.

[0219] Figure 15 shows the payload of the V3C unit according to embodiments.

[0220] The bitstream of Fig. 14 may include a V3C unit as in Fig. 15. The payload of the V3C unit may indicate that the payload includes a parameter set or sub-bitstream regarding the data type indicated by the type of the V3C unit.

[0221] Figure 16 shows a mesh patch data decryption process according to embodiments.

[0222] The decoding method / device according to the embodiments (receiving device (110) of FIG. 1, receiving unit (111), file / segment decapsulator (112), mesh decoder (113), renderer (114), decoder of FIG. 11, FIG. 13, bitstream and syntax parsing of FIG. 14 to FIG. 15, decoding of FIG. 17, decoding of FIG. 23 to FIG. 27, syntax acquisition of FIG. 28a and FIG. 28b to FIG. 44a, FIG. 44b and FIG. 44c, decoding method of FIG. 46, etc.) can decode mesh patch data as shown in FIG. 16.

[0223] A meshpatch according to embodiments may refer to an atlas element associated with basemesh information. Meshpatch data according to embodiments may refer to atlas data associated with a meshpatch that can transform a basemesh into a reconstructed mesh.

[0224] Referring to FIG. 16, a decoding process is described. For example, an atlas data decoding process is described. The decoding process according to embodiments may be combined with the technology of V-DMC standard document 23090-29 Video-based mesh coding. The atlas data decoding process is an atlas data decoding process defined in 23090-29 Video-based mesh coding, and may include a process of decoding atlas data considering the presence of a displacement vector. The atlas data decoding process and related sections according to the embodiments below may refer to the standard document V-DMC CD v1.0-.

[0225] The atlas data decoding process can take an atlas sub-bitstream as input and be a process of decoding atlas data.

[0226] Atlas data may refer to data required in processes such as mesh decoding and mesh restoration, and may include segmentation methods, transformation methods, quantization methods, and the location and size of patches within the atlas frame.

[0227] The atlas data decoding process may include a step of decoding a meshpatch data unit, and the step of decoding the meshpatch data unit may have as inputs atdu_meshpatch_mode[tileID][p], which is a current mesh patch mode, when the current patch index is p, the current tile ID is tileID. The output may be parameters related to the meshpatch whose current patch index is p, and may be 2D position information, etc., depending on the embodiment, and the 2D position information may be a bounding box position (upper left x and y coordinates) and a bounding box size (width and height) of the meshpatch. The 2D position information may be determined differently depending on geometric information and / or attribute information. Parameters related to a mesh patch may be parameters used in a texture coordinate derivation process, a sub-mesh ID corresponding to the mesh patch, a displacement vector ID corresponding to the mesh patch, a number of vertices, a number of faces, a subdivision method, a number of subdivisions, a displacement vector coordinate system, a displacement vector data conversion method, a displacement vector quantization method, etc., depending on the embodiment.

[0228] The mesh patch type can be configured as I_INTRA, P_INTRA, P_SKIP, P_MERGE, P_INTER, etc. depending on the mesh patch encoding method, and the mesh patch decoding method can be performed differently depending on the mesh patch type.

[0229] Figure 16 may be a mesh patch data decoding process. Depending on the mesh patch type, an intra type mesh patch may be decoded. In the case of decoding using reference information such as inter, merge, or skip types, a reference mesh patch may be derived using the reference information, and the current mesh patch may be derived using the reference mesh patch.

[0230] Intra type mesh patch decoding unit:

[0231] When the mesh patch type is Intra (Decoding process for mesh patch data units coded in intra mode), the decoding process can receive the current patch index p and the current tile ID tileID as input. The syntax of the mesh patch data unit can be parsed to determine the mesh patch parameters.

[0232] Atlas data may contain information related to texture maps, information related to displacement vector data, etc., and information related to displacement vector data may be omitted depending on the presence or absence of displacement vectors.

[0233] The displacement_present_flag is a flag that indicates whether displacement vector data exists. If displacement vector data does not exist, it can be set to 0, and if it exists, it can be set to 1. Through this flag, if the flag is 0, atlas data related to displacement vector data can be omitted.

[0234] According to the displacement_present_flag indicating the presence of displacement vector data, if the flag is 0, i.e., if the displacement vector data does not exist, the process of decoding mesh patch data related to the displacement vector can be omitted, and if it is 1, the mesh patch data related to the displacement vector can be decoded. Depending on the embodiment, the process of decoding atlas parameters such as a subdivision method, a displacement vector coordinate system, and a displacement vector transformation method, which are mesh patch parameters related to the displacement vector data, can be omitted.

[0235] Skip type mesh patch decoding unit:

[0236] When the mesh patch type is Skip (Decoding process for mesh patch data units coded in skip prediction mode), the decoding process can receive the current patch index p and the current tile ID tileID as input. The mesh patch data of the skip type can be determined using the reference mesh patch.

[0237] According to the displacement_present_flag indicating whether displacement vector data exists, if the flag is 0, i.e., if displacement vector data does not exist, the process of deriving mesh patch data related to the displacement vector using reference mesh patch information can be omitted, and if it is 1, mesh patch data related to the displacement vector can be derived using reference mesh patch information.

[0238] Merge type mesh patch decoding unit:

[0239] When the mesh patch type is Merge (Decoding process for meshpatch data units coded in merge prediction mode), the decoding process can receive the current patch index p and the current tile ID tileID as input.

[0240] According to the displacement_present_flag indicating the presence of displacement vector data, if the flag is 0, i.e., if the displacement vector data does not exist, the process of decoding mesh patch data related to the displacement vector can be omitted, and if it is 1, the mesh patch data related to the displacement vector can be decoded. Depending on the embodiment, the process of decoding atlas parameters such as a subdivision method, a displacement vector coordinate system, and a displacement vector transformation method, which are mesh patch parameters related to the displacement vector data, can be omitted.

[0241] Inter type mesh patch decoding unit:

[0242] When the mesh patch type is Inter (Decoding process for mesh patch data units coded in inter prediction mode), the decoding process can receive the current patch index p and the current tile ID tileID as input. Some mesh patch parameters can be determined using the reference mesh patch.

[0243] In the case of an Inter mesh patch type, the 2D position information of geometric information and attribute information can be derived by parsing the difference between the position information of the current mesh patch and the reference mesh patch and adding the difference value with the reference mesh patch.

[0244] In an embodiment, when decoding the x and y coordinates of the upper left position of the mesh patch bounding box among the 2D position information, the difference between the coordinates of the current mesh patch and the reference mesh patch is parsed, and then the difference is multiplied by PatchPackingBlockSize and added to the coordinates of the reference mesh patch, thereby deriving the upper left position coordinates of the current mesh patch.

[0245] In an embodiment, when decoding the width and height of a mesh patch bounding box among 2D position information, the width and height of the current mesh patch can be derived by parsing the difference between the width and height of the current mesh patch and the reference mesh patch, multiplying this by PatchSizeXQuantizer and PatchSizeYQuantizer, and adding it to the width and height of the reference mesh patch.

[0246] According to the displacement_present_flag indicating the presence of displacement vector data, if the flag is 0, i.e., if the displacement vector data does not exist, the process of decoding mesh patch data related to the displacement vector can be omitted, and if it is 1, the mesh patch data related to the displacement vector can be decoded. Depending on the embodiment, the process of decoding atlas parameters such as a subdivision method, a displacement vector coordinate system, and a displacement vector transformation method, which are mesh patch parameters related to the displacement vector data, can be omitted.

[0247] Reference mesh patch induction section:

[0248] The Derivation of inter reference patch parameters process is a process for deriving mesh patch data to be referenced when the mesh patch type is inter, merge, etc., and takes as input the atlas frame reference index refIdx, the patch reference index refPatchIdx, and the current tile ID tileID, and the output can be reference mesh patch 2D position information (upper left X and Y coordinates of the bounding box, bounding box width and height, submesh ID, displacement ID, number of vertices, number of faces, subdivision method, number of subdivisions, displacement vector coordinate system, transformation method, attribute 2D position information (upper left X and Y coordinates of the attribute, width and height of the attribute 2D patch)).

[0249] According to the displacement_present_flag indicating whether displacement vector data exists, if the flag is 0, i.e., if displacement vector data does not exist, the process of deriving reference mesh patch parameters related to the displacement vector may be omitted, and if it is 1, the process of deriving reference mesh patch parameters related to the displacement vector may be performed.

[0250] Referring to FIG. 16, a mesh patch data decoding method according to embodiments determines whether the mesh patch type is Intra, and if it is Intra, decoding is performed through an Intra type mesh patch decoding unit, and if it is not Intra, the mesh patch type is determined as one of Inter, Merge, and Skip through a reference mesh patch derivation unit, and then decoding is performed in the corresponding mesh patch decoding unit according to the determined type, and when all decoding processes are completed, the procedure is terminated.

[0251] Figure 17 illustrates an atlas data decoding process depending on the presence or absence of a displacement vector according to embodiments.

[0252] Fig. 17 is an example of an atlas mesh patch data decoding process according to the presence or absence of a displacement vector. Data excluding syntax related to displacement vector data among atlas information can be decoded first, and the syntax to be decoded first can be attribute 2D packing information, sub-mesh ID, texture coordinate derivation information, etc. After that, displacement_present_flag indicating the presence or absence of displacement vector data is parsed, and if the flag is 0, the displacement vector data does not exist, so the process of decoding the syntax related to the displacement vector data can be omitted, and if it is 1, the syntax related to the displacement vector data can be decoded.

[0253] Referring to Fig. 17, the atlas data decoding process according to the embodiments first decodes mesh patch data other than displacement vector data. Then, it is determined whether the displacement_present_flag value is 1. If the value is 1, mesh patch data related to displacement vectors is additionally decoded. If the displacement_present_flag value is not 1, the decoding process is immediately terminated.

[0254] The atlas data decoding process of the method and device according to the embodiments is as follows.

[0255] General atlas decoding process:

[0256] For example, the specification in ISO / IEC 23090-5(2E):2023 subclause 9.2.1 may apply.

[0257] Decoding process of coded atlas frames:

[0258] For example, the specification in ISO / IEC 23090-5(2E):2023 subclause 9.2.2 may be applied with the following additions:

[0259] The process in subsection 9.2.8 specifies the mesh patch decoding process according to the patch mode as follows.

[0260] - Decoding of intra-coded mesh patches is specified in subsection 9.2.8.2.

[0261] - Decoding of mesh patches coded in skip mode is specified in subsection 9.2.8.4.

[0262] - Decoding of mesh patches coded in merge mode is specified in subsection 9.2.8.5.

[0263] - Decoding of intercoded mesh patches is specified in subclause 9.2.8.6.

[0264] The Atlas NAL unit decoding process is as follows:

[0265] The specifications in ISO / IEC 23090-5(2E):2023 subclause 9.2.3 apply with the following additions:

[0266] The Atlas tile header decoding process is as follows:

[0267] Atlas frame order count derivation process:

[0268] The specifications in ISO / IEC 23090-5(2E):2023 subclause 9.2.4.1 apply.

[0269] The decoding process for generating an unavailable reference atlas frame is as follows:

[0270] common:

[0271] The specifications in ISO / IEC 23090-5(2E):2023 subclause 9.2.4.2.1 apply.

[0272] Create one unusable atlas frame:

[0273] When this process is called, an unusable atlas frame is created as follows:

[0274] - The following applies to all tiles associated with this atlas frame:

[0275] for( t = 0; t<= afti_num_tiles_in_atlas_frame_minus1; t++ ) {

[0276] tileID = TileIndexToID( t )

[0277] AtduTotalNumMeshpatches[ tileID ] = MaxNumMeshpatches for( p = 0; p<= AtduTotalNumMeshpatches[ tileID ]; p++ ) {

[0278] TileMeshpatch2dPosX[tileID][p] = 0

[0279] TileMeshpatch2dPosY[ tileID ][ p ] = 0

[0280] TileMeshpatch2dSizeX[ tileID ][ p ] = 1

[0281] TileMeshpatch2dSizeY[ tileID ][ p ] = 1

[0282] for( attrIdx = 0; attrIdx < asve_num_attribute_video; attrIdx){

[0283] TileMeshpatchAttributes2dPosX[ tileID ][ p ][ attrIdx ] = 0

[0284] TileMeshpatchAttributes2dPosY[ tileID ][ p ][ attrIdx ] = 0

[0285] TileMeshpatchAttributes2dSizeX[ tileID ][ p ][ attrIdx ] = 1

[0286] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ attrIdx ] = 1

[0287] }

[0288] TileMeshpatchSubmeshID[ tileID ][ p ] = 0

[0289] TileMeshpatchDisplID[ tileID ][ p ] = 0

[0290] TileMeshpatchVertexCount[ tileID ][ p ] = 0

[0291] TileMeshpatchFaceCount[ tileID ][ p ] = 0

[0292]

[0293] TileMeshpatchSubdivMethod[ tileID ][ p ] = 0

[0294] TileMeshpatchSubdivCount[tileID][p] = 0

[0295] TileMeshpatchDispCoordSys[tileID][p] = 0

[0296] TileMeshpatchTransformMethod[tileID][p] = 0

[0297]

[0298] TileMeshpatchFrameScale[tileID][p] = 1

[0299] TileMeshpatchNumSubpatches[tileID][p] = 0

[0300] }

[0301] }

[0302] The process for generating a reference atlas frame list is as follows:

[0303] The specifications in ISO / IEC 23090-5(2E):2023 subclause 9.2.4.3 apply.

[0304] Reference atlas frame display process:

[0305] The specifications in ISO / IEC 23090-5(2E):2023 subclause 9.2.4.4 apply.

[0306] Patch data unit decoding process:

[0307] The specifications in ISO / IEC 23090-5(2E):2023 subclause 9.2.5 apply.

[0308] Block-patch map decoding process:

[0309] The specifications in ISO / IEC 23090-5(2E):2023 subclause 9.2.6 apply.

[0310] Convert 9-tile level patch information to atlas level patch information:

[0311] The specifications in ISO / IEC 23090-5(2E):2023 subclause 9.2.7 apply.

[0312] Decoding process of mesh patch data units:

[0313] General decoding process for a meshpatch data unit:

[0314] The inputs to this process are the current patch index p of the current tile whose tile ID is tileID and the current meshpatch mode atdu_meshpatch_mode[ tileID ][ p ].

[0315] The output of this process is several parameters associated with the current mesh patch with patch index p, including 2D and its 3D position information.

[0316] More specifically, the following variables are derived:

[0317] The variables horLimit and verLimit are calculated as follows:

[0318] horLimit = TileWidth[ TileIDToIndex[ tileID ] ]

[0319] verLimit = TileHeight[ TileIDToIndex[ tileID ] ]

[0320] TileMeshpatch2dPosX[ tileID ][ p ] specifies the x-coordinate of the upper-left corner of the mesh patch bounding box for the current mesh patch with patch index p of the current tile. The x-coordinate is relative to the upper-left corner of the current tile, with tile ID equal to tileID. It is expressed in atlas sample units. The value of TileMeshpatch2dPosX[ tileID ][ p ] ranges from 0 to horLimit - 1.

[0321] TileMeshpatch2dPosY[ tileID ][ p ] specifies the y-coordinate of the upper-left corner of the mesh patch bounding box for the current mesh patch with patch index p of the current tile. The y-coordinate is relative to the upper-left corner of the current tile, with tile ID equal to tileID. It is expressed in atlas sample units. The value of TileMeshpatch2dPosY[ tileID ][ p ] ranges from 0 to verLimit - 1.

[0322] TileMeshpatch2dSizeX[ tileID ][ p ] specifies the bounding box width, in atlas sample units, of the current mesh patch with patch index p of the current tile. The value of TileMeshpatch2dSizeX[ tileID ][ p ] ranges from 1 to horLimit.

[0323] TileMeshpatch2dSizeY[ tileID ][ p ] specifies the bounding box height, in atlas sample units, of the current mesh patch with patch index p of the current tile. The value of TileMeshpatch2dSizeY[ tileID ][ p ] ranges from 1 to verLimit.

[0324] If asve_num_attribute_video is greater than 0, the following additional variables are defined:

[0325] Calculate the horLimitAtt[attrIdx] and verLimitAtt[attrIdx] variables for the attrIdxth attribute as follows:

[0326] In AFATI and AFTI, we assume that the number of tiles and their corresponding IDs are the same. TileIDAttr is the same as tileID.

[0327] horLimitAtt[attrIdx] =

[0328] TileWidthAtt[attrIdx][TileIDToIndexAtt[attrIdx][tileIDAttr] ]

[0329] verLimit[attrIdx] =

[0330] TileHeightAtt[attrIdx][TileIDToIndexAtt[attrIdx][tileIDAttr] ]

[0331] TileMeshpatchAttributes2dPosX[ tileID ][ p ][ attrIdx ] specifies the x-coordinate of the upper-left corner of the attribute frame associated with the current mesh patch with patch index p in the current tile. This value is specified in atlas sample units for the attribute signaled in the attribute video data unit with index attrIdx . The value of TileMeshpatchAttributes2dPosX[ tileID ][ p ][ attrIdx ] ranges from 0 to horLimitAtt[ attrIdx ] - 1.

[0332] TileMeshpatchAttributes2dPosY[ tileID ][ p ][ attrIdx ] specifies the y-coordinate of the upper-left corner of the attribute frame associated with the current mesh patch with patch index p in the current tile. This value is for the attribute signaled in the attribute video data unit with index attrIdx (in atlas samples). The value of TileMeshpatchAttributes2dPosY[ tileID ][ p ][ attrIdx ] is in the range 0 to verLimitAtt[ attrIdx ] - 1, inclusive.

[0333] TileMeshpatchAttributes2dSizeX[ tileID ][ p ][ attrIdx ] specifies the width of the attribute frame of the current mesh patch with patch index p in the current tile (the current tile with tile ID equal to tileID). This value is for the attribute signaled in the attribute video data unit with index attrIdx (in atlas samples). The value of TileMeshpatchAttributes2dSizeX[ tileID ][ p ] is in the range 1 to horLimitAtt[ attrIdx ], inclusive.

[0334] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ attrIdx ] specifies the attribute frame height of the current mesh patch with patch index p in the current tile. The attribute frame is specified in atlas sample units for the attribute signaled in the attribute video data unit whose tile ID is equal to tileID and whose index is attrIdx. The value of TileMeshpatchAttributes2dSizeY[ tileID ][ p ] is in the range 1 to verLimitAtt[ attrIdx ], inclusive.

[0335] The following conditions apply for bitstream conformance:

[0336] if(! displacement_id_present_flag){

[0337] TileMeshpatch2dPosX[ tileID ][ p ] + TileMeshpatch2dSizeX[ tileID ][ p ] <=

[0338] horLimit (1)

[0339] TileMeshpatch2dPosY[ tileID ][ p ] + TileMeshpatch2dSizeY[ tileID ][ p ] <=

[0340] verLimit (2)

[0341] }

[0342] for( attrIdx = 0; attrIdx < asve_num_attribute_video; attrIdx){

[0343] TileMeshpatchAttributes2dPosX[ tileID ][ p ] +

[0344] TileMeshpatchAttributes2dSizeX[ tileID ][ p ] <= horLimitAtt[ attrIdx ]

[0345] TileMeshpatchAttributes2dPosY[ tileID ][ p ] +

[0346] TileMeshpatchAttributes2dSizeY[ tileID ][ p ] <= verLimitAtt[ attrIdx ]

[0347] }

[0348] Additional meshpatch related variables are derived.

[0349] TileMeshpatchTexcoordProjectionFlag[ tileID ][ p ] specifies that the texture coordinates of the meshpatch are derived using a geometry projection.

[0350] TileMeshpatchTexcoordProjectionWidthNormalization[ tileID ][ p ] specifies the width of the projection surface used to derive texture coordinates.

[0351] TileMeshpatchTexcoordProjectionHeightNormalization[ tileID ][ p ] specifies the height of the projection surface used to derive texture coordinates.

[0352] TileMeshpatchTexcoordProjectionGutter[ tileID ][ p ] specifies the gutter used for texture coordinate derivation.

[0353] TileMeshpatchSubMeshID[ tileID ][ p ] specifies the ID of the submesh for the current meshpatch with patch index p whose tile ID is equal to tileID in the current tile. The value of TileMeshpatchSubMeshID[ tileID ][ p ] must be one of afmi_submesh_id[ i ], where i is in the range 0 to 65535.

[0354] TileMeshpatchDisplID[ tileID ][ p ] specifies the displacement ID of the current mesh patch with patch index p in the current tile. The tile ID is equal to tileID.

[0355] TileMeshpatchVertexCount[ tileID ][ p ] specifies the number of vertices in the current mesh patch with patch index p in the current tile. The tile ID is equal to tileID.

[0356] TileMeshpatchFaceCount[ tileID ][ p ] specifies the number of faces in the current mesh patch with patch index p in the current tile. The tile ID is equal to tileID.

[0357] TileMeshpatchSubdivMethod[ tileID ][ p ][ i ] specifies the subdividing method for the current mesh patch with patch index p in the current tile. This tile ID is equal to tileID and the subdividing index is equal to i.

[0358] TileMeshpatchSubdivMethod[ tileID ][ p ] specifies the subdivision method for the current mesh patch with patch index p in the current tile, where p is the tile ID.

[0359] TileMeshpatchSubdivCount[ tileID ][ p ] specifies the number of subdivs of the current mesh patch with patch index p in the current tile with tile ID tileID.

[0360] TileMeshpatchDispCoordSys[ tileID ][ p ] specifies the displacement coordinate system of the current mesh patch with patch index p in the current tile with tile ID tileID.

[0361] TileMeshpatchTransformMethod[ tileID ][ p ] specifies the transformation method for the current mesh patch with patch index p in the current tile with tile ID tileID.

[0362] If afve_projection_texcoord_present_flag[ SubMeshIDToIndex[ TileMeshpatchSubMeshID[ tileID ][ p ] ] ] is 1, an additional variable is derived.

[0363] TileMeshpatchFrameScale[ tileID ][ p ] specifies the frame scale of the current mesh patch with patch index p in the current tile, where tileID is equal to tileID.

[0364] TileMeshpatchNumSubpatches[ tileID ][ p ] specifies the number of subpatches of the current mesh patch with patch index p in the current tile. The tile ID is equal to tileID.

[0365] TileMeshpatchSubpatchFaceId[ tileID ][ p ][ i ] specifies the face ID of the subpatch of the current mesh patch with patch index p in the current tile. The tile ID is equal to tileID.

[0366] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ] specifies the projection ID for the subpatch with index i of the current mesh patch with patch index p in the current tile with tile ID tileID.

[0367] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ] specifies the orientation ID for the subpatch with index i of the current mesh patch with patch index p in the current tile with tile ID tileID.

[0368] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ i ] specifies the x-coordinate of the upper-left corner of the subpatch with index i of the current mesh patch with patch index p in the current tile with tile ID tileID.

[0369] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ] specifies the y-coordinate of the upper-left corner of the subpatch with index i of the current mesh patch with patch index p in the current tile with tile ID tileID.

[0370] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] specifies the width of the subpatch with index i of the current mesh patch with patch index p in the current tile with tile ID tileID.

[0371] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] specifies the height for the subpatch with index i of the current mesh patch with patch index p in the current tile with tile ID tileID.

[0372] TileMeshpatchSubpatchScale[ tileID ][ p ][ i ] specifies the scale of the subpatch with index i of the current mesh patch with patch index p in the tile whose current tile ID is tileID.

[0373] These variables are initially set as follows:

[0374] TileMeshpatch2dPosX[tileID][p] = 0

[0375] TileMeshpatch2dPosY[tileID][p] = 0

[0376] TileMeshpatch2dSizeX[tileID][p] = 1

[0377] TileMeshpatch2dSizeY[tileID][p] = 1

[0378] for( attrIdx = 0; attrIdx < asve_num_attribute_video; attrIdx){

[0379] TileMeshpatchAttributes2dPosX[tileID][p] = 0

[0380] TileMeshpatchAttributes2dPosY[tileID][p] = 0

[0381] TileMeshpatchAttributes2dSizeX[tileID][p] = 1

[0382] TileMeshpatchAttributes2dSizeY[tileID][p] = 1

[0383] }

[0384] TileMeshpatchSubmeshID[tileID][p] = 0

[0385] TileMeshpatchDisplID[tileID][p] = 0

[0386] TileMeshpatchVertexCount[tileID][p] = 0

[0387] TileMeshpatchFaceCount[tileID][p] = 0

[0388] TileMeshpatchSubdivCount[tileID][p] = 0

[0389] TileMeshpatchDispCoordSys[tileID][p] = 0

[0390] TileMeshpatchTransformMethod[tileID][p] = 0

[0391] TileMeshpatchFrameScale[tileID][p] = 1

[0392] TileMeshpatchNumSubpatches[tileID][p] = 0

[0393] If atdu_meshpatch_mode[ tileID ][ p ] equals I_INTRA or P_INTRA, the process for decoding intra-coded mesh patches in subclause 9.2.8.2 is used, with p and tileID as input to that process and the output of that process as output.

[0394] If atdu_meshpatch_mode[ tileID ][ p ] equals P_SKIP, the process for decoding skip-coded mesh patches in subclause 9.2.8.4 is used, with p and tileID as inputs to that process and the output of that process as output.

[0395] If atdu_meshpatch_mode[ tileID ][ p ] equals P_MERGE, the process for decoding merge-coded mesh patches in subsection 9.2.8.5 is used, with p and tileID as inputs to that process and the output of that process as output.

[0396] If atdu_meshpatch_mode[ tileID ][ p ] equals P_INTER, the process for decoding inter-coded mesh patches in subclause 9.2.8.6 is used, with p and tileID as inputs to that process and the output of that process as output.

[0397] Decoding process of a mesh patch data unit coded in intra mode according to embodiments:

[0398] The inputs to this process are the current patch index p and the current tile ID tileID.

[0399] The following mesh patch related variables are assigned considering the parsed elements of the mesh patch data unit.

[0400] TileMeshpatchSubmeshID[ tileID ][ p ] = mdu_submesh_id[ tileID ][ p ]

[0401] If displacement_present_flag is 1, the following applies:

[0402] if (displacement_present_flag) {

[0403] TileMeshpatchSubdivCount[ tileID ][ p ] = PatchSubdivisionCount[ tileID ][ p ]

[0404] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){

[0405] TileMeshpatchSubdivMethod[tileID][p][i] =

[0406] PatchSubdivisionMethod[tileID][patchIdx][i]

[0407] }

[0408] TileMeshpatchDispCoordSys[ tileID ][ p ] =

[0409] mdu_displacement_coordinate_system[ tileID ][ p ]

[0410] TileMeshpatchTransformMethod[ tileID ][ p ]= mdu_transform_method[ tileID ][ p ]

[0411] }

[0412] If asve_displacement_id_present_flag is 0, the following applies:

[0413] TileMeshpatchFaceCount[ tileID ][ p ] =

[0414] mdu_face_count_minus1[ tileID ][ p ] + 1

[0415] TileMeshpatch2dPosX[ tileID ][ p ] =

[0416] mdu_2d_pos_x[ tileID ][ p ] * PatchPackingBlockSize (3)

[0417] TileMeshpatch2dPosY[ tileID ][ p ] =

[0418] mdu_2d_pos_y[ tileID ][ p ] * PatchPackingBlockSize (4)

[0419] TileMeshpatch2dSizeX[ tileID ][ p ] =

[0420] (mdu_2d_size_x_minus1[ tileID ][ p ] + 1) * PatchSizeXQuantizer (5)

[0421] TileMeshpatch2dSizeY[ tileID ][ p ] =

[0422] (mdu_2d_size_y_minus1[ tileID ][ p ] + 1) * PatchSizeYQuantizer (6)

[0423] for( i=0; i<= TileSubdivisionCount[ tileID ][ p ]; i++){

[0424] TilePatchVertexBlockCount[ tileID ][ p ][ i ] =

[0425] mpdumpdu_vertex_count_inlastblock[ tileID ][ patchIdx ][ i ] == 0 ?

[0426] (mpdu_vertex_block_count_minus1[ tileID ][ patchIdx ][ i ] + 1) :

[0427] mpdu_vertex_block_count_minus1[ tileID ][ patchIdx ][ i ]

[0428] TilePatchVertexCountLast[ tileID ][ p ][ i ] =

[0429] mpdumpdu_vertex_count_inlastblock[ tileID ][ patchIdx ][ i ]

[0430] TilePatchVertexCount[ tileID ][ p ][ i ] =

[0431] TilePatchVertexBlockCount[ tileID ][ p ][ i ] *

[0432] PatchPackingBlockSize * PatchPackingBlockSize +

[0433] mpdumpdu_vertex_count_inlastblock[ tileID ][ patchIdx ][ i ]

[0434] TilePatchTotalVertexCount[tileID][p] +=

[0435] TilePatchVertexCount[tileID][p][i]

[0436] }

[0437] If asve_displacement_id_present_flag is 1, the following applies:

[0438] TileMeshpatchDisplID[tileID][p] = mdu_displ_id[tileID][p]

[0439] If asve_num_attribute_video is greater than 0, the following applies:

[0440] In AFATI and AFTI, the number of tiles and IDs are assumed to be the same.

[0441] for( i = 0; i< asve_num_attribute_video; i++ ){

[0442] if(asve_attribute_subtexture_enabled_flag[ i ]){

[0443] TileMeshpatchAttributes2dPosX[tileID][p][i] =

[0444] mdu_attributes_2d_pos_x[tileID][p][i]

[0445] TileMeshpatchAttributes2dPosY[tileID][p][i] =

[0446] mdu_attributes_2d_pos_y[ tileID ][ p ][ i ]

[0447] TileMeshpatchAttributes2dSizeX[tileID][p][i] =

[0448] (mdu_attributes_2d_size_x_minus1[ tileID ][ p ][ i ] + 1) *PatchSizeYQuantizer

[0449] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ i ] =

[0450] (mdu_attributes_2d_size_y_minus1[ tileID ][ p ][ i ] + 1) * PatchSizeYQuantizer

[0451] }else{

[0452] TileMeshpatchAttributes2dPosX[ tileID ][ p ][ i ] = 0

[0453] TileMeshpatchAttributes2dPosY[ tileID ][ p ][ i ] = 0

[0454] TileMeshpatchAttributes2dSizeX[ tileID ][ p ][ i ] =

[0455] TileWidthAtt[ attrIdx ][ TileIDToIndexAtt[ attrIdx ][ tileID ] ]

[0456] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ i ] =

[0457] TileHeightAtt[ attrIdx ][ TileIDToIndexAtt[ attrIdx ][ tileID ] ]

[0458] }

[0459] }

[0460] smIdx = SubmeshIDToIndex[ TileMeshpatchSubmeshID[ tileID ][ p ] ]

[0461] TileMeshpatchTexcoordProjectionFlag[tileID][p] = TexcoordProjectionFlag[smIdx]

[0462] TileMeshpatchTexcoordProjectionWidthNormalization[ tileID ][ p ] =

[0463] TexcoordProjectionWidthNormalization[ smIdx ]

[0464] TileMeshpatchTexcoordProjectionHeightNormalization[ tileID ][ p ] =

[0465] TexcoordProjectionHeightNormalization[ smIdx ]

[0466] TileMeshpatchTexcoordProjectionGutter[ tileID ][ p ] =

[0467] TexcoordProjectionGutter[ smIdx ]

[0468] If TileMeshpatchTexcoordProjectionFlag[ tileID ][ p ] is equal to 1, decoding texture projection information as specified in subsection 9.2.8.3 is called with p and tileID as input.

[0469] Texture projection information decoding process:

[0470] The inputs to this process are the patch index p and the current tile ID tileID.

[0471] TileMeshpatchFrameScale[ tileID ][ p ] = tpi_frame_scale[ tileID ][ p ]

[0472] TileMeshpatchNumSubpatches[tileID][p] =

[0473] tpi_subpatch_count_minus1[ tileID ][ p ] + 1 (7)

[0474] for( i = 0; i < TileMeshpatchNumSubpatches[ tileID ][ p ]; i++ ){

[0475] if( tpi_face_id_present_flag[ tileID ][ p ] )

[0476] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] =

[0477] si_face_id[ tileID ][ p ][ i ]

[0478] else

[0479] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] = i

[0480] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ] =

[0481] si_projection_id[ tileID ][ p ][ i ] (8)

[0482] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ] =

[0483] si_orientation_id[ tileID ][ p ][ i ] (9)

[0484] TileMeshpatchSubpatch2dPosX[ tileID ][ i ][ p ] =

[0485] si_2d_pos_x[ tileID ][ p ][ i ] (10)

[0486] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ] =

[0487] si_2d_pos_y[ tileID ][ p ][ i ] (11)

[0488] if( i > 0 ) {

[0489] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[0490] ( si_2d_size_x_minus1_diff[ tileID ][ p ][ i ] +

[0491] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i - 1 ] ) (12)

[0492] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[0493] ( si_2d_size_y_minus1_diff[ tileID ][ p ][ i ] +

[0494] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i - 1 ] ) (13)

[0495] } else {

[0496] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[0497] ( si_2d_size_x_minus1_diff[ tileID ][ p ][ i ] + 1 ) (14)

[0498] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[0499] ( si_2d_size_y_minus1_diff[ tileID ][ p ][ i ] + 1 ) (15)

[0500] }

[0501] TileMeshpatchSubpatchScale[ tileID ][ p ][ i ] =

[0502] SubpatchScalingFactor[tileID][p][i] (16)

[0503] }

[0504] Decoding process of mesh patch data units coded in skip prediction mode:

[0505] The inputs to this process are the current patch index p and the current tile ID tileID.

[0506] First, refIdx is set to 0.

[0507] Then, the reference atlas frame refAtlasFrm is selected as the atlas frame corresponding to the ( refIdx + 1 )th entry of the reference atlas frame list RefAtlasFrmList, RefAtlasFrmList[ refIdx ].

[0508] If p is 0, PredictorIdx is set to 0.

[0509] The variable RefPatchIdx, which corresponds to the predicted patch index of the tile with the same ID as tileID in the reference atlas frame refAtlasFrm, is computed as follows:

[0510] RefPatchIdx = PredictorIdx (17)

[0511] and PredictorIdx is set to RefPatchIdx + 1.

[0512] The process described in subsection 9.2.8.6.2.1 is called with variables refIdx, RefPatchIdx and tileID as input and outputs variables refMeshpatch2dPosX, refMeshpatch2dPosY, refMeshpatch2dSizeX, refMeshpatch2dSizeY, refMeshpatchSubmeshID, refMeshpatchVertexCount, refMeshpatchFaceCount, refMeshpatchSubdivMethod, refMeshpatchSubdivCount, refMeshpatchDispCoordSys, refMeshpatchTransformMethod, 1D arrays refMeshpatchVertexblockCount, refMeshpatchVertexCountLast, refMeshpatchAttributes2dPosX, refMeshpatchAttributes2dPosY. refMeshpatchAttributes2dSizeX and refMeshpatchAttributes2dSizeY.

[0513] The following parameters are derived:

[0514] TileMeshpatchSubmeshID[tileID][p] = refMeshpatchSubmeshID (18)

[0515] If displacement_present_flag is 1, the following applies:

[0516] if (displacement_present_flag) {

[0517] TileMeshpatchSubdivCount[ tileID ][ p ] = refMeshpatchSubdivCount

[0518] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){

[0519] TileMeshpatchSubdivMethod[ tileID ][ p ][ i ] = refMeshpatchSubdivMethod[ i ] (19)

[0520] }

[0521] TileMeshpatchDispCoordSys[ tileID ][ p ] = refMeshpatchDispCoordSys (20)

[0522] TileMeshpatchTransformMethod[ tileID ][ p ] = refMeshpatchTransformMethod (21)

[0523] }

[0524] If asve_displacement_id_present_flag is 0, the following applies:

[0525] TileMeshpatchVertexCount[ tileID ][ p ] = refMeshpatchVertexCount (22)

[0526] TileMeshpatchFaceCount[ tileID ][ p ] = refMeshpatchFaceCount (23)

[0527] TileMeshpatch2dPosX[ tileID ][ p ] = refMeshpatch2dPosX (24)

[0528] TileMeshpatch2dPosY[ tileID ][ p ] = refMeshpatch2dPosY (25)

[0529] TileMeshpatch2dSizeX[ tileID ][ p ] = refMeshpatch2dSizeX (26)

[0530] TileMeshpatch2dSizeY[ tileID ][ p ] = refMeshpatch2dSizeY (27)

[0531] for( i=0; i<= TileSubdivisionCount[ tileID ][ p ]; i++){

[0532] TilePatchVertexBlockCount[ tileID ][ p ][ i ] =

[0533] refMeshatchVertexBlockCount[ i ]

[0534] TilePatchVertexCountLast[ tileID ][ p ][ i ] = refMeshpatchVertexCountLast[ i ]

[0535] TilePatchVertexCount[ tileID ][ p ][ i ] =

[0536] TilePatchVertexBlockCount[ tileID ][ p ][ i ] *

[0537] PatchPackingBlockSize * PatchPackingBlockSize +

[0538] mpdu_vertex_count_inlastblock[ tileID ][ patchIdx ][ i ]

[0539] TilePatchTotalVertexCount[ tileID ][ p ] +=

[0540] TilePatchVertexCount[ tileID ][ p ][ i ]

[0541] }

[0542] If asve_displacement_id_present_flag is 1, the following applies:

[0543] TileMeshpatchDisplID[ tileID ][ p ] = refMeshpatchDisplID (28)

[0544] The associated attribute 2D parameters are derived as follows:

[0545] for( i = 0; i< asve_num_attribute_video; i++ ){

[0546] TileMeshpatchAttributes2dPosX[ tileID ][ p ][ i ] =

[0547] refMeshpatchAttributes2dPosX[ i ]

[0548] TileMeshpatchAttributes2dPosY[ tileID ][ p ][ i ] =

[0549] refMeshpatchAttributes2dPosY[ i ]

[0550] TileMeshpatchAttributes2dSizeX[ tileID ][ p ][ i ] =

[0551] refMeshpatchAttributes2dSizeX[ i ]

[0552] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ i ] =

[0553] refMeshpatchAttributes2dSizeY[ i ]

[0554] }

[0555] smIdx = SubmeshIDToIndex[ TileMeshpatchSubmeshID[ tileID ][ p ] ]

[0556] TileMeshpatchTexcoordProjectionFlag[ tileID ][ p ] = TexcoordProjectionFlag[ smIdx ]

[0557] TileMeshpatchTexcoordProjectionWidthNormalization[ tileID ][ p ] =

[0558] TexcoordProjectionWidthNormalization[ smIdx ]

[0559] TileMeshpatchTexcoordProjectionHeightNormalization[ tileID ][ p ] =

[0560] TexcoordProjectionHeightNormalization[ smIdx ]

[0561] TileMeshpatchTexcoordProjectionGutter[ tileID ][ p ] =

[0562] TexcoordProjectionGutter[ smIdx ]

[0563] If TileMeshpatchTexcoordProjectionFlag[ tileID ][ p ] is 1, the process of subclause 9.2.8.6.2.2 is called with p and tileID as inputs, and the outputs are the variables refMeshpatchFrameScale and refMeshpatchNumSubpatches, and the one-dimensional arrays refMeshpatchSubpatchIdxToFaceId, refMeshpatchSubpatchProjectionID, refMeshpatchSubpatchOrientationID, refMeshpatchSubpatch2dPosX, refMeshpatchSubpatch2dPosY, refMeshpatchSubpatch2dSizeX, refMeshpatchSubpatch2dSizeY, refMeshpatchSubpatchScale.

[0564] Then, the texture projection information is derived as follows.

[0565] TileMeshpatchFrameScale[ tileID ][ p ] = refMeshpatchFrameScale

[0566] TileMeshpatchNumSubpatches[ tileID ][ p ] = refMeshpatchNumSubpatches

[0567] for( i = 0; i < TileMeshpatchNumSubpatches[ tileID ][ p ]; i++ ){

[0568] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] =

[0569] refMeshpatchSubpatchIdxToFaceId,[ i ]

[0570] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ] =

[0571] refMeshpatchSubpatchProjectionID[ i ]

[0572] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ] =

[0573] refMeshpatchSubpatchOrientationID[ i ]

[0574] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ i ] =

[0575] refMeshpatchSubpatch2dPosX[ i ]

[0576] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ] =

[0577] refMeshpatchSubpatch2dPosY[ i ]

[0578] TileMeshpatchSubpatch2dSizeX[tileID][p][i] =

[0579] refMeshpatchSubpatch2dSizeX[ i ]

[0580] TileMeshpatchSubpatch2dSizeY[tileID][p][i] =

[0581] refMeshpatchSubpatch2dSizeY [i]

[0582] TileMeshpatchSubpatchScale[tileID][p][i] =

[0583] refMeshpatchSubpatchScale[ i ]

[0584] }

[0585] Decoding process of mesh patch data units coded in merge prediction mode:

[0586] The inputs to this process are the current patch index p and the current tile ID tileID.

[0587] First, the reference atlas frame index refIdx is derived as mmdu_ref_index[ tileID ][ p ].

[0588] Then, the reference atlas frame refAtlasFrm is selected as the atlas frame corresponding to the ( refIdx + 1 )th entry of the reference atlas frame list RefAtlasFrmList, RefAtlasFrmList[ refIdx ].

[0589] If p is 0, PredictorIdx is set to 0.

[0590] Then, the predicted patch index RefPatchIdx of the tile with the same ID as the tile ID in the reference atlas frame refAtlasFrm is calculated as follows.

[0591] RefPatchIdx = PredictorIdx + mmdu_patch_index[tileID][p] (29)

[0592] And PredictorIdx is set to RefPatchIdx + 1.

[0593] The process described in subsection 9.2.8.6.2.1 is called with the variables refIdx, RefPatchIdx and tileID as input, and the outputs are refMeshpatch2dPosX, refMeshpatch2dPosY, refMeshpatch2dSizeX, refMeshpatch2dSizeY and refMeshpatchSubmeshID. refMeshpatchVertexCount, refMeshpatchFaceCount, refMeshpatchSubdivMethod, refMeshpatchSubdivCount, refMeshpatchDispCoordSys, refMeshpatchTransformMethod, one-dimensional array refMeshatchVertexBlockCount, refMeshpatchVertexCountLast, refMeshpatchAttributes2dPosX, refMeshpatchAttributes2dPosY, refMeshpatchAttributes2dSizeX, refMeshpatchAttributes2dSizeY.

[0594] The following parameters are derived:

[0595] TileMeshpatchSubmeshID[tileID][p] = refMeshpatchSubmeshID (30)

[0596] If displacement_present_flag is 1, the following applies:

[0597] if (displacement_present_flag) {

[0598] TileMeshpatchSubdivCount[ tileID ][ p ] = refMeshpatchSubdivCount (31)

[0599] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){

[0600] TileMeshpatchSubdivMethod[ tileID ][ p ][ i ] = refMeshpatchSubdivMethod[ i ] (32)

[0601] }

[0602] TileMeshpatchDispCoordSys[ tileID ][ p ] = refMeshpatchDispCoordSys (33)

[0603] TileMeshpatchTransformMethod[ tileID ][ p ] = refMeshpatchTransformMethod (34)

[0604] }

[0605] If asve_displacement_id_present_flag is 0, the following applies:35

[0606] TileMeshpatchFaceCount[ tileID ][ p ] = refMeshpatchFaceCount (36)

[0607] TileMeshpatch2dPosX[ tileID ][ p ] = refMeshpatch2dPosX (37)

[0608] TileMeshpatch2dPosY[ tileID ][ p ] = refMeshpatch2dPosY (38)

[0609] TileMeshpatch2dSizeX[ tileID ][ p ] = refMeshpatch2dSizeX (39)

[0610] TileMeshpatch2dSizeY[ tileID ][ p ] = refMeshpatch2dSizeY (40)

[0611] for( i=0; i<= TileSubdivisionCount[ tileID ][ p ]; i++){

[0612] TilePatchVertexBlockCount[ tileID ][ p ][ i ] = refMeshatchVertexBlockCount[ i ] TilePatchVertexCountLast[ tileID ][ p ][ i ] = refMeshpatchVertexCountLast[ i ]

[0613] TilePatchVertexCount[tileID][p][i] =

[0614] TilePatchVertexBlockCount[tileID][p][i] *

[0615] PatchPackingBlockSize * PatchPackingBlockSize +

[0616] mpdu_vertex_count_inlastblock[tileID][p][i]

[0617] TilePatchTotalVertexCount[tileID][p] +=

[0618] TilePatchVertexCount[tileID][p][i]

[0619] }

[0620] If asve_displacement_id_present_flag is 1, the following applies:

[0621] TileMeshpatchDisplID[tileID][p] = refMeshpatchDisplID (41)

[0622] The associated attribute 2D parameters are derived as follows:

[0623] for( i = 0; i< asve_num_attribute_video; i++ ){

[0624] TileMeshpatchAttributes2dPosX[ tileID ][ p ][ i ] =

[0625] refMeshpatchAttributes2dPosX[ i ]

[0626] TileMeshpatchAttributes2dPosY[ tileID ][ p ][ i ] =

[0627] refMeshpatchAttributes2dPosY[ i ]

[0628] TileMeshpatchAttributes2dSizeX[ tileID ][ p ][ i ] =

[0629] refMeshpatchAttributes2dSizeX[ i ]

[0630] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ i ] =

[0631] refMeshpatchAttributes2dSizeY[ i ]

[0632] }

[0633] smIdx = SubmeshIDToIndex[ TileMeshpatchSubmeshID[ tileID ][ p ] ]

[0634] TileMeshpatchTexcoordProjectionFlag[ tileID ][ p ] = TexcoordProjectionFlag[ smIdx ]

[0635] TileMeshpatchTexcoordProjectionWidthNormalization[ tileID ][ p ] =

[0636] TexcoordProjectionWidthNormalization[ smIdx ]

[0637] TileMeshpatchTexcoordProjectionHeightNormalization[ tileID ][ p ] =

[0638] TexcoordProjectionHeightNormalization[ smIdx ]

[0639] TileMeshpatchTexcoordProjectionGutter[ tileID ][ p ] =

[0640] TexcoordProjectionGutter[ smIdx ]

[0641] If mmdu_texture_projection_present_flag[ tileID ][ p ] is 1, the process of subclause 9.2.8.6.2.2 is called with p and tileID as inputs, and the outputs are variables refMeshpatchFrameScale and refMeshpatchNumSubpatches, and one-dimensional arrays refMeshpatchSubpatchIdxToFaceId, refMeshpatchSubpatchProjectionID, refMeshpatchSubpatchOrientationID, refMeshpatchSubpatch2dPosX, refMeshpatchSubpatch2dPosY, refMeshpatchSubpatch2dSizeX, refMeshpatchSubpatch2dSizeY, refMeshpatchSubpatchScale.

[0642] Then, the texture projection information is derived as follows.

[0643] TileMeshpatchFrameScale[ tileID ][ p ] = refMeshpatchFrameScale

[0644] TileMeshpatchNumSubpatches[ tileID ][ p ] = refMeshpatchNumSubpatches

[0645] for( i = 0; i < TileMeshpatchNumSubpatches[ tileID ][ p ]; i++ ){

[0646] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] =

[0647] refMeshpatchSubpatchIdxToFaceId,[ i ]

[0648] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ] =

[0649] refMeshpatchSubpatchProjectionID[ i ]

[0650] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ] =

[0651] refMeshpatchSubpatchOrientationID[ i ]

[0652] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ i ] =

[0653] refMeshpatchSubpatch2dPosX[ i ]

[0654] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ] =

[0655] refMeshpatchSubpatch2dPosY[ i ]

[0656] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[0657] refMeshpatchSubpatch2dSizeX[ i ]

[0658] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[0659] refMeshpatchSubpatch2dSizeY[ i ]

[0660] TileMeshpatchSubpatchScale[ tileID ][ p ][ i ] =

[0661] refMeshpatchSubpatchScale[ i ]

[0662] }

[0663] numSubPatchesUpdate = tpmi_update_subpatch_count_minus1[ tileID ][ p ]

[0664] for( i = 0; i < numSubPatchesUpdate; i++ ){

[0665] subPatchIdx = smi_subpatch_index[ tileID ][ p ][ i ]

[0666] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ subPatchIdx ] =

[0667] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ subPatchIdx ] +

[0668] smi_2d_pos_x_delta[ tileID ][ p ][ i ]

[0669] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ subPatchIdx ] =

[0670] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ subPatchIdx ] +

[0671] smi_2d_pos_y_delta[ tileID ][ p ][ i ]

[0672] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ subPatchIdx ] =

[0673] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ subPatchIdx ] +

[0674] smi_2d_size_x_delta[tileID][p][i]

[0675] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ subPatchIdx ] =

[0676] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ subPatchIdx ] +

[0677] smi_2d_size_y_delta[tileID][p][i]

[0678] }

[0679] Decoding process of mesh patch data units coded in inter prediction mode:

[0680] 9.2.8.6.1 General decoding process for mesh patch data units coded in inter prediction mode:

[0681] The inputs to this process are the current patch index p and the current tile ID tileID.

[0682] First, the reference atlas frame index refIdx is derived as imdu_ref_index[ tileID ][ p ].

[0683] Then, the reference atlas frame refAtlasFrm is selected as the atlas frame corresponding to the ( refIdx + 1 )th entry of the reference atlas frame list RefAtlasFrmList, RefAtlasFrmList[ refIdx ].

[0684] If p is 0, PredictorIdx is set to 0.

[0685] Then, the corresponding patch index RefPatchIdx of the tile with the same ID as the tile ID in the reference atlas frame refAtlasFrm is calculated as follows:

[0686] RefPatchIdx = PredictorIdx + imdu_patch_index[tileID][p] (42)

[0687] PredictorIdx is set to RefPatchIdx + 1.

[0688] The process described in subsection 9.2.8.6.2.1 is called with the variables refIdx, RefPatchIdx and tileID as inputs, and the outputs are refMeshpatch2dPosX, refMeshpatch2dPosY, refMeshpatch2dSizeX, refMeshpatch2dSizeY, refMeshpatchSubmeshID, refMeshpatchVertexCount, refMeshpatchFaceCount, refMeshpatchSubdivMethod, refMeshpatchSubdivCount, refMeshpatchDispCoordSys, refMeshpatchTransformMethod, and the one-dimensional arrays refMeshpatchBlockCount, refMeshpatchVertexCountLast. refMeshpatchAttributes2dPosX, refMeshpatchAttributes2dPosY, refMeshpatchAttributes2dSizeX, refMeshpatchAttributes2dSizeY.

[0689] The following parameters are derived:

[0690] TileMeshpatchSubmeshID[tileID][p] = refMeshpatchSubmeshID

[0691] If displacement_present_flag is 1, the following applies:

[0692] if (displacement_present_flag) {

[0693] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){

[0694] TileMeshpatchSubdivMethod[ tileID ][ p ][ i ] = refMeshpatchSubdivMethod[ i ]

[0695] }

[0696] TileMeshpatchDispCoordSys[ tileID ][ p ] = refMeshpatchDispCoordSys

[0697] TileMeshpatchTransformMethod[ tileID ][ p ] = refMeshpatchTransformMethod

[0698] }

[0699] If asve_displacement_id_present_flag is 0, the following applies:

[0700] TileMeshpatchFaceCount[ tileID ][ p ] = refMeshpatchFaceCount

[0701] TileMeshpatch2dPosX[ tileID ][ p ] =

[0702] refMeshpatch2dPosX + imdu_2d_delta_pos_x[ tileID ][ p ] * PatchPackingBlockSize

[0703] TileMeshpatch2dPosY[ tileID ][ p ] =

[0704] refMeshpatch2dPosY + imdu_2d_delta_pos_y[ tileID ][ p ] * PatchPackingBlockSize

[0705] TileMeshpatch2dSizeX[ tileID ][ p ] = refMeshpatch2dSizeX +

[0706] imdu_2d_delta_size_x[ tileID ][ p ] * PatchSizeXQuantizer

[0707] TileMeshpatch2dSizeY[ tileID ][ p ] = refMeshpatch2dSizeY +

[0708] imdu_2d_delta_size_y[ tileID ][ p ] * PatchSizeYQuantizer

[0709] TileMeshpatchSubdivCount[ tileID ][ p ] = InterPatchSubdivisionCount[ tileID ][ p ]

[0710] for( i=0; i<= TileMeshpatchSubdivCount[ tileID ][ p ]; i++){

[0711] TilePatchVertexBlockCount[ tileID ][ p ][ i ] =

[0712] (i < refMeshpatchSubdivCount ? refMeshpatchTotalVertexBlockCount[ i ] : 0 )

[0713] + imdu_delta_block_count[ tileID ][ p ][ i ] + 1

[0714] TilePatchVertexCountLastTilePatchVertexCountLast[ tileID ][ p ][ i ] =

[0715] (i < refMeshpatchSubdivCount ? refMeshpatchVertexCountLast[ i ] : 0 )

[0716] + imdu_delta_last_pos_in_blockin_block[tileID][p][i]

[0717] TilePatchVertexCount[tileID][p][i] =

[0718] TilePatchVertexBlockCount[tileID][p][i] *

[0719] PatchPackingBlockSize*PatchPackingBlockSize +

[0720] ipdu_vertex_count_inlastblock[tileID][p][i]

[0721] TilePatchTotalVertexCount[tileID][p] +=

[0722] TilePatchVertexCount[tileID][p][i]

[0723] }

[0724] If asve_displacement_id_present_flag is 1, the following applies:

[0725] TileMeshpatchDisplID[tileID][p] = refMeshpatchDisplID

[0726] The 2D parameters of the relevant properties are derived as follows.

[0727] for( i = 0; i< asve_num_attribute_video; i++ ){

[0728] TileMeshpatchAttributes2dPosX[tileID][p][i] =

[0729] refMeshpatchAttributes2dPosX[ i ] +

[0730] imdu_attribute_2d_delta_pos_x[ tileID ][ p ] * PatchPackingBlockSize

[0731] TileMeshpatchAttributes2dPosY[ tileID ][ p ][ i ] =

[0732] refMeshpatchAttributes2dPosY[ i ] +

[0733] imdu_attribute_2d_delta_pos_y[ tileID ][ p ] * PatchPackingBlockSize

[0734] TileMeshpatchAttributes2dSizeX[ tileID ][ p ][ i ] =

[0735] refMeshpatchAttributes2dSizeX[ i ] +

[0736] imdu_attribute_2d_delta_size_x[ tileID ][ p ] * PatchSizeXQuantizer

[0737] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ i ] =

[0738] refMeshpatchAttributes2dSizeY[ i ] +

[0739] imdu_attribute_2d_delta_size_y[ tileID ][ p ] * PatchSizeXQuantizer

[0740] }

[0741] smIdx = SubmeshIDToIndex[ TileMeshpatchSubmeshID[ tileID ][ p ] ]

[0742] TileMeshpatchTexcoordProjectionFlag[tileID][p] = TexcoordProjectionFlag[smIdx]

[0743] TileMeshpatchTexcoordProjectionWidthNormalization[ tileID ][ p ] =

[0744] TexcoordProjectionWidthNormalization[ smIdx ]

[0745] TileMeshpatchTexcoordProjectionHeightNormalization[ tileID ][ p ] =

[0746] TexcoordProjectionHeightNormalization[ smIdx ]

[0747] TileMeshpatchTexcoordProjectionGutter[ tileID ][ p ] =

[0748] TexcoordProjectionGutter[ smIdx ]

[0749] If imdu_texture_projection_present_flag[ tileID ][ p ] is 1, the process of subclause 9.2.8.6.2.2 is called with p and tileID as inputs, and the outputs are variables refMeshpatchFrameScale and refMeshpatchNumSubpatches, and one-dimensional arrays refMeshpatchSubpatchIdxToFaceId, refMeshpatchSubpatchProjectionID, refMeshpatchSubpatchOrientationID, refMeshpatchSubpatch2dPosX, refMeshpatchSubpatch2dPosY, refMeshpatchSubpatch2dSizeX, refMeshpatchSubpatch2dSizeY, refMeshpatchSubpatchScale.

[0750] 그러면 텍스처 투영 정보는 다음과 같이 도출된다.

[0751] TileMeshpatchFrameScale[ tileID ][ p ] = tpii_frame_scale[ tileID ][ p ]

[0752] TileMeshpatchNumSubpatches[ tileID ][ p ] = tpii_subpatch_count_minus1[ tileId ][ p ] + 1

[0753] for( i = 0; i < TileMeshpatchNumSubpatches[ tileID ][ p ]; i++ ){

[0754] if( tpii_subpatch_inter_present_flag[ tileID ][ p ][ i ] ){

[0755] sIdx = sii_subpatch_index_diff[ tileID ][ p ][ i ] + i

[0756] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] =

[0757] refMeshpatchSubpatchIdxToFaceId[ sIdx ]

[0758] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ] =

[0759] refMeshpatchSubpatchProjectionID[ sIdx ]

[0760] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ] =

[0761] refMeshpatchSubpatchOrientationID[ sIdx ]

[0762] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ i ] =

[0763] refMeshpatchSubpatch2dPosX[ sIdx ] +

[0764] sii_2d_pos_x_delta[ tileID ][ p ][ i ]

[0765] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ] =

[0766] refMeshpatchSubpatch2dPosY[ sIdx ] +

[0767] sii_2d_pos_y_delta[ tileID ][ p ][ i ]

[0768] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[0769] refMeshpatchSubpatch2dSizeX[ sIdx ] +

[0770] sii_2d_size_x_delta[ tileID ][ p ][ i ]

[0771] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[0772] refMeshpatchSubpatch2dSizeY[ sIdx ] +

[0773] sii_2d_size_y_delta[ tileID ][ p ][ i ]

[0774] TileMeshpatchSubpatchScale[ tileID ][ p ][ i ] =

[0775] refMeshpatchSubpatchScale[ i ]

[0776] } else {

[0777] if( tpii_face_id_present_flag[ tileID ][ p ] )

[0778] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] =

[0779] si_face_id[ tileID ][ p ][ i ]

[0780] else

[0781] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] = i

[0782] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ] =

[0783] si_projection_id[ tileID ][ p ][ i ]

[0784] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ] =

[0785] si_orientation_id[ tileID ][ p ][ i ]

[0786] TileMeshpatchSubpatch2dPosX[ tileID ][ i ][ p ] =

[0787] si_2d_pos_x[ tileID ][ p ][ i ]

[0788] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ] =

[0789] si_2d_pos_y[ tileID ][ p ][ i ]

[0790] if( i > 0 ) {

[0791] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[0792] ( si_2d_size_x_minus1_diff[ tileID ][ p ][ i ] +

[0793] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i - 1 ] )

[0794] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[0795] ( si_2d_size_y_minus1_diff[ tileID ][ p ][ i ] +

[0796] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i - 1 ] )

[0797] } else {

[0798] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[0799] ( si_2d_size_x_minus1_diff[ tileID ][ p ][ i ] + 1 )

[0800] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[0801] ( si_2d_size_y_minus1_diff[ tileID ][ p ][ i ] + 1 )

[0802] }

[0803] TileMeshpatchSubpatchScale[ tileID ][ p ][ i ] =

[0804] SubpatchScalingFactor[ tileID ][ p ][ i ]

[0805] }

[0806] }

[0807] 9.2.8.6.2 참조 간 패치 매개변수 도출

[0808] 9.2.8.6.2.1 General derivation of patch parameters between references

[0809] The inputs to this process are the atlas frame reference index (refIdx), the patch reference index (refPatchIdx), and the current tile ID (tileID).

[0810] The output of this process is the variables refMeshpatch2dPosX, refMeshpatch2dPosY, refMeshpatch2dSizeX, refMeshpatch2dSizeY, refMeshpatchSubmeshID, refMeshpatchDisplID, refMeshpatchVertexCount, refMeshpatchFaceCount, refMeshpatchSubdivMethod, refMeshpatchSubdivCount, refMeshpatchDispCoordSys, refMeshpatchTransformMethod, one-dimensional array refMeshpatchAttributes2dPosX, refMeshpatchAttributes2dPosY, refMeshpatchAttributes2dSizeX, refMeshpatchAttributes2dSizeY.

[0811] First, determine the mesh patch refMeshpatch with the same index as refPatchIdx from the tile with the same tile ID as the tileID of the (refIdx + 1)th entry of the reference atlas frame list RefAtlasFrmList(RefAtlasFrmList[refIdx]).

[0812] Then, the output of this process is derived based on the relevant parameters of the mesh patch refMeshpatch as follows.

[0813] If displacement_present_flag is 1, the following applies:

[0814] if (displacement_present_flag) {

[0815] refMeshpatch2dPosX = TileMeshpatch2dPosX[ tileID ][ refPatchIdx ]

[0816] refMeshpatch2dPosY = TileMeshpatch2dPosY[ tileID ][ refPatchIdx ]

[0817] refMeshpatch2dSizeX = TileMeshpatch2dSizeX[ tileID ][ refPatchIdx ]

[0818] refMeshpatch2dSizeY = TileMeshpatch2dSizeY[ tileID ][ refPatchIdx ]

[0819] refMeshpatchDisplID = TileMeshpatchDisplID[ tileID ][ RefPatchIdx ]

[0820] refMeshpatchSubdivCount = TileMeshpatchSubdivCount[ tileID ][ refPatchIdx ]

[0821] for( i = 0; i < refMeshpatchSubdivCount ; i++ ){

[0822] refMeshpatchSubdivMethod[ i ] =

[0823] TileMeshpatchSubdivMethod[ tileID ][ refPatchIdx ][ i ]

[0824] } refMeshpatchDispCoordSys = TileMeshpatchDispCoordSys[ tileID ][ refPatchIdx ]

[0825] refMeshpatchTransformMethod = TileMeshpatchTransformMethod[ tileID ][ refPatchIdx ]

[0826] }

[0827] refMeshpatchSubmeshID = TileMeshpatchSubmeshID[ tileID ][ RefPatchIdx ] refMeshpatchVertexCount = TileMeshpatchVertexCount[ tileID ][ refPatchIdx ]

[0828] refMeshpatchFaceCount = TileMeshpatchFaceCount[ tileID ][ refPatchIdx ]

[0829] 연관된 속성 2D 매개변수는 다음과 같이 파생된다.

[0830] for( i = 0; i< asve_num_attribute_video; i++ ){

[0831] refMeshpatchAttributes2dPosX[ i ] =

[0832] TileMeshpatchAttributes2dPosX[ tileID ][ refPatchIdx ][ i ]

[0833] refMeshpatchAttributes2dPosY[ i ] =

[0834] TileMeshpatchAttributes2dPosY[ tileID ][ refPatchIdx ][ i ]

[0835] refMeshpatchAttributes2dSizeX[ i ] =

[0836] TileMeshpatchAttributes2dSizeX[ tileID ][ refPatchIdx ][ i ]

[0837] refMeshpatchAttributes2dSizeY[ i ] =

[0838] TileMeshpatchAttributes2dSizeY[ tileID ][ refPatchIdx ][ i ]

[0839] }

[0840] where TileMeshpatch2dPosX, TileMeshpatch2dPosY, TileMeshpatch2dSizeX, TileMeshpatch2dSizeY, TileMeshpatchSubmeshID, TileMeshpatchDisplID, TileMeshpatchVertexCount, TileMeshpatchFaceCount, TileMeshpatchSubdivMethod, TileMeshpatchSubdivCount, TileMeshpatchDispCoordSys, TileMeshpatchTransformMethod, TileMeshpatchAttributes2dPosX, TileMeshpatchAttributes2dPosY, TileMeshpatchAttributes2dSizeX, and TileMeshpatchAttributes2dSizeY are the associated tiles in the meshpatch with index refPatchIdx of the tile ID equal to the tileID of the refIdxth entry of the reference atlas frame list structure RefAtlasFrmList. meshpatch parameter.

[0841] 9.2.8.6.2.2 Deriving texture projection information from reference patch parameters

[0842] The inputs to this process are the atlas frame reference index (refIdx), the patch reference index (refPatchIdx), and the current tile ID (tileID).

[0843] First, determine the mesh patch (refMeshpatch) with the same index as refPatchIdx in the tile with the same tileID as the (refIdx + 1)th entry of the reference atlas frame list RefAtlasFrmList, RefAtlasFrmList[refIdx].

[0844] The output of this process is the variables refMeshpatchFrameScale and refMeshpatchNumSubpatches, one-dimensional arrays refMeshpatchSubpatchIdxToFaceId, refMeshpatchSubpatchProjectionID, refMeshpatchSubpatchOrientationID, refMeshpatchSubpatch2dPosX, refMeshpatchSubpatch2dPosY, These are refMeshpatchSubpatch2dSizeX, refMeshpatchSubpatch2dSizeY, and refMeshpatchSubpatchScale.

[0845] Then, the output of this process is derived based on the relevant parameters of meshpatch refMeshpatch as follows.

[0846] refMeshpatchFrameScale = TileMeshpatchFrameScale[ tileID ][ refPatchIdx ]

[0847] refMeshpatchNumSubpatches = TileMeshpatchNumSubpatches[ tileID ][ refPatchIdx ]

[0848] for( i = 0; i < TileMeshpatchNumSubpatches[ tileID ][ p ]; i++ ){

[0849] refMeshpatchSubpatchIdxToFaceId[ i ] =

[0850] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ refPatchIdx ][ i ]

[0851] refMeshpatchSubpatchProjectionID[ i ] =

[0852] TileMeshpatchSubpatchProjectionID[ tileID ][ refPatchIdx ][ i ]

[0853] refMeshpatchSubpatchOrientationID [ i ] =

[0854] TileMeshpatchSubpatchOrientationID[ tileID ][ refPatchIdx ][ i ]

[0855] refMeshpatchSubpatch2dPosX[ i ] =

[0856] TileMeshpatchSubpatch2dPosX[ tileID ][ refPatchIdx ][ i ]

[0857] refMeshpatchSubpatch2dPosY[ i ] =

[0858] TileMeshpatchSubpatch2dPosY[ tileID ][ refPatchIdx ][ i ]

[0859] refMeshpatchSubpatch2dSizeX[ i ] =

[0860] TileMeshpatchSubpatch2dSizeX[ tileID ][ refPatchIdx ][ i ]

[0861] refMeshpatchSubpatch2dSizeY[ i ] =

[0862] TileMeshpatchSubpatch2dSizeY[ tileID ][ refPatchIdx ][ i ]

[0863] refMeshpatchSubpatchScale[ i ] =

[0864] TileMeshpatchSubpatchScale[ tileID ][ refPatchIdx ][ i ]

[0865] }

[0866] Convert tile-level meshpatch information to atlas-level meshpatch information:

[0867] 9.2.9.1 General

[0868] In some implementations, the reconstruction process can be performed using tile information directly, i.e., the reconstruction process is tile-based. In other implementations, the reconstruction process can be performed using all tile information, i.e., the reconstruction process is atlas-based. In this case, tile-level patch information may need to be converted to atlas-level patch information. This conversion is performed in this subsection.

[0869] 9.2.9.2 Converting tile-level mesh patch information to atlas-level mesh patch information

[0870] AtlasTotalNumMeshpatches = 0

[0871] atlasPatchIdx = 0

[0872] for( t = 0; t <= afti_num_tiles_in_atlas_frame_minus1; t++ ) {

[0873] tileID = TileIndexToID[ t ]

[0874] tileOffsetX = TileOffsetX[ t ]

[0875] tileOffsetY = TileOffsetY[t]

[0876] for( p = 0; p < AtduTotalNumMeshpatches[ tileID ]; p++ ) {

[0877] if (displacement_present_flag) {

[0878] AtlasMeshpatch2dSizeX[ atlasPatchIdx ] =

[0879] TileMeshpatch2dSizeX[tileID][p]

[0880] AtlasMeshpatch2dSizeY[ atlasPatchIdx ] =

[0881] TileMeshpatch2dSizeY[ tileID ][ p ]

[0882] AtlasMeshpatch2dPosX[ atlasPatchIdx ] =

[0883] TileMeshpatch2dPosX[ tileID ][ p ] + tileOffsetX

[0884] AtlasMeshpatch2dPosY[ atlasPatchIdx ] =

[0885] TileMeshpatch2dPosY[ tileID ][ p ] + tileOffsetY

[0886] AtlasMeshpatchDisplID[ atlasPatchIdx ] =

[0887] TileMeshpatchDisplID[ tileID ][ p ]

[0888] AtlasMeshpatchSubdivCount[ atlasPatchIdx ] =

[0889] TileMeshpatchSubdivCount[ tileID ][ p ]

[0890] for( i = 0; i < AtlasMeshpatchSubdivCount[ atlasPatchIdx ]; i++ ){

[0891] AtlasMeshpatchSubdivMethod[ atlasPatchIdx ][ i ] =

[0892] TileMeshpatchSubdivMethod[ tileID ][ p ][ i ]

[0893] }

[0894] AtlasMeshpatchDispCoordSys[ atlasPatchIdx ] =

[0895] TileMeshpatchDispCoordSys[ tileID ][ p ]

[0896] AtlasMeshpatchTransformMethod[ atlasPatchIdx ] =

[0897] TileMeshpatchTransformMethod[ tileID ][ p ]

[0898] for( i=0; i<= AtlasPatchSubdivisionCount[ atlasPatchIdx ]; i++){

[0899] AtlasPatchVertexBlockCount[ atlasPatchIdx ][ i ] =

[0900] TilePatchVertexBlockCount[ tileID ][ p ][ i ]

[0901] AtlasPatchVertexCountLast[ atlasPatchIdx ][ i ] =

[0902] TilePatchVertexCountLast[ tileID ][ p ][ i ]

[0903] AtlasPatchVertexCount[ atlasPatchIdx ][ i ] =

[0904] TileVertexCount[ tileID ][ p ][ i ]

[0905] AtlasPatchTotalVertexCount[ atlasPatchIdx ] =

[0906] TilePatchTotalVertexCount[ tileID ][ p ]

[0907] }

[0908] }

[0909] AtlasMeshpatchSubmeshID[ atlasPatchIdx ] =

[0910] TileMeshpatchSubmeshID[ tileID ][ p ]

[0911] AtlasMeshpatchVertexCount[ atlasPatchIdx ] =

[0912] TileMeshpatchVertexCount[ tileID ][ p ]

[0913] AtlasMeshpatchFaceCount[ [ atlasPatchIdx ] =

[0914] TileMeshpatchFaceCount[ tileID ][ p ] + 1

[0915] if( asve_num_attribute_video > 0 ){

[0916] AttributeTileMeshpatchParamsToAtlas( atlasPatchIdx, t, p )

[0917] }

[0918] AtlasMeshpatchTexcoordProjectionFlag[ atlasPatchIdx ] =

[0919] TileMeshpatchTexcoordProjectionFlag[ tileID ][ p ]

[0920] AtlasMeshpatchTexcoordProjectionWidthNormalization[ atlasPatchIdx ] =

[0921] TileMeshpatchTexcoordProjectionWidthNormalization[ tileID ][ p ]

[0922] AtlasMeshpatchTexcoordProjectionHeightNormalization[ atlasPatchIdx ] =

[0923] TileMeshpatchTexcoordProjectionHeightNormalization[ tileID ][ p ]

[0924] AtlasMeshpatchTexcoordProjectionGutter[atlasPatchIdx] =

[0925] TileMeshpatchTexcoordProjectionGutter[ tileID ][ p ]

[0926] if( AtlasMeshpatchTexcoordProjectionFlag[ atlasPatchIdx ] )

[0927] SubpatchTileParamToAtlas( atlasPatchIdx, tileID, p )

[0928] atlasPatchIdx += 1

[0929] }

[0930] }

[0931] AtlasTotalNumMeshpatches = atlasPatchIdx

[0932] In this version of the document, AtlasPatchVertexCount[ atlasPatchIdx ][ i ] must be greater than 2 for each patch whose index is atlasPatchIdx and for each subdivision whose index is i.

[0933] 9.2.9.2.2 Process of copying attribute mesh patch parameters from tile to atlas representation

[0934] The AttributeTileMeshpatchParamsToAtlas( atlasPatchIdx, t, p ) process is defined as follows:

[0935] AttributeTileMeshpatchParamsToAtlas( atlasPatchIdx, t, p ) { for( ai = 0; ai< asve_num_attribute_video; ai++ ) {

[0936] tileIDAtt = TileIndexToIDAtt[ ai ][ t ]

[0937] tileOffsetAttX = TileOffsetXAtt[ ai ][ t ]

[0938] tileOffsetAttY = TileOffsetYAtt[ ai ][ t ]

[0939] if( asve_attribute_subtexture_enabled_flag[ ai ] ) {

[0940] AtlasMeshpatchAttributes2dPosX[ atlasPatchIdx ][ ai ] =

[0941] TileMeshpatchAttributes2dPosX[ tileIDAtt ][ p ][ ai ] + tileOffsetAttX

[0942] AtlasMeshpatchAttributes2dPosY[ atlasPatchIdx ][ ai ] =

[0943] TileMeshpatchAttributes2dPosY[ tileIDAtt ][ p ][ ai ] + tileOffsetAttY

[0944] AtlasMeshpatchAttributes2dSizeX[ atlasPatchIdx ][ ai ] =

[0945] TileMeshpatchAttributes2dSizeX[ tileIDAtt ][ p ][ ai ]

[0946] AtlasMeshpatchAttributes2dSizeY[ atlasPatchIdx ][ ai ] =

[0947] TileMeshpatchAttributes2dSizeY[ tileIDAtt ][ p ][ ai ]

[0948] }else{

[0949] AtlasMeshpatchAttributes2dPosX[ atlasPatchIdx ][ ai ] = 0

[0950] AtlasMeshpatchAttributes2dPosY[atlasPatchIdx][ai] = 0

[0951] AtlasMeshpatchAttributes2dSizeX[ atlasPatchIdx ][ ai ] =

[0952] TileWidthAtt[ ai ][ t ]

[0953] AtlasMeshpatchAttributes2dSizeY]atlasPatchIdx ][ i ] =

[0954] TileHeightAtt[ ai ][ t ]

[0955] }

[0956] }

[0957] }

[0958] 9.2.9.2.3 Process of copying sub-patch parameters from tile to atlas representation

[0959] The SubpatchTileParamToAtlas(atlasPatchIdx, tileID, p) process is defined as follows:

[0960] SubpatchTileParamToAtlas( atlasPatchIdx, tileID, p ) {

[0961] AtlasMeshpatchFrameScale[ atlasPatchIdx ] =

[0962] TileMeshpatchFrameScale[tileID][p]

[0963] AtlasMeshpatchNumSubpatches[ atlasPatchIdx ] =

[0964] TileMeshpatchNumSubpatches[ tileID ][ p ]

[0965] for( i = 0; i < AtlasMeshpatchNumSubpatches[ atlasPatchIdx ]; i++ ){

[0966] AtlasMeshpatchSubpatchFaceId[ atlasPatchIdx ][ i ] =

[0967] TileMeshpatchSubpatchFaceId[ tileID ][ p ][ i ]

[0968] AtlasMeshpatchSubpatchProjectionID[ atlasPatchIdx ][ i ] =

[0969] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ]

[0970] AtlasMeshpatchSubpatchOrientationID[ atlasPatchIdx ][ i ] =

[0971] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ])

[0972] AtlasMeshpatchSubpatch2dPosX[ atlasPatchIdx ][ i ] =

[0973] TileMeshpatchSubpatch2dPosX[ tileID ][ i ][ p ]

[0974] AtlasMeshpatchSubpatch2dPosY[ atlasPatchIdx ][ i ] =

[0975] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ]

[0976] AtlasMeshpatchSubpatch2dSizeX[ atlasPatchIdx ][ i ] =

[0977] TileMeshpatchSubpatch2dSizeX[tileID][p][i]

[0978] AtlasMeshpatchSubpatch2dSizeY[ atlasPatchIdx ][ i ] =

[0979] TileMeshpatchSubpatch2dSizeY[tileID][p][i]

[0980] AtlasMeshpatchSubpatchScale[ atlasPatchIdx ][ i ] =

[0981] TileMeshpatchSubpatchScale[tileID][p][i]

[0982] }

[0983] }

[0984] Fig. 18 shows a dynamic mesh encoder according to embodiments.

[0985] FIG. 18 illustrates an encoder structure described in the encoding method and device (FIG. 1 Transmitter (100), Mesh Encoder (102), File / Segment Encapsulator (103), Transmitter (104), FIG. 2, FIG. 3, FIG. 4, FIG. 6, FIG. 7 Pre-processor, Encoder, FIG. 12 Encoder, FIG. 14 to FIG. 15 Bitstream and Syntax Generation, FIG. 19 to FIG. 22 Encoding, FIG. 28a and FIG. 28b to FIG. 44a, FIG. 44b and FIG. 44c Syntax Generation, FIG. 45 Encoding Method, etc.) according to embodiments. The encoder may be composed of a memory and at least one processor connected to the memory.

[0986] Mesh Simplification: Takes an original mesh as input and generates a simplified base mesh. The input mesh can be simplified to a target number of vertices or a target number of faces.

[0987] Mesh parameterization: Performs parameterization to generate texture coordinates (UV coordinates) and texture connection information per vertex of the input mesh.

[0988] Mesh Subdivision: The mesh subdivision unit can generate additional vertices by performing subdivision on the base mesh. Depending on the subdivision method, geometric connection information, texture coordinate connection information, and texture coordinates can be implicitly derived and generated.

[0989] Mesh refinement can be performed multiple times by user parameters or decoder / decoder agreement, and depending on the embodiment, the vertices of the base mesh are R0, the newly generated vertices are R1 by performing the 1st refinement, and the vertices generated by performing the nth refinement are R. n When defined as LoD n can be defined as follows:

[0990] LoD n =

[0991] Mesh fitting section: Adjusts vertex positions so that the refined mesh resembles the original mesh.

[0992] Depending on the embodiment, the mesh simplification unit, mesh parameterization unit, mesh refinement unit, and mesh fitting unit may be omitted, and if the processes are omitted, the original mesh may be applied as input to the mesh quantization unit.

[0993] At this time, coordinate information of the original mesh can be applied as input to the displacement vector calculation unit, and depending on the embodiment, the displacement vector encoding process (displacement vector calculation unit, displacement vector coordinate system conversion unit, displacement vector encoding unit) can be omitted.

[0994] Mesh quantization unit: It can quantize floating-point geometric information (x, y, z, geometry data) or / and texture coordinates (u, v, attribute data) or / and normal information (nx, ny, nz) into fixed-point information.

[0995] Depending on the embodiment, quantization for certain components may be omitted.

[0996] Static mesh encoding unit: Encodes the connection information, vertex geometry information, vertex texture coordinates, normal information, etc. of the base mesh.

[0997] Motion vector encoding unit: Motion vector encoding can be performed by calculating motion vectors using the reference restoration base mesh and the current base mesh as input.

[0998] The motion vector encoding unit can perform prediction based on connection information using a previously encoded / decoded motion vector as a predictor, and perform entropy encoding on a residual motion vector obtained by subtracting a predicted motion vector from a current motion vector.

[0999] Motion vector encoding can be performed on a vertex basis or a subgroup basis, depending on the embodiment.

[1000] Displacement vector calculation unit: Calculates the displacement vector between the fitted subdivision mesh and the restored current base mesh, which is the mesh on which subdivision was performed.

[1001] The displacement vector of the number of vertices of the subdivided mesh can be calculated through the displacement vector calculation unit.

[1002] Displacement vector coordinate system transformation part: The vertex displacement vector calculated in the (x, y, z) space can be transformed into the (normal, tangential, bi-tangential) coordinate system based on the normal vector of each vertex.

[1003] Depending on the embodiment, only the normal component among the coordinate systems (normal, tangential, bi-tangential) may be encoded, and when the coordinate system transformation is applied according to the encoder / decoder agreement, only the normal component may always be encoded, or the encoder may decide to signal a 1-bit flag (onlyNormFlag).

[1004] At this time, the normal vector can be calculated for each subdivided vertex based on the geometric information or / and connection information of the surrounding vertices.

[1005] Whether or not to transform the displacement vector coordinate system is determined by the encoder / decoder agreement, or the coordinate system transformation flag (applyLocalCoord) is transmitted in units such as sequence, GOF (Group of frame), frame, and sub-mesh to determine whether or not to transform the coordinate system.

[1006] Base mesh restoration unit: Restores the base mesh according to the encoding type of the current mesh (inter-screen encoding or intra-screen encoding).

[1007] When inter-screen encoding is performed, the current base mesh can be generated by adding the restored motion vector to the reference restored base mesh.

[1008] At this time, if the motion vector is not quantized, the motion vector restoration process is omitted, and the current base mesh can be restored using the motion vector calculated by the motion vector encoding unit.

[1009] When in-screen encoding is performed, the current base mesh can be restored by performing inverse quantization on the quantized base mesh through the mesh quantization unit.

[1010] Base mesh dequantization unit: The mesh quantization unit performs dequantization using inputs such as restoration geometric information (x, y, z) or / and texture coordinates (u, v) or / and normal information (nx, ny, nz) of the restoration base mesh.

[1011] In some embodiments, dequantization for certain components may be omitted.

[1012] Displacement vector restoration unit: The bitstream encoded by the 2D video encoder is packed into a 2D image / video and decoded by the 2D video decoder, and then depacked.

[1013] The quantized transformation coefficients for which inverse packing has been performed are subjected to nutritional magnetization, and the inverse transformation is performed to calculate the restored displacement vector.

[1014] Mesh restoration unit: Subdivision is performed on the restored base mesh that has been restored by performing inverse quantization in the base mesh inverse quantization unit, thereby generating subdivided vertex position information, texture coordinates, and connection information.

[1015] Restored vertex position information is generated by adding the restored displacement vector to the detailed vertex position information.

[1016] Texture map generation unit: Generates a texture map for the restored mesh using the texture coordinates and connection information of the restored mesh and the relationship between the original mesh and the texture map of the original mesh.

[1017] Texture map encoding unit: The texture map generated through the texture map generation unit is stacked in the frame order of the mesh to form a texture map video, and this is encoded through a 2D video encoder.

[1018] Depending on the embodiment, if the color space of the texture map is RGB444, encoding may be performed after conversion to a color space such as YUV420 or YUV444.

[1019] Figure 19 shows a displacement vector conversion process according to embodiments.

[1020] Figure 19 illustrates in detail the displacement vector conversion process included in Figure 18.

[1021] The displacement vector encoding unit can perform displacement vector encoding through a 2D video encoder such as H.264, HEVC, or VVC, or encoding can be performed through a zero run length encoder or an arithmetic encoder.

[1022] The displacement vector encoding method can be determined as a specific encoding method by a decoder / sub-coder agreement, or the encoding method determined by the encoder can be signaled as a flag or index (dispEncType).

[1023] Displacement vector encoding methods may vary, and depending on the embodiment, one of {video codec-based encoding method, zero run-length encoding method}, {video codec-based encoding method, zero run-length encoding method}, {video codec-based encoding method, arithmetic encoding method}, video codec-based encoding method, zero run-length encoding method, and arithmetic encoding method may be determined through the dispEncType flag or index.

[1024] Depending on the embodiment, a displacement vector encoding method may be determined according to a profile defined in a decoder / decoder, and an index (profileToolsetIdx) indicating profile information may be signaled so that the decoder can determine a displacement vector decoding method according to profileToolsetIdx.

[1025] An embodiment of a displacement vector encoding unit according to a displacement vector encoding method is as follows.

[1026] As shown in Fig. 19(a), when the displacement vector encoding method is a video codec-based encoding method, the displacement vector transform coefficient packing unit may be a process of packing the quantized displacement vector transform coefficients into one frame for each LoD level through the displacement vector transform coefficient quantization unit. The area packed for each LoD level may be in a raster-scan order or may be in a rectangular shape, depending on the embodiment. The packing method may be determined by deriving it in the same way as the decoder / decoder, and the packing method may be determined in the decoder by signaling.

[1027] As shown in Fig. 19(a), in the method according to the embodiments, the displacement vector transform unit quantizes coefficients through the displacement vector transform coefficient quantization unit, packs them in the displacement vector transform coefficient packing unit, and performs encoding in the displacement vector image / video encoding unit. As shown in Fig. 19(b), in the method according to the embodiments, the displacement vector transform unit performs prediction in the displacement vector transform coefficient level prediction unit through the restored displacement vector transform coefficient level buffer, and encodes them in the displacement vector transform coefficient zero run length encoding unit. As shown in Fig. 19(c), in the method according to the embodiments, the displacement vector transform unit quantizes coefficients through the displacement vector transform coefficient quantization unit, and then performs prediction in the displacement vector transform coefficient level prediction unit through the restored displacement vector transform coefficient level buffer, and performs arithmetic encoding in the displacement vector transform coefficient arithmetic encoding unit.

[1028] Figure 20 shows a displacement vector conversion process according to embodiments.

[1029] Figure 20 illustrates the displacement vector conversion process in detail, as in Figure 19.

[1030] As shown in Fig. 20(a), in the method according to the embodiments, the displacement vector transform unit performs prediction in the displacement vector transform coefficient prediction unit with reference to the restored displacement vector transform coefficient buffer, performs quantization in the displacement vector transform coefficient quantization unit, and performs encoding in the displacement vector transform coefficient zero run length encoding unit. As shown in Fig. 20(b), in the method according to the embodiments, the displacement vector transform unit performs prediction in the displacement vector transform coefficient prediction unit with reference to the restored displacement vector transform coefficient buffer, performs quantization in the displacement vector transform coefficient quantization unit, and performs arithmetic encoding in the displacement vector transform coefficient arithmetic encoding unit. The entire process proceeds in the order of first predicting the displacement vector transform coefficient with reference to the restored displacement vector transform coefficient buffer, quantizing the predicted coefficient, and then performing zero run length encoding or arithmetic encoding according to the selected encoding method.

[1031] According to an embodiment, the restoration displacement vector transformation coefficient may be stored in a buffer according to a reference structure, and the restoration displacement vector transformation coefficient (refDispCoeff) of the reference mesh to which the current mesh vertex is mapped may be used as a predictor of the current displacement vector transformation coefficient to perform prediction using the following formula.

[1032] for (size_t v = 0; v < N; v++) {

[1033] for(size_t d = 0; d < dim; d++) {

[1034] dispCoef[v][d] = curDispCoef[v][d] - refDispCoef[v][d]

[1035] }

[1036] }

[1037] Displacement vector transform coefficient quantization can perform inverse quantization on the differential displacement vector transform coefficient (dispCoeff) obtained by subtracting the predicted displacement vector transform coefficient (refDispCoeff) from the current displacement vector transform coefficient (curdispCoeff).

[1038] Figure 21 shows a lifting transformation update process according to embodiments.

[1039] Figure 21 illustrates in detail the lifting transformation update process included in Figure 18.

[1040] Referring to FIG. 21, the method according to the embodiments sets the variable i to lodCount - 2. It is determined whether i is greater than or equal to 0. The lifting transformation prediction unit performs prediction. The lifting transformation update unit performs update. The last block decreases the value of i by 1. The overall process repeats the process of initializing i to lodCount - 2, performing lifting transformation prediction and update if i is greater than or equal to 0, and decreasing i by 1, and the procedure ends when i becomes less than 0.

[1041] Displacement vector transformation unit: The displacement vector of the (x, y, z) or (n, t, bt) coordinate system can be transformed through the displacement vector transformation unit. In an embodiment, when the coordinate system transformation is performed to the (n, t, bt) coordinate system, a 1D scalar displacement vector of the normal (n) component is applied as an input of the displacement vector transformation unit, and transformation, quantization, and encoding can be performed on the displacement value of the normal component. The transformation may be a lifting transformation, a wavelet transformation, etc., depending on the embodiment. When the lifting transformation is performed, the transformation of the displacement vector can be performed through the embodiment of FIG. 21. The number of lifting transformations can be determined using the number of mesh subdivision levels (lodCount). The lifting transformation process can be performed in units of mesh subdivision levels. During the lifting transformation process, a lifting transformation prediction unit and a lifting transformation update unit can be performed.

[1042] Lifting transformation prediction part: When performing displacement vector prediction of vertex R_k of the th subdivision level, t(t <k 또는 t헽)번째 세분화 레벨의 정점 R_t의 변위 벡터를 예측자로 사용해 k번째 세분화 레벨의 변위벡터 예측을 수행할 수 있다. 실시예에 따라 변위벡터의 예측 수행 시 현재 정점보다 세분화 레벨이 낮은 정점 중 연결정보를 기반으로 가까운 n개의 점을 평균 또는 거리기반 가중평균예측을 수행할 수 있다. 실시예에 따라 메쉬 세분화 단계에서 현재 정점을 생성하기 위해 사용한 n개의 정점의 변위 벡터를 기반으로 예측을 수행할 수 있다. 세분화 레벨의 변위 벡터와 예측 변위 벡터 간 차를 통해 잔차신호를 생성할 수 있다.

[1043] Lifting transformation update unit: A process of updating the displacement vector of a vertex used for prediction can be performed using the residual signal generated in the lifting transformation prediction unit.

[1044] Lifting transformation update part: The lifting transformation update weight (updateWeight) can be derived using the vltp_log2_lifting_update_weight syntax.

[1045] The lifting transformation update process can perform updates by sharing the same weights for each LoD level of the mesh, or it can perform updates by using different weights for each LoD level of the mesh.

[1046] If adaptiveUpdateWeight, which determines whether to perform adaptive updates according to an embodiment, is 0, the same update weight can be used for each LoD level, and if it is 1, different adaptive updates can be performed for each LoD level according to the characteristics of the LoD level.

[1047] Displacement vector transform coefficient quantization unit: Quantization is performed on the transform coefficients transformed through the displacement vector transform unit.

[1048] Depending on the embodiment, the transform coefficients may be quantized through different quantization parameters for each axis, and the quantization rate may be determined for each LoD level by deriving quantization parameters or scaling parameters by a decoder / decoder agreement.

[1049] Atlas Encoding Unit: The atlas encoding unit can encode atlas information. An atlas can be information required for the mesh reconstruction process, and can also refer to information such as tiles and patches.

[1050] Atlas data may refer to data required in processes such as mesh decoding and mesh restoration, and may include segmentation methods, transformation methods, quantization methods, and the location and size of patches within the atlas frame.

[1051] Atlas information can be encoded using Exp-Golomb coding, etc.

[1052] Depending on the presence of displacement vector data, if displacement vector data does not exist, encoding of atlas parameters related to displacement vector data may be omitted, and if displacement vector data exists, atlas parameters related to displacement vector data may be encoded.

[1053] Parameters related to displacement vector data may be, depending on the embodiment, a displacement vector transformation method, a displacement vector quantization method, a subdivision method, a subdivision count, a displacement vector coordinate system, etc.

[1054] According to the displacement_present_flag indicating the presence of displacement vector data, if the flag is 0, i.e., if the displacement vector data does not exist, encoding of atlas data related to the displacement vector may be omitted. In some embodiments, if the displacement_present_flag flag is 0, the encoding process of syntax related to displacement vector data in ASPS (Atlas sequence parameter set), AFPS (Atlas frame parameter set), and meshpatch syntax may be omitted, and if it is 1, the encoding process of data related to displacement vector may be performed. In some embodiments, the decoding process of atlas parameters such as a subdivision method, a displacement vector coordinate system, and a displacement vector transformation method, which are meshpatch parameters related to displacement vector data, may be omitted.

[1055] Figure 22 shows an atlas data encoding process depending on the presence or absence of a displacement vector according to embodiments.

[1056] Fig. 22 is an example of an atlas data encoding process according to the presence or absence of a displacement vector. Data excluding data related to displacement vector data among the atlas information can be encoded first, and can be attribute 2D packing information, sub-mesh ID, texture coordinate derivation information, etc. After that, if the flag is 0 according to displacement_present_fla indicating the presence or absence of displacement vector data, i.e., if displacement vector data does not exist, the process of encoding information related to displacement vector data can be omitted, and if it is 1, information related to displacement vector data can be encoded.

[1057] Referring to FIG. 22, a method according to embodiments encodes atlas information other than displacement vector data. It is determined whether the displacement_present_flag value is 1. If the displacement_present_flag value is 1, information related to displacement vector data is encoded. If the displacement_present_flag value is not 1, the procedure is terminated. The overall process first encodes atlas information other than displacement vector data, and then checks the displacement_present_flag value. If the value is 1, information related to displacement vector data is additionally encoded, and if the value is not 1, the procedure is terminated.

[1058] Referring back to Figure 18, the dynamic mesh encoding process first simplifies the original mesh in the mesh simplification unit. The simplified mesh passes through the mesh parameterization unit to generate a base mesh. The base mesh is quantized in the mesh quantization unit. The quantized mesh encodes motion information in the motion vector encoding unit, and encodes vertex information in the vertex mesh encoding unit. The encoded information is restored in the base mesh decoding unit to generate a restored base mesh. The mesh is further refined in the mesh refinement unit, and the mesh fitting unit performs a fitting operation for deformation. The displacement vector is calculated in the displacement vector calculation unit, and coordinates are transformed in the displacement vector coordinate system transformation unit. The displacement vector is encoded in the displacement vector encoding unit, and the result is output as a displacement vector bitstream. The texture map generation unit generates a texture map, and the texture map encoding unit encodes it and outputs it as a texture map bitstream. Finally, the atlas encoding unit encodes the entire atlas to generate an atlas bitstream.

[1059] Figure 23 shows a dynamic mesh decoder according to embodiments.

[1060] Fig. 23 may refer to a decoding method / device according to embodiments (receiving device (110) of Fig. 1, receiving unit (111), file / segment decapsulator (112), mesh decoder (113), renderer (114), decoder of Figs. 11 and 13, bitstream and syntax parsing of Figs. 14 to 15, decoding of Figs. 17, decoding of Figs. 24 to 27, syntax acquisition of Figs. 28a and 28b to 44a, 44b and 44c, decoding method of Fig. 46, etc.). Fig. 23 may perform a reverse process of the dynamic mesh encoder of Fig. 18. The decoder may be composed of a memory and at least one processor connected to the memory.

[1061] Atlas Decoding Unit: The atlas decoding unit can decode atlas information. The decoded atlas can be used in the mesh decoding process. Depending on the embodiment, the process in which the atlas information is used may include a segmentation process, a displacement vector restoration process, etc., and may include information such as tiles and patches.

[1062] The atlas bitstream can be decoded using Exp-Golomb coding, etc.

[1063] Atlas can be information required in the mesh reconstruction process and can mean information such as tiles and patches.

[1064] Atlas data may refer to data required in processes such as mesh decoding and mesh restoration, and may include segmentation methods, transformation methods, quantization methods, and the location and size of patches within the atlas frame.

[1065] Atlas information can be encoded using Exp-Golomb coding, etc.

[1066] Depending on the presence of displacement vector data, if displacement vector data does not exist, atlas parameters related to displacement vector data may not be parsed, and if displacement vector data exists, atlas parameters related to displacement vector data may be decoded.

[1067] Parameters related to displacement vector data may be, depending on the embodiment, a displacement vector transformation method, a displacement vector quantization method, a subdivision method, a subdivision count, a displacement vector coordinate system, etc.

[1068] According to the displacement_present_flag indicating the presence of displacement vector data, if the flag is 0, i.e., if the displacement vector data does not exist, the process of decoding the syntax related to the displacement vector data in the ASPS (Atlas sequence parameter set), AFPS (Atlas frame parameter set), and meshpatch syntax may be omitted depending on the embodiment. If the displacement_present_flag is 1, the atlas syntax related to the displacement vector may be decoded. Depending on the embodiment, the process of decoding the atlas parameters related to the displacement vector data, such as the subdivision method, the displacement vector coordinate system, and the displacement vector transformation method, may be omitted.

[1069] Figure 24 shows an atlas data decoding process depending on the presence or absence of a displacement vector according to embodiments.

[1070] Figure 24 illustrates in more detail the atlas data decoding process included in Figure 23.

[1071] Fig. 24 is an example of an atlas data decoding process according to the presence or absence of a displacement vector. Data excluding data related to displacement vector data among the atlas information can be decoded first, and may include attribute 2D packing information, sub-mesh ID, texture coordinate derivation information, etc. After that, displacement_present_flag indicating the presence or absence of displacement vector data is parsed, and if the flag is 0, the displacement vector data does not exist, so the process of decoding information related to displacement vector data can be omitted, and if it is 1, information related to displacement vector data can be decoded.

[1072] Motion vector decoding unit: Motion vector decoding can be performed if the current mesh performs inter-screen prediction.

[1073] A residual motion vector can be decoded in units of vertices or subblocks through a motion vector bitstream, and a motion vector can be decoded by adding it to the residual motion vector by performing prediction based on connection information using a previously decoded motion vector as a predictor.

[1074] Static mesh decoding unit: The static mesh decoding unit can restore the connection information, vertex geometry information, vertex texture coordinates, normal information, etc. of the base mesh.

[1075] Base mesh restoration unit: If the current base mesh is encoded based on a reference mesh, the current base mesh can be restored by adding a motion vector to the reference base mesh and then performing inverse quantization.

[1076] If the current base mesh is decoded through a static mesh encoding unit, inverse quantization is performed to generate a restored base mesh. Depending on the embodiment, the inverse quantization unit may be omitted.

[1077] Mesh Subdivision: The mesh subdivision unit can generate additional vertices by performing subdivision on the base mesh. Depending on the subdivision method, geometric connection information, texture coordinate connection information, and texture coordinates can be implicitly derived and generated.

[1078] The mesh subdivision section can perform subdivision using methods such as mid-edge, Loop, and Catmul&Clark, depending on the embodiment.

[1079] Mesh refinement can be performed multiple times by user parameters or decoder / decoder agreement, and depending on the embodiment, the vertices of the base mesh are R0, the newly generated vertices are R1 by performing the 1st refinement, and the vertices generated by performing the nth refinement are R. n When defined as LoD n can be defined as follows:

[1080] LoD n =

[1081] Figure 25 illustrates a process of interpolating or calculating a subdivided vertex normal using restored vertex information according to embodiments.

[1082] Figure 25 illustrates in detail the process of generating the normal of the vertex included in Figure 23.

[1083] Referring to Fig. 25(a), the method according to the embodiments calculates the normal of the restored base mesh using restored vertex information. The restored base mesh is subdivided. The normal of the subdivided vertex is interpolated. Referring to Fig. 25(b), the method according to the embodiments subdivides the restored base mesh using restored vertex information. The normal of the subdivided vertex is calculated. The overall process is divided into a method (Fig. 25(a)) of first calculating the normal of the base mesh based on the restored vertex information, performing subdivision, and then interpolating the subdivided vertex normal, and a method (Fig. 25(b)) of first subdividing the base mesh using restored vertex information and then calculating the subdivided vertex normal, and both methods secure the normal information of the subdivided mesh.

[1084] Displacement vector coordinate system inverse transformation unit: The displacement vector coordinate system inverse transformation unit can perform inverse transformation of the inverse quantized restored displacement vector to the (x, y, z) coordinate axes when the coordinate system transformation flag (applyLocalCoord) parsed by sequence or GoF (group of frame) or frame or sub-mesh unit is 1.

[1085] At this time, the normal vector per vertex is calculated based on the restored vertex position information of the restored base mesh, and the normal value of the newly created vertex can be assigned by interpolating the calculated vertex normal vector of the restored base mesh for the vertex additionally created through the subdivision process. (Fig. 25(a))

[1086] In this case, interpolation can be performed by averaging or distance-based weighting the normal information of the base mesh used for subdivision.

[1087] According to an embodiment, after performing subdivision on a restored base mesh, normal vectors can be calculated for vertices generated through the subdivision section and vertices of the base mesh. (Fig. 25(b))

[1088] By calculating the tangential and bi-tangential vectors perpendicular to the normal vector through the calculated normal vector per vertex, the displacement vector coordinate system inverse transformation can be performed using the following formula.

[1089]

[1090] Depending on the embodiment, it is always possible to perform coordinate system inversion without sending flags.

[1091] Mesh restoration unit: The mesh restoration unit calculates the vertex position information of the restoration mesh by adding the restoration displacement vector to the vertices generated through the subdivision process in the mesh subdivision unit.

[1092] Texture map decoding unit: The texture map decoding unit may be a process of receiving a texture map bitstream as input and decoding the texture map.

[1093] Texture map decoder types include video decoder, zero run length decoder, and arithmetic decoder.

[1094] Depending on the embodiment, color space conversion of the texture map can be performed.

[1095] Figure 26 shows a displacement vector decoding process according to embodiments.

[1096] Figure 26 illustrates in detail the displacement vector decoding process of Figure 23.

[1097] Displacement vector transform coefficient decoding unit: The displacement vector transform coefficient decoding unit can perform displacement vector decoding through a 2D video decoder such as H.264, HEVC, VVC, etc., or decoding can be performed through a zero run length decoder or an arithmetic decoder.

[1098] The displacement vector transform coefficient decoding method can be determined by a specific decoding method through a sub / decoder agreement, or by receiving the encoding method determined by the encoder as a flag or index (dispEncType).

[1099] Displacement vector transform coefficient decoding methods may vary, and depending on the embodiment, one of {video codec-based decoding method, zero run-length decoding method}, {video codec-based decoding method, zero run-length decoding method}, {video codec-based decoding method, arithmetic decoding method}, video codec-based decoding method, zero run-length decoding method, and arithmetic decoding method may be determined through the dispEncType flag or index.

[1100] Depending on the embodiment, a displacement vector transform coefficient decoding method may be determined according to a profile defined in a decoder / decoder, and an index (profileToolsetIdx) indicating profile information may be transmitted so that the decoder can determine a displacement vector decoding method according to profileToolsetIdx.

[1101] If the displacement vector decoding method is a video codec-based decoding method, the displacement vector transform coefficient depacking unit may be a process of depacking a packed displacement vector transform coefficient frame.

[1102] In the displacement vector transform coefficient inverse packing unit, the inverse packing method can be derived in the same way as the unit / decoder, or the packing method can be transmitted and the decoder can determine the inverse packing method.

[1103] The reverse packing method may be in raster-scan order or in rectangular form, depending on the embodiment.

[1104] Displacement vector inverse quantization unit: The displacement vector inverse quantization unit can perform inverse quantization on displacement vectors.

[1105] Depending on the embodiment, the transform coefficients may be quantized through different quantization parameters for each axis, and the quantization rate may be determined for each LoD level by deriving quantization parameters or scaling parameters by a decoder / decoder agreement.

[1106] Referring to FIG. 26, the method according to the embodiments decodes the encoded displacement vector transform coefficient in the displacement vector transform coefficient decoding unit. The decoded transform coefficient is dequantized in the displacement vector dequantization unit to restore the original coefficient value. The displacement vector inverse transform unit uses the dequantized coefficient to restore the original displacement vector, thereby completing the entire restoration procedure.

[1107] Figure 27 shows a lifting inverse transformation update process according to embodiments.

[1108] Figure 27 illustrates in detail the lifting inverse transformation update process of Figure 23.

[1109] Displacement vector inverse transform unit: The displacement vector inverse transform unit can perform the inverse transform of the transform performed in the encoder.

[1110] Inverse transformation may be performed, depending on the embodiment, as lifting inverse transformation, wavelet inverse transformation, etc.

[1111] When lifting inverse transformation is performed, inverse transformation of the displacement vector can be performed through the embodiment of Fig. 15.

[1112] The number of lifting inverse transformations can be determined using the number of subdivision levels (lodCount) of the mesh.

[1113] The lifting inverse transformation process can be performed at each mesh subdivision level.

[1114] During the lifting inverse transformation process, a lifting inverse transformation prediction part and a lifting inverse transformation update part can be performed.

[1115] Lifting inverse transform prediction unit: The lifting inverse transform prediction unit can be performed on the displacement vector on which the lifting inverse transform update unit has been performed.

[1116] The lifting inverse prediction unit performs displacement vector prediction of the vertex R_k of the kth subdivision level, t(t <k 또는 t헽)번째 세분화 레벨의 정점 R_t의 변위 벡터를 예측자로 사용해 k번째 세분화 레벨의 변위벡터 예측을 수행할 수 있다. 실시예에 따라 변위벡터의 예측 수행 시 현재 정점보다 세분화 레벨이 낮은 정점 중 연결정보를 기반으로 가까운 n개의 점을 평균 또는 거리기반 가중평균예측을 수행할 수 있다.

[1117] In some embodiments, prediction can be performed based on the displacement vectors of n vertices used to generate the current vertex in the mesh refinement step. The displacement vectors of vertices at each refinement level can be reconstructed by summing the predicted displacement vectors with the parsed residual signals.

[1118] Lifting inverse transform update unit: The lifting inverse transform update unit can perform a process of updating the displacement vector of the vertex used for prediction through the parsed residual signal.

[1119] The lifting inverse transform update weight (updateWeight) can be derived with the vltp_log2_lifting_update_weight syntax.

[1120] The lifting inverse transformation update process can perform updates by sharing the same weights for each LoD level of the mesh, or it can perform updates by using different weights for each LoD level of the mesh.

[1121] If adaptiveUpdateWeight, which determines whether to perform adaptive updates according to an embodiment, is 0, the same update weight can be used for each LoD level, and if it is 1, different adaptive updates can be performed depending on the characteristics of the LoD level.

[1122] Referring to Fig. 27, the method according to the embodiments initializes the variable i to 0. Then, it is determined whether i is less than lodCount - 1. If the condition is true, the lifting inverse transform update unit performs an inverse transform update, and then the lifting inverse transform prediction unit performs a prediction. Then, the value of i is increased by 1, and the process is repeated by returning to the condition determination step. If i is greater than or equal to lodCount - 1, the procedure is terminated. Overall, this process consists of an iterative structure in which lifting inverse transform update and prediction are performed at each step while sequentially increasing i starting from 0, and the process is terminated after a given number of repetitions.

[1123] Referring back to FIG. 23, the method according to the embodiments performs motion vector decoding using a reference restoration base mesh. Vertex mesh decoding is performed using the reference restoration base mesh. The base mesh is restored through the outputs of the motion vector decoding unit and the vertex mesh decoding unit. The restored base mesh is subdivided in a mesh refinement unit. The output of the mesh refinement unit is restored in a mesh restoration unit. The displacement vector bitstream is decoded in a displacement vector decoding unit. The output of the displacement vector decoding unit is transformed into a coordinate system in a displacement vector coordinate system inversion unit. The texture map bitstream is decoded in a texture map decoding unit. The atlas bitstream is decoded in an atlas decoding unit. The overall process proceeds in the following order: decoding motion vectors and vertex meshes from the base mesh bitstream to restore the base mesh, subdividing it to perform mesh restoration, and decoding displacement vectors, texture maps, and atlas bitstreams to finally generate a restored mesh.

[1124] The encoding method and device according to the embodiments (Fig. 1, transmitting device (100), mesh encoder (102), file / segment encapsulator (103), transmitter (104), Figs. 2, 3, 4, 6, 7 pre-processor, encoder, Fig. 12 encoder, Figs. 14 to 15 bitstream and syntax generation, Figs. 18 to 22 encoding, Figs. 28a and 28b to Figs. 44a, 44b, and 44c syntax generation, Fig. 45 encoding method, etc.) can encode mesh data and generate a bitstream including the encoded mesh data. In addition, signaling information (which may be referred to as parameter information, syntax elements, etc.) regarding the mesh data can be generated and included in the bitstream.

[1125] The decoding method / device according to the embodiments (receiving device (110) in FIG. 1, receiving unit (111), file / segment decapsulator (112), mesh decoder (113), renderer (114), decoder in FIG. 11, FIG. 13, bitstream and syntax parsing in FIG. 14 to FIG. 15, decoding in FIG. 16 to FIG. 17, decoding in FIG. 23 to FIG. 27, syntax acquisition in FIG. 28a and FIG. 28b to FIG. 44a, FIG. 44b and FIG. 44c, decoding method in FIG. 46, etc.) can obtain a bitstream, obtain syntax information (syntax element) from the bitstream, and decode mesh data based on the syntax information.

[1126] Hereinafter, the syntax and semantics within the bitstream are described with reference to FIGS. 28a and 28b to FIGS. 41a and 41b.

[1127] Figures 28a and 28b illustrate ASPS VDMC extension syntax according to embodiments.

[1128] Atlas sequence parameter set V-DMC extension syntax:

[1129] The method according to the embodiments can signal information necessary for the process of decoding and restoring displacement vector data only when displacement vector data exists according to the flag by signaling a flag indicating whether or not a displacement vector exists with an atlas syntax signaled at the sequence level.

[1130] The method for deriving the presence of a displacement vector may, depending on the embodiment, signal a flag indicating the presence of a displacement vector, or may derive the presence of displacement vector data using a syntax capable of deriving the presence of a displacement vector within ASPS (atlas sequence parameter set V-DMC extension).

[1131] Figures 28a and 28b illustrate a case in which a flag indicating the presence or absence of displacement vector data according to embodiments is added.

[1132] Figures 29a and 29b illustrate ASPS VDMC extension syntax according to embodiments.

[1133] Atlas sequence parameter set V-DMC extension semantics:

[1134] asve_displacement_present_flag is a flag indicating whether displacement vector data exists. If the flag is 1, it can indicate that displacement data exists, and if it is 0, it can indicate that displacement data does not exist.

[1135] Figures 29a and 29b illustrate a case in which a syntax capable of inducing the presence or absence of displacement vector data is used among ASPS syntax according to embodiments.

[1136] Asve_subdivision_iteration_count is a syntax that indicates the number of times subdivision is performed during the subdivision process. If the subdivision iteration count is 0, it can indicate that no subdivision is performed. If no subdivision is performed, it can induce that displacement vector data does not exist. Depending on the embodiment, if the subdivision method is None, it can indicate that no subdivision is performed and can also induce that displacement vector data does not exist.

[1137] Figures 30a and 30b illustrate AFPS VDMC extension syntax according to embodiments.

[1138] Atlas frame parameter set V-DMC extension syntax:

[1139] An atlas syntax signaled at the frame level can signal information necessary for decoding and restoring displacement vector data only when displacement vector data exists, based on a flag indicating the presence of a displacement vector.

[1140] The method for deriving the existence of a displacement vector can be implemented by inheriting a flag indicating the existence of a displacement vector from the ASPS syntax, or by utilizing an existing syntax that can induce the existence of displacement vector data among the AFPS (Atlas frame parameter set V-DMC extension) syntaxes.

[1141] Figures 30a and 30b illustrate a case in which the ASPS syntax indicating the presence or absence of displacement vector data according to embodiments is inherited and used.

[1142] Figures 31a and 31b illustrate AFPS VDMC extension syntax according to embodiments.

[1143] The method according to the embodiments may generate the following syntax when using a syntax that can induce the presence or absence of displacement vector data among the ASPS syntax according to the embodiments.

[1144] AspsSubdivisionCount can mean the subdivision iteration count derived from ASPS syntax, and when AspsSubdivisionCount is 0, i.e., when no subdivision is performed, it can be derived that there is no displacement vector data.

[1145] Figures 32a and 32b illustrate AFPS VDMC extension syntax according to embodiments.

[1146] The method according to the embodiments may use a syntax that can induce the presence or absence of displacement vector data among AFPS syntax.

[1147] Figures 33a, 33b and 33c illustrate mesh patch data unit syntax according to embodiments.

[1148] The method according to the embodiments may be signaled as follows based on the Meshpatch data unit syntax.

[1149] Atlas syntax signaled at the mesh patch level allows signaling of information necessary for decoding and restoring displacement vector data only when the displacement vector data exists, based on a flag indicating the presence of the displacement vector.

[1150] The method for inducing the presence of a displacement vector may, depending on the embodiment, signal a flag indicating the presence of a displacement vector, or may induce the presence of displacement vector data using a syntax capable of inducing the presence of a displacement vector among the Meshpatch data unit syntax or inherited syntaxes.

[1151] The method according to the embodiments can be used by inheriting ASPS syntax that indicates the presence or absence of displacement vector data.

[1152] Figures 34a, 34b and 34c illustrate mesh patch data unit syntax according to embodiments.

[1153] The method according to the embodiments may use a syntax that can induce the presence or absence of displacement vector data among AFPS syntax.

[1154] AfpsSubdivisonCount can mean the subdivision iteration count derived from the AFPS syntax, and if AfpsSubdivisonCount is 0, i.e., if no subdivision is performed, it can be derived that there is no displacement vector data.

[1155] Figures 35a, 35b and 35c illustrate mesh patch data unit syntax according to embodiments.

[1156] The method according to the embodiments may use a syntax that can induce the presence or absence of displacement vector data among meshpatch syntax.

[1157] Figure 36 illustrates a merge mesh patch data unit syntax according to embodiments.

[1158] The method according to the embodiments can signal information necessary for the process of decoding and restoring displacement vector data only when displacement vector data exists according to a flag indicating the presence or absence of a displacement vector, with respect to the merge meshpatch data unit syntax, in the atlas syntax signaled at the merge mesh patch level.

[1159] The method for inducing the presence of a displacement vector may, depending on the embodiment, signal a flag indicating the presence of a displacement vector, or may induce the presence of displacement vector data using a syntax capable of inducing the presence of a displacement vector among the Meshpatch data unit syntax or inherited syntaxes.

[1160] The method according to the embodiments can be used by inheriting ASPS syntax that indicates the presence or absence of displacement vector data.

[1161] Figure 37 illustrates a merge mesh patch data unit syntax according to embodiments.

[1162] The method according to the embodiments may use a syntax that can induce the presence or absence of displacement vector data among AFPS syntax.

[1163] AfpsSubdivisonCount can mean the subdivision iteration count derived from the AFPS syntax, and if AfpsSubdivisonCount is 0, i.e., if no subdivision is performed, it can be derived that there is no displacement vector data.

[1164] Figure 38 illustrates a merge mesh patch data unit syntax according to embodiments.

[1165] The method according to the embodiments may use a syntax that can induce the presence or absence of displacement vector data among meshpatch syntax.

[1166] If the subdivision count is 0, that is, the number of subdivisions is 0, it may mean that there is no displacement vector data, and in this case, data related to the displacement vector data may be omitted.

[1167] Figures 39a and 39b illustrate inter-mesh patch data unit syntax according to embodiments.

[1168] The method according to the embodiments can signal information necessary for the process of decoding and restoring displacement vector data only when displacement vector data exists according to a flag indicating the presence or absence of a displacement vector, with an atlas syntax signaled at the mesh patch level.

[1169] The method for deriving the presence of a displacement vector may, depending on the embodiment, signal a flag indicating the presence of a displacement vector, or may derive the presence of displacement vector data using a syntax capable of deriving the presence of a displacement vector among inter meshpatch data unit syntax or inherited syntax.

[1170] The method according to the embodiments can be used by inheriting ASPS syntax that indicates the presence or absence of displacement vector data.

[1171] Figures 40a and 40b illustrate inter-mesh patch data unit syntax according to embodiments.

[1172] The method according to the embodiments may use a syntax that can induce the presence or absence of displacement vector data among AFPS syntax.

[1173] AfpsSubdivisonCount can mean the subdivision iteration count derived from the AFPS syntax, and if AfpsSubdivisonCount is 0, i.e., if no subdivision is performed, it can be derived that there is no displacement vector data.

[1174] Figures 41a and 41b illustrate inter-mesh patch data unit syntax according to embodiments.

[1175] The method according to the embodiments may use a syntax that can induce the presence or absence of displacement vector data among meshpatch syntax.

[1176] If the subdivision iteration count is 0, that is, the number of subdivisions is 0, it means that there is no displacement vector data, so if it is 0, data information related to the displacement vector data can be omitted.

[1177] Based on the syntax of FIGS. 28a and 28b to 41a and 41b, the operations of the encoder and decoder described in FIGS. 18 to 23 can be performed.

[1178] The method and device according to the embodiments may further include and perform a meshpatch decoding method for displacement vector data of a dynamic mesh.

[1179] The decoding procedure for meshpatch data units according to embodiments may be described with reference to ISO / IEC 23090-29 (ISO / IEC JTC 1 / SC 29 / WG 07 N0960 Study of technologies for Video-based mesh coding). Section 9.2.8 in the document specifies the decoding process for meshpatch data units.

[1180] A bitstream according to embodiments may have the following restrictions.

[1181] if(!asve_displacement_id_present_flag){

[1182] TileMeshpatch2dPosX[ tileID ][ p ] + TileMeshpatch2dSizeX[ tileID ][ p ] <=

[1183] horLimit (1)

[1184] TileMeshpatch2dPosY[ tileID ][ p ] + TileMeshpatch2dSizeY[ tileID ][ p ] <=

[1185] verLimit (2)

[1186] }

[1187] for( attrIdx = 0; attrIdx < asve_num_attribute_video; attrIdx){

[1188] TileMeshpatchAttributes2dPosX[ tileID ][ p ] +

[1189] TileMeshpatchAttributes2dSizeX[ tileID ][ p ] <= horLimitAtt[ attrIdx ]

[1190] TileMeshpatchAttributes2dPosY[ tileID ][ p ] +

[1191] TileMeshpatchAttributes2dSizeY[ tileID ][ p ] <= verLimitAtt[ attrIdx ]

[1192] }

[1193] The aforementioned mesh patch related variables according to the embodiments may further include the following.

[1194] TileMeshpatchLoDIdx[ tileID ][ p ] specifies the LOD index for the current mesh patch with patch index p in the current tile. The tile ID is equal to tileID.

[1195] TileMeshpatchSubdivMethod[ tileID ][ p ][ i ] specifies the subdividing method for the i-th subdividing iteration for the current mesh patch with patch index p in the current tile whose current tile ID is equal to tileID.

[1196] TileMeshpatchLiftingOffset[ tileID ][ p ][ i ] specifies the lifting offset value of the i-th subdivision iteration for the current mesh patch whose patch index is p in the current tile whose tile ID is equal to tileID.

[1197] TileMeshpatchLiftingOffsetNum[ tileID ][ p ][ i ] specifies the numerator of the lifting offset value of the ith subdivision iteration for the current mesh patch with patch index p in the current tile whose current tile ID is equal to tileID.

[1198] TileMeshpatchLiftingOffsetDeno[ tileID ][ p ][ i ] specifies the denominator of the lifting offset value of the ith subdivision iteration for the current mesh patch with patch index p in the current tile whose current tile ID is equal to tileID.

[1199] TileMeshpatchSubpatch2dBiasX[ tileID ][ p ][ i ] specifies the x-coordinate of the lower-left corner of the projected 3D bounding box for the subpatch with index i of the current mesh patch with patch index p in the current tile with tile ID tileID.

[1200] TileMeshpatchSubpatch2dBiasY[ tileID ][ p ][ i ] specifies the y-coordinate of the lower-left corner of the projected 3D bounding box for the subpatch with index i of the current mesh patch with patch index p in the current tile with tile ID tileID.

[1201] Mesh patch related variables according to the embodiments can be set as follows.

[1202] TileMeshpatch2dPosX[tileID][p] = 0

[1203] TileMeshpatch2dPosY[tileID][p] = 0

[1204] TileMeshpatch2dSizeX[tileID][p] = 1

[1205] TileMeshpatch2dSizeY[tileID][p] = 1

[1206]

[1207] for( attrIdx = 0; attrIdx < asve_num_attribute_video; attrIdx){

[1208] TileMeshpatchAttributes2dPosX[tileID][p] = 0

[1209] TileMeshpatchAttributes2dPosY[tileID][p] = 0

[1210] TileMeshpatchAttributes2dSizeX[tileID][p] = 1

[1211] TileMeshpatchAttributes2dSizeY[tileID][p] = 1

[1212] }

[1213] TileMeshpatchSubmeshID[tileID][p] = 0

[1214] TileMeshpatchDisplID[tileID][p] = 0

[1215] TileMeshpatchLodIdx[tileID][p] = 0

[1216] TileMeshpatchVertexCount[tileID][p] = 0

[1217] TileMeshpatchFaceCount[tileID][p] = 0

[1218] TileMeshpatchSubdivCount[tileID][p] = 0

[1219] TileMeshpatchDispCoordSys[tileID][p] = 0

[1220] TileMeshpatchTransformMethod[tileID][p] = 0

[1221] TileMeshpatchLiftingOffset[tileID][p] = 0

[1222] TileMeshpatchFrameScale[tileID][p] = 1

[1223] TileMeshpatchNumSubpatches[tileID][p] = 0

[1224] The decoding procedure for the mesh patch data units coded in the aforementioned intra mode may include the following procedures.

[1225] The inputs to this process are the current patch index p and the current tile ID tileID.

[1226] The following meshpatch-related variables are assigned according to the parsed elements of the meshpatch data unit.

[1227] TileMeshpatchSubmeshID[ tileID ][ p ] = mdu_submesh_id[ tileID ][ p ]

[1228] TileMeshpatchLoDIdx[ tileID ][ p ] = mdu_lod_idx[ tileID ][ p ]

[1229] TileMeshpatchSubdivCount[ tileID ][ p ] = PatchSubdivisionCount[ tileID ][ p ]

[1230] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){

[1231] TileMeshpatchSubdivMethod[tileID][p][i] =

[1232] PatchSubdivisionMethod[tileID][patchIdx][i]

[1233] }

[1234] If asve_displacement_present_flag, a flag indicating the presence of displacement data, is 1, i.e., if displacement data exists, the meshpatch data unit syntax related to displacement data can be parsed.

[1235] If asve_displacement_present_flag is 1, the following meshpatch-related variables are allocated, taking into account the parsed elements of the meshpatch data unit.

[1236] TileMeshpatchDispCoordSys[tileID][p] =

[1237] mdu_displacement_coordinate_system[tileID][p]

[1238] TileMeshpatchTransformMethod[ tileID ][ p ]= mdu_transform_method[ tileID ][ p ]

[1239] asve_displacement_id_present_flag가 0이고 asve_displacement_present_flag가 1이면 다음이 적용된다.

[1240] TileMeshpatchFaceCount[ tileID ][ p ] =

[1241] mdu_face_count_minus1[ tileID ][ p ] + 1

[1242] TileMeshpatch2dPosX[ tileID ][ p ] =

[1243] mdu_2d_pos_x[ tileID ][ p ] * PatchPackingBlockSize (3)

[1244] TileMeshpatch2dPosY[ tileID ][ p ] =

[1245] mdu_2d_pos_y[ tileID ][ p ] * PatchPackingBlockSize (4)

[1246] TileMeshpatch2dSizeX[ tileID ][ p ] =

[1247] (mdu_2d_size_x_minus1[ tileID ][ p ] + 1) * PatchSizeXQuantizer (5)

[1248] TileMeshpatch2dSizeY[ tileID ][ p ] =

[1249] (mdu_2d_size_y_minus1[ tileID ][ p ] + 1) * PatchSizeYQuantizer (6)

[1250] if( asve_displacement_id_present_flag || ( asve_lod_patches_enable_flag == 0 ) ) {

[1251] vertexInfoCount = TileSubdivisionCount[ tileID ][ p ] + 1

[1252] } else {

[1253] vertexInfoCount = 1

[1254] }

[1255] for( i=0; i< vertexInfoCount; i++){

[1256] TilePatchVertexBlockCount[ tileID ][ p ][ i ] =

[1257] mdu_last_pos_in_block[ tileID ][ patchIdx ][ i ] == 0 ?

[1258] (mdu_block_count_minus1[ tileID ][ patchIdx ][ i ] + 1) :

[1259] mdu_block_count_minus1[ tileID ][ patchIdx ][ i ]

[1260] TilePatchVertexCountLast[ tileID ][ p ][ i ] =

[1261] mdu_last_pos_in_block[ tileID ][ patchIdx ][ i ]

[1262] TilePatchVertexCount[ tileID ][ p ][ i ] =

[1263] TilePatchVertexBlockCount[ tileID ][ p ][ i ] *

[1264] PatchPackingBlockSize * PatchPackingBlockSize +

[1265] TilePatchVertexCountLast[tileID][patchIdx][i]

[1266] TilePatchTotalVertexCount[tileID][p] +=

[1267] TilePatchVertexCount[tileID][p][i]

[1268] }

[1269] If asve_displacement_id_present_flag is 1 and asve_displacement_present_flag is 1, the following applies:

[1270] TileMeshpatchDisplID[tileID][p] = mdu_displ_id[tileID][p]

[1271] If asve_lifting_offset_present_flag is 1 and asve_displacement_present_flag is 1, the following applies:

[1272] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){

[1273] TileMeshpatchLiftingOffsetNum[ tileID ][ p ] [ i ] =

[1274] mdu_lifting_offset_values_num[tileID][p] [i]

[1275] TileMeshpatchLiftingOffsetDeno[tileID][p][i] =

[1276] (mdu_lifting_offset_values_deno_minus1[ tileID ][ p ] [ i ] + 1)

[1277] TileMeshpatchLiftingOffset[tileID][p][i] =

[1278] TileMeshpatchLiftingOffsetNum[ tileID ][ p ] [ i ] χ

[1279] TileMeshpatchLiftingOffsetDeno[ tileID ][ p ] [ i ]

[1280] If asve_lifting_offset_present_flag is 0 and asve_displacement_present_flag is 1, the following applies:

[1281] TileMeshpatchLiftingOffset[tileID][p] = 0

[1282] If asve_num_attribute_video is greater than 0 and TileMeshpatchLoDIdx[ tileID ][ p ] is 0, the following applies:

[1283] for( i = 0; i< asve_num_attribute_video; i++ ){

[1284] if(asve_attribute_subtexture_enabled_flag[ i ]){

[1285] TileMeshpatchAttributes2dPosX[tileID][p][i] =

[1286] mdu_attributes_2d_pos_x[tileID][p][i]

[1287] TileMeshpatchAttributes2dPosY[tileID][p][i] =

[1288] mdu_attributes_2d_pos_y[ tileID ][ p ][ i ]

[1289] TileMeshpatchAttributes2dSizeX[ tileID ][ p ][ i ] =

[1290] (mdu_attributes_2d_size_x_minus1[ tileID ][ p ][ i ] + 1) *PatchSizeYQuantizer

[1291] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ i ] =

[1292] (mdu_attributes_2d_size_y_minus1[ tileID ][ p ][ i ] + 1) * PatchSizeYQuantizer

[1293] }else{

[1294] TileMeshpatchAttributes2dPosX[ tileID ][ p ][ i ] = 0

[1295] TileMeshpatchAttributes2dPosY[ tileID ][ p ][ i ] = 0

[1296] TileMeshpatchAttributes2dSizeX[ tileID ][ p ][ i ] =

[1297] TileWidthAtt[ attrIdx ][ TileIDToIndexAtt[ attrIdx ][ tileID ] ]

[1298] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ i ] =

[1299] TileHeightAtt[ attrIdx ][ TileIDToIndexAtt[ attrIdx ][ tileID ] ]

[1300] }

[1301] }

[1302] smIdx = SubmeshIDToIndex[ TileMeshpatchSubmeshID[ tileID ][ p ] ]

[1303] TileMeshpatchTexcoordProjectionFlag[tileID][p] = TexcoordProjectionFlag[smIdx]

[1304] TileMeshpatchTexcoordProjectionWidthNormalization[ tileID ][ p ] =

[1305] TexcoordProjectionWidthNormalization[ smIdx ]

[1306] TileMeshpatchTexcoordProjectionHeightNormalization[ tileID ][ p ] =

[1307] TexcoordProjectionHeightNormalization[ smIdx ]

[1308] TileMeshpatchTexcoordProjectionGutter[ tileID ][ p ] =

[1309] TexcoordProjectionGutter[ smIdx ]

[1310] If TileMeshpatchTexcoordProjectionFlag[ tileID ][ p ] is 1 and TileMeshpatchLoDIdx[ tileID ][ p ] is 0, the decoding of texture projection information specified in subsection 9.2.8.3 is called with p and tileID as input.

[1311] The decoding procedure for texture projection information according to embodiments may further include the following procedure.

[1312] The inputs to this process are the patch index p and the current tile ID tileID.

[1313] TileMeshpatchFrameScale[ tileID ][ p ] =

[1314] ( tpi_frame_upscale_minus1[ tileID ][ p ] + 1 ) / ( 2tpi_log2_frame_downscale[ tileID ][ p ] )

[1315] TileMeshpatchNumSubpatches[ tileID ][ p ] =

[1316] tpi_subpatch_count_minus1[ tileID ][ p ] + 1 (7)

[1317] for( i = 0; i < TileMeshpatchNumSubpatches[ tileID ][ p ]; i++ ){

[1318] if( tpi_face_id_present_flag[ tileID ][ p ] )

[1319] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] =

[1320] si_face_id[ tileID ][ p ][ i ]

[1321] else

[1322] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] = i

[1323] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ] =

[1324] si_projection_id[ tileID ][ p ][ i ] (8)

[1325] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ] =

[1326] si_orientation_id[ tileID ][ p ][ i ] (9)

[1327] TileMeshpatchSubpatch2dPosX[ tileID ][ i ][ p ] =

[1328] si_2d_pos_x[ tileID ][ p ][ i ] (10)

[1329] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ] =

[1330] si_2d_pos_y[ tileID ][ p ][ i ] (11)

[1331] if( asve_projection_texcoord_bbox_bias_enable_flag )

[1332] TileMeshpatchSubpatch2dBiasX[ tileID ][ p ][ i ] =

[1333] si_2d_bias_x[ tileID ][ p ][ i ] (12)

[1334] TileMeshpatchSubpatch2dBiasY[ tileID ][ p ][ i ] =

[1335] si_2d_bias_y[ tileID ][ p ][ i ] (13)

[1336] if( i > 0 ) {

[1337] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[1338] ( si_2d_size_x_minus1_diff[ tileID ][ p ][ i ] +

[1339] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i - 1 ] )

[1340] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[1341] ( si_2d_size_y_minus1_diff[ tileID ][ p ][ i ] +

[1342] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i - 1 ] )

[1343] } else {

[1344] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[1345] ( si_2d_size_x_minus1_diff[ tileID ][ p ][ i ] + 1 )

[1346] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[1347] ( si_2d_size_y_minus1_diff[ tileID ][ p ][ i ] + 1 )

[1348] }

[1349] } else {

[1350] TileMeshpatchSubpatch2dBiasX[ tileID ][ p ][ i ] = 0

[1351] TileMeshpatchSubpatch2dBiasY[ tileID ][ p ][ i ] = 0

[1352] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] = 0

[1353] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] = 0

[1354] }

[1355] TileMeshpatchSubpatchScale[tileID][p][i] =

[1356] SubpatchScale[tileID][p][i] (18)

[1357] }

[1358] The decoding procedure for meshpatch data units coded in skip prediction mode according to embodiments may further include the following procedure.

[1359] The inputs to this process are the current patch index p and the current tile ID tileID.

[1360] First, refIdx is set to 0.

[1361] Then, the reference atlas frame refAtlasFrm is selected as the atlas frame corresponding to the ( refIdx + 1 )th entry of the reference atlas frame list RefAtlasFrmList, RefAtlasFrmList[ refIdx ].

[1362] If p is 0, PredictorIdx is set to 0.

[1363] The variable RefPatchIdx, which corresponds to the predicted patch index of the tile with the same ID as tileID in the reference atlas frame refAtlasFrm, is computed as follows:

[1364] RefPatchIdx = PredictorIdx (19)

[1365] and PredictorIdx is set to RefPatchIdx + 1.

[1366] The process described in subsection 9.2.8.6.2.1 is called with the variables refIdx, RefPatchIdx, and tileID as input, and the output is the variables refMeshpatch2dPosX, refMeshpatch2dPosY, refMeshpatch2dSizeX, refMeshpatch2dSizeY, refMeshpatchSubmeshID, refMeshpatchLoDIdx, refMeshpatchLiftingOffsetNum, refMeshpatchLiftingOffsetDeno, refMeshpatchLiftingOffset, refMeshpatchVertexCount, refMeshpatchFaceCount, refMeshpatchSubdivMethod, refMeshpatchSubdivCount, refMeshpatchDispCoordSys, refMeshpatchTransformMethod, and refMeshpatchVertexblockCount, The refMeshpatchVertexCountLast, refMeshpatchAttributes2dPosX, refMeshpatchAttributes2dPosY, refMeshpatchAttributes2dSizeX and refMeshpatchAttributes2dSizeY arrays.

[1367] The following parameters are derived:

[1368] TileMeshpatchSubmeshID[tileID][p] = refMeshpatchSubmeshID (20)

[1369] TileMeshpatchLoDIdx[ tileID ][ p ] = refMeshpatchLoDIdx (21)

[1370] If asve_displacement_present_flag, a flag indicating the presence of displacement data, is 1, i.e., if displacement data exists, the meshpatch data unit syntax coded in skip mode related to displacement data can be parsed.

[1371] If asve_displacement_id_present_flag is 0 and asve_displacement_present_flag is 1, the following applies:

[1372] TileMeshpatchVertexCount[tileID][p] = refMeshpatchVertexCount (22)

[1373] TileMeshpatchFaceCount[tileID][p] = refMeshpatchFaceCount (23)

[1374] TileMeshpatch2dPosX[ tileID ][ p ] = refMeshpatch2dPosX (24)

[1375] TileMeshpatch2dPosY[ tileID ][ p ] = refMeshpatch2dPosY (25)

[1376] TileMeshpatch2dSizeX[ tileID ][ p ] = refMeshpatch2dSizeX (26)

[1377] TileMeshpatch2dSizeY[ tileID ][ p ] = refMeshpatch2dSizeY (27)

[1378] If TileMeshpatchLoDIdx[ tileID ][ p ] is equal 0, the following applies:

[1379] TileMeshPatchSubdivCount [ tileID ][ p ] = refMeshPatchSubdivCount

[1380] for( i = 0 ; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){ .

[1381] TileMeshpatchSubdivMethod[ tileID][p][i] = refMeshpatchSubdivMethod[i](28);

[1382] }}

[1383] If TileMeshpatchLoDIdx[ tileID][p] is equal to 0, the following applies:

[1384]

[1385] TileMeshpatchDispCoordSys[ tileID][p] = refMeshpatchDispCoordSys(29);

[1386] TileMeshpatchTransformMethod [ tileID ][ p ] = refMeshpatchTransformMethod

[1387] asve_lifting_offset_present_flag 1 month asve_displacement_present_flag 1 year.

[1388] for( i = 0 ; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){ .

[1389] TileMeshPatchLiftingOffsetNum [ tileID ][ p ] [ i ] =

[1390] refMeshPatchLiftingOffsetNum[ i ] .

[1391] TileMeshpatchLiftingOffsetDeno[tileID][p][i] =

[1392] refMeshpatchLiftingOffsetDeno[i]

[1393] TileMeshpatchLiftingOffset[tileID][p][i] =

[1394] refMeshpatchLiftingOffset[ i ]

[1395] If asve_lifting_offset_present_flag is 0 and asve_displacement_present_flag is 1, the following applies:

[1396] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ )

[1397] TileMeshpatchLiftingOffset[tileID][p][i] = 0

[1398] If asve_displacement_present_flag is 1, the vertex information is derived as follows.

[1399] if ( asve_displacement_id_present_flag || ( asve_lod_patches_enable_flag == 0 ) ) {

[1400] vertexInfoCount = TileMeshpatchSubdivCount[tileID][p] + 1

[1401] } else {

[1402] vertexInfoCount = 1

[1403] }

[1404] for( i=0; i< vertexInfoCount; i++){

[1405] TilePatchVertexBlockCount[tileID][p][i] =

[1406] refMeshatchVertexBlockCount[i]

[1407] TilePatchVertexCountLast[ tileID ][ p ][ i ] = refMeshpatchVertexCountLast[ i ]

[1408] TilePatchVertexCount[tileID][p][i] =

[1409] TilePatchVertexBlockCount[tileID][p][i] *

[1410] PatchPackingBlockSize * PatchPackingBlockSize +

[1411] TilePatchVertexCountLast[tileID][patchIdx][i]

[1412] TilePatchTotalVertexCount[tileID][p] +=

[1413] TilePatchVertexCount[tileID][p][i]

[1414] }

[1415] If asve_displacement_id_present_flag is 1 and asve_displacement_present_flag is 1, the following applies:

[1416] TileMeshpatchDisplID[tileID][p] = refMeshpatchDisplID (31)

[1417] If TileMeshpatchLoDIdx[ tileID ][ p ] is 0, the associated attribute 2D parameters are derived as follows:

[1418] for( i = 0; i< asve_num_attribute_video; i++ ){

[1419] TileMeshpatchAttributes2dPosX[ tileID ][ p ][ i ] =

[1420] refMeshpatchAttributes2dPosX[ i ]

[1421] TileMeshpatchAttributes2dPosY[ tileID ][ p ][ i ] =

[1422] refMeshpatchAttributes2dPosY[ i ]

[1423] TileMeshpatchAttributes2dSizeX[ tileID ][ p ][ i ] =

[1424] refMeshpatchAttributes2dSizeX[ i ]

[1425] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ i ] =

[1426] refMeshpatchAttributes2dSizeY[ i ]

[1427] }

[1428] smIdx = SubmeshIDToIndex[ TileMeshpatchSubmeshID[ tileID ][ p ] ]

[1429] TileMeshpatchTexcoordProjectionFlag[ tileID ][ p ] = TexcoordProjectionFlag[ smIdx ]

[1430] TileMeshpatchTexcoordProjectionWidthNormalization[ tileID ][ p ] =

[1431] TexcoordProjectionWidthNormalization[ smIdx ]

[1432] TileMeshpatchTexcoordProjectionHeightNormalization[ tileID ][ p ] =

[1433] TexcoordProjectionHeightNormalization[ smIdx ]

[1434] TileMeshpatchTexcoordProjectionGutter[ tileID ][ p ] =

[1435] TexcoordProjectionGutter[ smIdx ]

[1436] If TileMeshpatchTexcoordProjectionFlag[ tileID ][ p ] is 1 and TileMeshpatchLoDIdx[ tileID ][ p ] is 0, the process of subclause 9.2.8.6.2.2 is called with p and tileID as input, and the outputs are the variables refMeshpatchFrameScale and refMeshpatchNumSubpatches, the 1D arrays refMeshpatchSubpatchIdxToFaceId, refMeshpatchSubpatchProjectionID, refMeshpatchSubpatchOrientationID, refMeshpatchSubpatch2dPosX, refMeshpatchSubpatch2dPosY, refMeshpatchSubpatch2dBiasX, refMeshpatchSubpatch2dBiasY, refMeshpatchSubpatch2dSizeX refMeshpatchSubpatch2dSizeY, and This is refMeshpatchSubpatchScale.

[1437] Then, the texture projection information is derived as follows.

[1438] TileMeshpatchFrameScale[ tileID ][ p ] = refMeshpatchFrameScale

[1439] TileMeshpatchNumSubpatches[ tileID ][ p ] = refMeshpatchNumSubpatches

[1440] for( i = 0; i < TileMeshpatchNumSubpatches[ tileID ][ p ]; i++ ){

[1441] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] =

[1442] refMeshpatchSubpatchIdxToFaceId,[ i ]

[1443] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ] =

[1444] refMeshpatchSubpatchProjectionID[ i ]

[1445] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ] =

[1446] refMeshpatchSubpatchOrientationID[ i ]

[1447] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ i ] =

[1448] refMeshpatchSubpatch2dPosX[ i ]

[1449] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ] =

[1450] refMeshpatchSubpatch2dPosY[ i ]

[1451] TileMeshpatchSubpatch2dBiasX[ tileID ][ p ][ i ] =

[1452] refMeshpatchSubpatch2dBiasX[ i ]

[1453] TileMeshpatchSubpatch2dBiasY[tileID][p][i] =

[1454] refMeshpatchSubpatch2dBiasY[ i ] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[1455] refMeshpatchSubpatch2dSizeX[ i ]

[1456] TileMeshpatchSubpatch2dSizeY[tileID][p][i] =

[1457] refMeshpatchSubpatch2dSizeY [i]

[1458] TileMeshpatchSubpatchScale[tileID][p][i] =

[1459] refMeshpatchSubpatchScale[ i ]

[1460] }

[1461] The decoding procedure for meshpatch data units coded in merge prediction mode according to embodiments further includes the following procedure.

[1462] The inputs to this process are the current patch index p and the current tile ID tileID.

[1463] First, the reference atlas frame index refIdx is derived as mmdu_ref_index[ tileID ][ p ].

[1464] Then, the reference atlas frame refAtlasFrm is selected as the atlas frame corresponding to the ( refIdx + 1 )th entry of the reference atlas frame list RefAtlasFrmList, RefAtlasFrmList[ refIdx ].

[1465] If p is 0, PredictorIdx is set to 0.

[1466] Then, the predicted patch index RefPatchIdx of the tile with the same ID as the tile ID in the reference atlas frame refAtlasFrm is calculated as follows:

[1467] RefPatchIdx = PredictorIdx + mmdu_patch_index[tileID][p] (32)

[1468] and PredictorIdx is set to RefPatchIdx + 1.

[1469] The process described in subclause 9.2.8.6.2.1 is called with variables refIdx, RefPatchIdx and tileID as input and outputs variables refMeshpatch2dPosX, refMeshpatch2dPosY, refMeshpatch2dSizeX, refMeshpatch2dSizeY, refMeshpatchSubmeshID, refMeshpatchVertexCount, refMeshpatchFaceCount, refMeshpatchSubdivMethod, refMeshpatchSubdivCount, refMeshpatchDispCoordSys, refMeshpatchTransformMethod, 1D arrays refMeshatchVertexBlockCount, refMeshpatchVertexCountLast, refMeshpatchAttributes2dPosX, refMeshpatchAttributes2dPosY, refMeshpatchAttributes2dSizeX, These are refMeshpatchAttributes2dSizeY, refMeshpatchLiftingOffsetNum, and refMeshpatchLiftingOffsetDeno.

[1470] The following parameters are derived:

[1471] TileMeshpatchSubmeshID[tileID][p] = refMeshpatchSubmeshID (33)

[1472] TileMeshpatchLoDidx[ tileID ][ p ] = mmdu_lod_idx[ tileID ][ p ]

[1473] if(TileMeshpatchLoDIdx[ tileID ][ p ] == 0) {

[1474] TileMeshpatchSubdivCount[tileID][p]=

[1475] MergePatchSubdivisionCount[ tileID ][ p ] (34) for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){

[1476] TileMeshpatchSubdivMethod[tileID][p][i] =

[1477] refMeshpatchSubdivMethod[ i ] (35)

[1478] }

[1479] If asve_displacement_present_flag, a flag indicating the presence of displacement data, is 1, i.e., if displacement data exists, the meshpatch data unit syntax coded in merge mode related to displacement data can be parsed.

[1480] If asve_displacement_present_flag is 1, the associated displacement data parameters are derived as follows:

[1481] TileMeshpatchDispCoordSys[ tileID ][ p ] = refMeshpatchDispCoordSys (36)

[1482] TileMeshpatchTransformMethod[ tileID ][ p ] = refMeshpatchTransformMethod (37)

[1483] }

[1484] asve_displacement_id_present_flag가 0이고 asve_displacement_present_flag가 1이면 다음이 적용된다.

[1485] if(TileMeshpatchLoDIdx[ tileID ][ p ] == 0){

[1486] TileMeshpatchFaceCount[ tileID ][ p ] = refMeshpatchFaceCount (39)

[1487] }

[1488] TileMeshpatch2dPosX[ tileID ][ p ] = refMeshpatch2dPosX (40)

[1489] TileMeshpatch2dPosY[ tileID ][ p ] = refMeshpatch2dPosY (41)

[1490] TileMeshpatch2dSizeX[ tileID ][ p ] = refMeshpatch2dSizeX (42)

[1491] TileMeshpatch2dSizeY[ tileID ][ p ] = refMeshpatch2dSizeY (43)

[1492] if( asve_displacement_id_present_flag || ( asve_lod_patches_enable_flag == 0 ) ) {

[1493] vertexInfoCount = TileSubdivisionCount[ tileID ][ p ] + 1

[1494] } else {

[1495] vertexInfoCount = 1

[1496] }

[1497] for( i=0; i< vertexInfoCount; i++){

[1498] TilePatchVertexBlockCount[ tileID ][ p ][ i ] = refMeshatchVertexBlockCount[ i ] TilePatchVertexCountLast[ tileID ][ p ][ i ] = refMeshpatchVertexCountLast[ i ]

[1499] TilePatchVertexCount[ tileID ][ p ][ i ] =

[1500] TilePatchVertexBlockCount[ tileID ][ p ][ i ] *

[1501] PatchPackingBlockSize * PatchPackingBlockSize +

[1502] TilePatchVertexCountLast[ tileID ][ p ][ i ]

[1503] TilePatchTotalVertexCount[ tileID ][ p ] +=

[1504] TilePatchVertexCount[ tileID ][ p ][ i ]

[1505] }

[1506] asve_displacement_id_present_flag가 1이고 asve_displacement_present_flag가 1이면 다음이 적용된다.

[1507] TileMeshpatchDisplID[ tileID ][ p ] = refMeshpatchDisplID (44)

[1508] TileMeshpatchLoDIdx[ tileID ][ p ] is 0 if the associated attribute 2D parameter is generated as follows.

[1509] for( i = 0; i< asve_num_attribute_video; i++ ){

[1510] TileMeshpatchAttributes2dPosX[ tileID ][ p ][ i ] =

[1511] refMeshpatchAttributes2dPosX[ i ]

[1512] TileMeshpatchAttributes2dPosY[ tileID ][ p ][ i ] =

[1513] refMeshpatchAttributes2dPosY[ i ]

[1514] TileMeshpatchAttributes2dSizeX[ tileID ][ p ][ i ] =

[1515] refMeshpatchAttributes2dSizeX[ i ]

[1516] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ i ] =

[1517] refMeshpatchAttributes2dSizeY[ i ]

[1518] }

[1519] smIdx = SubmeshIDToIndex[ TileMeshpatchSubmeshID[ tileID ][ p ] ]

[1520] TileMeshpatchTexcoordProjectionFlag[ tileID ][ p ] = TexcoordProjectionFlag[ smIdx ]

[1521] TileMeshpatchTexcoordProjectionWidthNormalization[ tileID ][ p ] =

[1522] TexcoordProjectionWidthNormalization[ smIdx ]

[1523] TileMeshpatchTexcoordProjectionHeightNormalization[ tileID ][ p ] =

[1524] TexcoordProjectionHeightNormalization[ smIdx ]

[1525] TileMeshpatchTexcoordProjectionGutter[ tileID ][ p ] =

[1526] TexcoordProjectionGutter[ smIdx ]

[1527] TileMeshpatchLoDIdx[ tileID ][ p ]가 0이고 asve_lifting_offset_present_flag가 1이며 asve_displacement_present_flag가 1이면 다음이 적용된다.

[1528] if(TileMeshpatchSubdivCount[ tileID ][ p ] > refMeshpatchSubdivCount){

[1529] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){

[1530] TileMeshpatchLiftingOffsetNum[ tileID ][ p ] [ i ] =

[1531] refMeshpatchLiftingOffsetNum

[0000] +

[1532] mmdu_lifting_offset_delta_values_num[ tileID ][ p ][ i ]

[1533] TileMeshpatchLiftingOffsetDeno[ tileID ][ p ] [ i ] =

[1534] refMeshpatchLiftingOffsetDeno

[0000] +

[1535] mmdu_lifting_offset_delta_values_deno[ tileID ][ p ][ i ]

[1536] TileMeshpatchLiftingOffset[ tileID ][ p ] [ i ] =

[1537] TileMeshpatchLiftingOffsetNum[ tileID ][ p ] [ i ] χ

[1538] TileMeshpatchLiftingOffsetDeno[ tileID ][ p ] [ i ]

[1539] }

[1540] }

[1541] else

[1542] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ]; i++ ){

[1543] TileMeshpatchLiftingOffsetNum[ tileID ][ p ] [ i ] =

[1544] refMeshpatchLiftingOffsetNum[ i ]+

[1545] mmdu_lifting_offset_delta_values_num[ tileID ][ p ] [ i ]

[1546] TileMeshpatchLiftingOffsetDeno[ tileID ][ p ] [ i ] =

[1547] refMeshpatchLiftingOffsetDeno[ i ]+

[1548] mmdu_lifting_offset_delta_values_deno[ tileID ][ p ] [ i ]

[1549] TileMeshpatchLiftingOffset[ tileID ][ p ] [ i ] =

[1550] TileMeshpatchLiftingOffsetNum[ tileID ][ p ] [ i ] χ

[1551] TileMeshpatchLiftingOffsetDeno[ tileID ][ p ] [ i ]

[1552] }

[1553] }

[1554] TileMeshpatchLoDIdx[ tileID ][ p ]가 0이고 asve_lifting_offset_present_flag가 0이며 asve_displacement_present_flag가 1이면 다음이 적용된다.

[1555] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ]; i++ )

[1556] TileMeshpatchLiftingOffset[ tileID ][ p ][ i ] = 0

[1557] If mmdu_texture_projection_present_flag[ tileID ][ p ] is 1 and TileMeshpatchLoDIdx[ tileID ][ p ] is 0, the process of subclause 9.2.8.6.2.2 is called with p and tileID as input, and the outputs are variables refMeshpatchFrameScale and refMeshpatchNumSubpatches, 1D arrays refMeshpatchSubpatchIdxToFaceId, refMeshpatchSubpatchProjectionID, refMeshpatchSubpatchOrientationID, refMeshpatchSubpatch2dPosX, refMeshpatchSubpatch2dPosY, refMeshpatchSubpatch2dBiasX, refMeshpatchSubpatch2dBIasY, refMeshpatchSubpatch2dSizeX, refMeshpatchSubpatch2dSizeY, and This is refMeshpatchSubpatchScale.

[1558] Then, the texture projection information is derived as follows.

[1559] TileMeshpatchFrameScale[ tileID ][ p ] = refMeshpatchFrameScale

[1560] TileMeshpatchNumSubpatches[ tileID ][ p ] = refMeshpatchNumSubpatches

[1561] for( i = 0; i < TileMeshpatchNumSubpatches[ tileID ][ p ]; i++ ){

[1562] TileMeshpatchSubpatchIdxToFaceId[tileID][p][i] =

[1563] refMeshpatchSubpatchIdxToFaceId,[ i ]

[1564] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ] =

[1565] refMeshpatchSubpatchProjectionID[ i ]

[1566] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ] =

[1567] refMeshpatchSubpatchOrientationID[ i ]

[1568] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ i ] =

[1569] refMeshpatchSubpatch2dPosX[ i ]

[1570] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ] =

[1571] refMeshpatchSubpatch2dPosY[ i ]

[1572] TileMeshpatchSubpatch2dBiasX[ tileID ][ p ][ i ] =

[1573] refMeshpatchSubpatch2dBiasX[ i ]

[1574] TileMeshpatchSubpatch2dBiasY[ tileID ][ p ][ i ] =

[1575] refMeshpatchSubpatch2dBiasY[ i ] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[1576] refMeshpatchSubpatch2dSizeX[ i ]

[1577] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[1578] refMeshpatchSubpatch2dSizeY[ i ]

[1579] TileMeshpatchSubpatchScale[ tileID ][ p ][ i ] =

[1580] refMeshpatchSubpatchScale[ i ]

[1581] }

[1582] numSubPatchesUpdate = tpmi_update_subpatch_count_minus1[ tileID ][ p ]

[1583] for( i = 0; i < numSubPatchesUpdate; i++ ){

[1584] subPatchIdx = smi_subpatch_index[ tileID ][ p ][ i ]

[1585] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ subPatchIdx ] =

[1586] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ subPatchIdx ] +

[1587] smi_2d_pos_x_delta[ tileID ][ p ][ i ]

[1588] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ subPatchIdx ] =

[1589] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ subPatchIdx ] +

[1590] smi_2d_pos_y_delta[ tileID ][ p ][ i ]

[1591] if( asve_projection_texcoord_bbox_bias_enable_flag ) {

[1592] TileMeshpatchSubpatch2dBiasX[ tileID ][ p ][ subPatchIdx ] =

[1593] TileMeshpatchSubpatch2dBiasX[ tileID ][ p ][ subpatchIdx ] +

[1594] smi_2d_bias_x_delta[ tileID ][ p ][ i ]

[1595] TileMeshpatchSubpatch2dBiasY[ tileID ][ p ][ subPatchIdx ] =

[1596] TileMeshpatchSubpatch2dBiasY[ tileID ][ p ][ subpatchIdx ] +

[1597] smi_2d_bias_y_delta[ tileID ][ p ][ i ]

[1598] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ subPatchIdx ] =

[1599] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ subPatchIdx ] +

[1600] smi_2d_size_x_delta[ tileID ][ p ][ i ]

[1601] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ subPatchIdx ] =

[1602] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ subPatchIdx ] +

[1603] smi_2d_size_y_delta[tileID][p][i]

[1604] }

[1605] }

[1606] The decoding procedure for mesh patch data units coded in inter prediction mode according to embodiments further includes the following procedure.

[1607] 9.2.8.2.1 Decoding process of mesh patch data units coded in inter prediction mode:

[1608] The inputs to this process are the current patch index p and the current tile ID tileID.

[1609] First, the reference atlas frame index refIdx is derived as imdu_ref_index[ tileID ][ p ].

[1610] Then, the reference atlas frame refAtlasFrm is selected as the atlas frame corresponding to the ( refIdx + 1 )th entry of the reference atlas frame list RefAtlasFrmList, RefAtlasFrmList[ refIdx ].

[1611] If p is 0, PredictorIdx is set to 0.

[1612] Then, the corresponding patch index RefPatchIdx of the tile with the same ID as the tile ID in the reference atlas frame refAtlasFrm is calculated as follows:

[1613] RefPatchIdx = PredictorIdx + imdu_patch_index[tileID][p] (45)

[1614] and PredictorIdx is set to RefPatchIdx + 1.

[1615] The process described in subclause 9.2.8.6.2.1 is called with variables refIdx, RefPatchIdx and tileID as input and outputs variables refMeshpatch2dPosX, refMeshpatch2dPosY, refMeshpatch2dSizeX, refMeshpatch2dSizeY, refMeshpatchSubmeshID, refMeshpatchVertexCount, refMeshpatchFaceCount, refMeshpatchSubdivMethod, refMeshpatchSubdivCount, refMeshpatchDispCoordSys, refMeshpatchTransformMethod, 1D arrays refMeshpatchBlockCount, refMeshpatchVertexCountLast, refMeshpatchAttributes2dPosX, refMeshpatchAttributes2dPosY, refMeshpatchAttributes2dSizeX, These are refMeshpatchAttributes2dSizeY, refMeshpatchLiftingOffsetNum, refMeshpatchLiftingOffsetDeno, and refMeshpatchLiftingOffset.

[1616] The following parameters are derived:

[1617] TileMeshpatchSubmeshID[tileID][p] = refMeshpatchSubmeshID

[1618] TileMeshpatchLoDIdx[ tileID ][ p ] = imdu_lod_idx[ tileID ][ p ]

[1619] if(TileMeshpatchLoDIdx[ tileID ][ p ] == 0){

[1620] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){

[1621] TileMeshpatchSubdivMethod[ tileID ][ p ][ i ] = refMeshpatchSubdivMethod[ i ]

[1622] }

[1623] TileMeshpatchDispCoordSys[ tileID ][ p ] = refMeshpatchDispCoordSys

[1624] TileMeshpatchTransformMethod[ tileID ][ p ] = refMeshpatchTransformMethod

[1625] }

[1626] If asve_displacement_present_flag, a flag indicating the presence of displacement data, is 1, i.e., if displacement data exists, the meshpatch data unit syntax coded in inter mode related to displacement data can be parsed.

[1627] If asve_displacement_id_present_flag is 0 and asve_displacement_present_flag is 1, the following applies:

[1628] if(TileMeshpatchLoDIdx[ tileID ][ p ] == 0){

[1629] TileMeshpatchFaceCount[tileID][p] = refMeshpatchFaceCount

[1630] }

[1631] TileMeshpatch2dPosX[tileID][p] =

[1632] refMeshpatch2dPosX + imdu_2d_delta_pos_x[ tileID ][ p ] * PatchPackingBlockSize

[1633] TileMeshpatch2dPosY[ tileID ][ p ] =

[1634] refMeshpatch2dPosY + imdu_2d_delta_pos_y[ tileID ][ p ] * PatchPackingBlockSize

[1635] TileMeshpatch2dSizeX[ tileID ][ p ] = refMeshpatch2dSizeX +

[1636] imdu_2d_delta_size_x[ tileID ][ p ] * PatchSizeXQuantizer

[1637] TileMeshpatch2dSizeY[ tileID ][ p ] = refMeshpatch2dSizeY +

[1638] imdu_2d_delta_size_y[ tileID ][ p ] * PatchSizeYQuantizer

[1639] TileMeshpatchSubdivCount[ tileID ][ p ] = InterPatchSubdivisionCount[ tileID ][ p ]

[1640] if( asve_displacement_id_present_flag || || ( asve_lod_patches_enable_flag == 0 ) ) {

[1641] vertexInfoCount = TileSubdivisionCount[ tileID ][ p ] + 1

[1642] } else {

[1643] vertexInfoCount = 1

[1644] }

[1645] for( i=0; i< vertexInfoCount; i++){

[1646] TilePatchVertexBlockCount[ tileID ][ p ][ i ] =

[1647] (i < refMeshpatchSubdivCount ? refMeshpatchTotalVertexBlockCount[ i ] : 0 )

[1648] + imdu_delta_block_count[ tileID ][ p ][ i ] + 1

[1649] TilePatchVertexCountLast[ tileID ][ p ][ i ] =

[1650] (i < refMeshpatchSubdivCount ? refMeshpatchVertexCountLast[ i ] : 0 )

[1651] + imdu_delta_last_pos_in_block[ tileID ][ p ][ i ]

[1652] TilePatchVertexCount[ tileID ][ p ][ i ] =

[1653] TilePatchVertexBlockCount[ tileID ][ p ][ i ] *

[1654] PatchPackingBlockSize*PatchPackingBlockSize +

[1655] TilePatchVertexCountLast[ tileID ][ p ][ i ]

[1656] TilePatchTotalVertexCount[ tileID ][ p ] +=

[1657] TilePatchVertexCount[ tileID ][ p ][ i ]

[1658] }

[1659] If asve_displacement_id_present_flag is 1 and asve_displacement_present_flag is 1, the following applies:

[1660] TileMeshpatchDisplID[tileID][p] = refMeshpatchDisplID

[1661] If TileMeshpatchLoDIdx[ tileID ][ p ] is 0, asve_lifting_offset_present_flag is 1, and asve_displacement_present_flag is 1, the following applies:

[1662] if(TileMeshpatchSubdivCount[ tileID ][ p ] > refMeshpatchSubdivCount){

[1663] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){

[1664] TileMeshpatchLiftingOffsetNum[ tileID ][ p ] [ i ] =

[1665] refMeshpatchLiftingOffsetNum

[0000] +

[1666] imdu_lifting_offset_delta_values_num[ tileID ][ p ] [ i ]

[1667] TileMeshpatchLiftingOffsetDeno[tileID][p][i] =

[1668] refMeshpatchLiftingOffsetDeno

[0000] +

[1669] imdu_lifting_offset_delta_values_deno[ tileID ][ p ] [ i ]

[1670] TileMeshpatchLiftingOffset[ tileID ][ p ] [ i ] =

[1671] TileMeshpatchLiftingOffsetNum[ tileID ][ p ] [ i ] χ

[1672] TileMeshpatchLiftingOffsetDeno[ tileID ][ p ] [ i ]

[1673] }

[1674] }

[1675] else

[1676] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ ){

[1677] TileMeshpatchLiftingOffsetNum[ tileID ][ p ] [ i ] =

[1678] refMeshpatchLiftingOffsetNum[ i ]+

[1679] imdu_lifting_offset_delta_values_num[ tileID ][ p ] [ i ]

[1680] TileMeshpatchLiftingOffsetDeno[ tileID ][ p ] [ i ] =

[1681] refMeshpatchLiftingOffsetDeno[ i ]+

[1682] imdu_lifting_offset_delta_values_deno[ tileID ][ p ] [ i ]

[1683] TileMeshpatchLiftingOffset[ tileID ][ p ] [ i ] =

[1684] TileMeshpatchLiftingOffsetNum[ tileID ][ p ] [ i ] χ

[1685] TileMeshpatchLiftingOffsetDeno[ tileID ][ p ] [ i ]

[1686] }

[1687] }

[1688] If asve_lifting_offset_present_flag is 0, the following applies:

[1689] for( i = 0; i < TileMeshpatchSubdivCount[ tileID ][ p ] ; i++ )

[1690] TileMeshpatchLiftingOffset[tileID][p][i] = 0

[1691] If TileMeshpatchLoDIdx[ tileID ][ p ] is 0, the associated attribute 2D parameters are derived as follows:

[1692] for( i = 0; i< asve_num_attribute_video; i++ ){

[1693] TileMeshpatchAttributes2dPosX[tileID][p][i] =

[1694] refMeshpatchAttributes2dPosX[ i ] +

[1695] imdu_attribute_2d_delta_pos_x[ tileID ][ p ] * PatchPackingBlockSize

[1696] TileMeshpatchAttributes2dPosY[tileID][p][i] =

[1697] refMeshpatchAttributes2dPosY[ i ] +

[1698] imdu_attribute_2d_delta_pos_y[ tileID ][ p ] * PatchPackingBlockSize

[1699] TileMeshpatchAttributes2dSizeX[ tileID ][ p ][ i ] =

[1700] refMeshpatchAttributes2dSizeX[ i ] +

[1701] imdu_attribute_2d_delta_size_x[ tileID ][ p ] * PatchSizeXQuantizer

[1702] TileMeshpatchAttributes2dSizeY[ tileID ][ p ][ i ] =

[1703] refMeshpatchAttributes2dSizeY[ i ] +

[1704] imdu_attribute_2d_delta_size_y[ tileID ][ p ] * PatchSizeXQuantizer

[1705] }

[1706] smIdx = SubmeshIDToIndex[ TileMeshpatchSubmeshID[ tileID ][ p ] ]

[1707] TileMeshpatchTexcoordProjectionFlag[ tileID ][ p ] = TexcoordProjectionFlag[ smIdx ]

[1708] TileMeshpatchTexcoordProjectionWidthNormalization[ tileID ][ p ] =

[1709] TexcoordProjectionWidthNormalization[ smIdx ]

[1710] TileMeshpatchTexcoordProjectionHeightNormalization[ tileID ][ p ] =

[1711] TexcoordProjectionHeightNormalization[ smIdx ]

[1712] TileMeshpatchTexcoordProjectionGutter[ tileID ][ p ] =

[1713] TexcoordProjectionGutter[ smIdx ]

[1714] If imdu_texture_projection_present_flag[ tileID ][ p ] is 1 and TileMeshpatchLoDIdx[ tileID ][ p ] is 0, the process of subclause 9.2.8.6.2.2 is called with p and tileID as input, and the outputs are variables refMeshpatchFrameScale and refMeshpatchNumSubpatches, 1D arrays refMeshpatchSubpatchIdxToFaceId, refMeshpatchSubpatchProjectionID, refMeshpatchSubpatchOrientationID, refMeshpatchSubpatch2dPosX, refMeshpatchSubpatch2dPosY, refMeshpatchSubpatch2dBiasX, refMeshpatchSubpatch2dBiasY, refMeshpatchSubpatch2dSizeX, refMeshpatchSubpatch2dSizeY. Use refMeshpatchSubpatchScale.

[1715] Then, the texture projection information is derived as follows.

[1716] TileMeshpatchFrameScale[tileID][p] =

[1717] (tpii_frame_upscale_minus1[tileID][p] + 1) / (2tpii_log2_frame_downscale[tileID][p])

[1718] TileMeshpatchNumSubpatches[ tileID ][ p ] = tpii_subpatch_count_minus1[ tileId ][ p ] + 1

[1719] for( i = 0; i < TileMeshpatchNumSubpatches[ tileID ][ p ]; i++ ){

[1720] if( tpii_subpatch_inter_present_flag[ tileID ][ p ][ i ] ){

[1721] sIdx = sii_subpatch_index_diff[ tileID ][ p ][ i ] + i

[1722] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] =

[1723] refMeshpatchSubpatchIdxToFaceId[ sIdx ]

[1724] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ] =

[1725] refMeshpatchSubpatchProjectionID[ sIdx ]

[1726] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ] =

[1727] refMeshpatchSubpatchOrientationID[ sIdx ]

[1728] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ i ] =

[1729] refMeshpatchSubpatch2dPosX[ sIdx ] +

[1730] sii_2d_pos_x_delta[ tileID ][ p ][ i ]

[1731] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ] =

[1732] refMeshpatchSubpatch2dPosY[ sIdx ] +

[1733] sii_2d_pos_y_delta[ tileID ][ p ][ i ]

[1734] if( asve_projection_texcoord_bbox_bias_enable_flag ) {

[1735] TileMeshpatchSubpatch2dBiasX[ tileID ][ p ][ i ] =

[1736] refMeshpatchSubpatch2dBiasX[ sIdx ] +

[1737] sii_2d_bias_x_delta[ tileID ][ p ][ i ]

[1738] TileMeshpatchSubpatch2dBiasY[ tileID ][ p ][ i ] =

[1739] refMeshpatchSubpatch2dBiasY[ sIdx ] +

[1740] sii_2d_bias_y_delta[ tileID ][ p ][ i ] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[1741] refMeshpatchSubpatch2dSizeX[ sIdx ] +

[1742] sii_2d_size_x_delta[ tileID ][ p ][ i ]

[1743] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[1744] refMeshpatchSubpatch2dSizeY[ sIdx ] +

[1745] sii_2d_size_y_delta[ tileID ][ p ][ i ]

[1746] } else {

[1747] TileMeshpatchSubpatch2dBiasX[ tileID ][ p ][ i ] = 0

[1748] TileMeshpatchSubpatch2dBiasY[ tileID ][ p ][ i ] = 0

[1749] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] = 0

[1750] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] = 0

[1751] }

[1752] TileMeshpatchSubpatchScale[ tileID ][ p ][ i ] =

[1753] refMeshpatchSubpatchScale[ i ]

[1754] } else {

[1755] if( tpii_face_id_present_flag[ tileID ][ p ] )

[1756] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] =

[1757] si_face_id[ tileID ][ p ][ i ]

[1758] else

[1759] TileMeshpatchSubpatchIdxToFaceId[ tileID ][ p ][ i ] = i

[1760] TileMeshpatchSubpatchProjectionID[ tileID ][ p ][ i ] =

[1761] si_projection_id[ tileID ][ p ][ i ]

[1762] TileMeshpatchSubpatchOrientationID[ tileID ][ p ][ i ] =

[1763] si_orientation_id[ tileID ][ p ][ i ]

[1764] TileMeshpatchSubpatch2dPosX[ tileID ][ p ][ i ] =

[1765] si_2d_pos_x[ tileID ][ p ][ i ]

[1766] TileMeshpatchSubpatch2dPosY[ tileID ][ p ][ i ] =

[1767] si_2d_pos_y[ tileID ][ p ][ i ]

[1768] if( asve_projection_texcoord_bbox_bias_enable_flag ) {

[1769] TileMeshpatchSubpatch2dBiasX[ tileID ][ p ][ i ] =

[1770] si_2d_bias_x[ tileID ][ p ][ i ]

[1771] TileMeshpatchSubpatch2dBiasY[ tileID ][ p ][ i ] =

[1772] si_2d_bias_y[ tileID ][ p ][ i ]

[1773] if( i > 0 ) {

[1774] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[1775] ( si_2d_size_x_minus1_diff[ tileID ][ p ][ i ] +

[1776] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i - 1 ] )

[1777] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[1778] ( si_2d_size_y_minus1_diff[ tileID ][ p ][ i ] +

[1779] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i - 1 ] )

[1780] } else {

[1781] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] =

[1782] ( si_2d_size_x_minus1_diff[ tileID ][ p ][ i ] + 1 )

[1783] TileMeshpatchSubpatch2dSizeY[ tileID ][ p ][ i ] =

[1784] ( si_2d_size_y_minus1_diff[ tileID ][ p ][ i ] + 1 )

[1785] }

[1786] } else {

[1787] TileMeshpatchSubpatch2dBiasX[ tileID ][ p ][ i ] = 0

[1788] TileMeshpatchSubpatch2dBiasY[ tileID ][ p ][ i ] = 0

[1789] TileMeshpatchSubpatch2dSizeX[ tileID ][ p ][ i ] = 0

[1790] TileMeshpatchSubpatch2dSizeY[tileID][p][i] = 0

[1791] }

[1792] TileMeshpatchSubpatchScale[tileID][p][i] =

[1793] SubpatchScale[tileID][p][i]

[1794] }

[1795] }

[1796] Referring to FIGS. 28a and 28b, the atlas sequence parameter set V-DMC extended semantics further includes the following.

[1797] If asve_displacement_present_flag is 1, it indicates the presence of displacement data. If asve_displacement_present_flag is 0, there is no displacement data. As a requirement for V3C bitstream conformance, the value of asve_displacement_present_flag must be equal to (vps_geometry_video_present_flag[j]) || (pin_geometry_present_flag[j]), where j is the ID of the current atlas.

[1798] If asve_displacement_present_flag is 1, it indicates the presence of displacement data. If asve_displacement_present_flag is 0, there is no displacement data. As a requirement for V3C bitstream conformance, the value of asve_displacement_present_flag must be equal to (vps_geometry_video_present_flag[j]) || (pin_geometry_present_flag[ j ]) || (vps_ext_ac_displacement_present_flag[ j ]), where j is the ID of the current atlas.

[1799] asve_displacement_present_flag is a flag indicating the presence of displacement vector data. If the flag is 1, it can indicate the presence of displacement data, and if it is 0, it can indicate the absence of displacement data. The requirement of V3C bitstream conformance is that it must have the same value as vps_geometry_video_present_flag or pin_geometry_present_flag.

[1800] Depending on the embodiment, asve_displacement_present_flag may have the same value as vps_ext_ac_displacement_present_flag[j] or vps_geometry_video_present_flag or pin_geometry_present_flag, which signal the presence of displacement data for performing arithmetic coding at the vps level.

[1801] Figures 42a, 42b, 42c and 42d illustrate mesh patch data unit syntax according to embodiments.

[1802] The method according to the embodiments can signal information necessary for the process of decoding and restoring displacement vector data only when displacement vector data exists according to a flag indicating the presence or absence of a displacement vector, with an atlas syntax signaled at the mesh patch level.

[1803] Embodiments may include cases where the syntax of displacement data is skipped by using a flag indicating the presence of displacement data by inheriting the ASPS syntax indicating the presence of displacement vector data.

[1804] Meshpatch data unit syntax can represent the syntax of intra mesh patches.

[1805] The meshpatch data unit syntax can represent the syntax of a meshpatch in merge mode.

[1806] Figures 43a and 43b illustrate merge mesh patch data unit syntax according to embodiments.

[1807] The meshpatch data unit syntax can represent the syntax of a meshpatch in merge mode.

[1808] Figures 44a, 44b and 44c illustrate inter-mesh patch data unit syntax according to embodiments.

[1809] The meshpatch data unit syntax can represent the syntax of an inter-meshpatch.

[1810] Figure 45 shows a mesh data encoding method according to embodiments.

[1811] The method according to the embodiments may include a step of encoding a base mesh of mesh data (S4500); a step of encoding an atlas of mesh data (S4510); and / or a step of encoding an attribute of mesh data (S4520); etc.

[1812] The step of encoding the base mesh of mesh data (S4500), the step of encoding the atlas of mesh data (S4510), and the step of encoding the attribute of mesh data (S4520) may refer to the description of encoding the atlas, base mesh, displacement vector (displacement data), and attribute of mesh data, which are described in the drawing 1 transmitting device (100), mesh encoder (102), file / segment encapsulator (103), transmitter (104), drawing 2, drawing 3, drawing 4, drawing 6, drawing 7 pre-processor, encoder, drawing 12 encoder, drawing 14 to drawing 15 bitstream and syntax generation, drawing 18 to drawing 22 encoding, drawing 28a and drawing 28b to drawing 44a, drawing 44b, and drawing 44c syntax generation, etc.

[1813] Figure 46 shows a mesh data decryption method according to embodiments.

[1814] The method according to the embodiments may include a step of decoding a basemesh within a bitstream (S4600); a step of decoding an atlas within a bitstream (S4610); and / or a step of decoding an attribute within a bitstream (S4620); etc.

[1815] The step of decoding the base mesh (S4600), the step of decoding the atlas in the bitstream (S4610), and the step of decoding the attribute (S4620) may refer to the description of decoding the atlas, base mesh, displacement vector (displacement data), and attribute of mesh data, which is described in the drawing 1 receiving device (110), receiving unit (111), file / segment decapsulator (112), mesh decoder (113), renderer (114), decoder of FIG. 11, FIG. 13, bitstream and syntax parsing of FIG. 14 to FIG. 15, decoding of FIG. 16 to FIG. 17, decoding of FIG. 23 to FIG. 27, syntax acquisition of FIG. 28a and FIG. 28b to FIG. 44a, FIG. 44b, and FIG. 44c.

[1816] The bitstream generated and obtained in FIGS. 45 and 46 can be configured as follows.

[1817] With respect to 'asve_subdivision_iteration_count' in FIGS. 29a and 29b, the bitstream includes syntax information about an atlas sequence parameter set, and the syntax information may include: a parameter related to the number of subdivisions based on information about the number of subdivisions for the base mesh.

[1818] For example, if the information about the number of subdivisions for the base mesh is not 0, the transformation parameter related to the number of subdivisions is included in the syntax information, and if the information about the number of subdivisions for the base mesh is 0, the transformation parameter related to the number of subdivisions is not included in the syntax information.

[1819] With respect to 'AfpsSubdivisonCount' in Figs. 32a and 32b, the bitstream includes syntax information about an atlas frame parameter set, and the syntax information includes: information about the number of subdivisions about a base mesh, and when the information about the number of subdivisions about the base mesh is not 0, a transformation parameter related to the number of subdivisions is included in the syntax information, and when the information about the number of subdivisions about the base mesh is 0, a transformation parameter related to the number of subdivisions is not included in the syntax information.

[1820] With respect to 'PatchSubdivisionCount' in Figs. 35a, 35b and 35c, the bitstream includes syntax information about a mesh patch data unit, and the syntax information includes: information about the number of mesh patch subdivisions about a base mesh, and when the information about the number of mesh patch subdivisions about the base mesh is not 0, a transformation parameter related to the number of mesh patch subdivisions is included in the syntax information, and when the information about the number of mesh patch subdivisions about the base mesh is 0, a transformation parameter related to the number of mesh patch subdivisions is not included in the syntax information.

[1821] With respect to 'asve_displacement_present_flag' in Figs. 28a and 28b, the bitstream includes syntax information regarding an atlas sequence parameter set, and the syntax information may include: a flag indicating whether displacement data for the base mesh exists.

[1822] With respect to 'asve_displacement_present_flag' in Fig. 36, 'asve_displacement_present_flag' in Fig. 39a and Fig. 39b, the bitstream includes syntax information regarding a merge mesh patch data unit, the syntax information includes a flag indicating whether displacement data for the base mesh exists, and based on the value of the flag, a transformation parameter for the displacement data is included in the syntax information, and the bitstream further includes syntax information regarding an inter mesh patch data unit, and based on the flag indicating whether displacement data for the base mesh exists, position information and size information for the displacement data may be included in the syntax information. If the displacement data does not exist, atlas data for the displacement data (such as information regarding the position, size, or subdivision for the displacement data) may be omitted from the syntax.

[1823] In relation to the process of decoding mesh patch data units of intra mode and the process of decoding mesh patch data units of merge prediction mode, the step of decoding the atlas includes: the step of decoding intra mesh patch data, and when the value of the flag indicating whether displacement data for the base mesh in the bitstream exists is 1, a transformation parameter related to the displacement data is obtained, and the step of decoding the atlas further includes: the step of decoding merge mesh patch data, and when the value of the flag indicating whether displacement data for the base mesh in the bitstream exists is 1, a transformation parameter related to the displacement data can be obtained.

[1824] The decryption method may be performed by a decryption device. The decryption device includes a memory; and at least one processor connected to the memory; and the at least one processor may be configured to: decode a basemesh within a bitstream; decode an atlas within the bitstream; and decode an attribute within the bitstream.

[1825] The method of FIG. 45 may be performed by an encoding device, the encoding device including a memory; and at least one processor connected to the memory; wherein the at least one processor may be configured to: encode a base mesh of mesh data; encode an atlas of mesh data; and encode an attribute of mesh data.

[1826] Methods 45 and 46 can follow the reverse process of each other.

[1827] The embodiments further include a computer-readable storage medium storing a bitstream generated by the method according to FIG. 45.

[1828] Embodiments may include a step of obtaining a bitstream for mesh data, the bitstream being generated based on a step of encoding a basemesh of the mesh data; a step of encoding an atlas of the mesh data; and a step of encoding an attribute of the mesh data; and a step of transmitting data including the bitstream.

[1829] The method of FIGS. 45 to 46 according to the embodiments provides the following technical effects.

[1830] The atlas data encoding / decoding process performed in existing V-DMC always encodes / decodes parameters related to displacement vectors regardless of the presence of displacement vector data. In this embodiment, a method is proposed to omit atlas syntax related to displacement vector data depending on the presence of displacement vector data.

[1831] Encoder perspective effect: By encoding atlas data by considering the presence or absence of displacement vector data through this embodiment, when displacement vector data does not exist, the atlas parameter encoding related to displacement vector data can be omitted, thereby reducing the amount of atlas data bits.

[1832] Decoder perspective effect: By decoding atlas data by considering the presence or absence of displacement vector data through this embodiment, when displacement vector data does not exist, the computational complexity can be reduced by omitting the decoding of atlas parameters related to displacement vector data.

[1833] The embodiments have been described in terms of methods and / or devices, and the descriptions of methods and devices may be applied complementarily.

[1834] For the convenience of explanation, each drawing has been described separately, but it is also possible to design a new embodiment by combining the embodiments described in each drawing. In addition, designing a computer-readable recording medium having a program recorded thereon for executing the previously described embodiments, as needed by a person skilled in the art, also falls within the scope of the embodiments. The devices and methods according to the embodiments are not limited to the configurations and methods of the embodiments described above, but the embodiments may be configured by selectively combining all or part of the embodiments so that various modifications can be made. Although preferred embodiments of the embodiments have been illustrated and described, the embodiments are not limited to the specific embodiments described above, and various modifications can be made by a person skilled in the art to which the present invention pertains without departing from the gist of the embodiments claimed in the claims, and such modifications should not be understood individually from the technical idea or prospect of the embodiments.

[1835] The various components of the devices of the embodiments may be implemented by hardware, software, firmware, or a combination thereof. The various components of the embodiments may be implemented by a single chip, for example, a single hardware circuit. According to embodiments, the components according to the embodiments may be implemented by separate chips. According to embodiments, at least one of the components of the devices of the embodiments may be configured with one or more processors capable of executing one or more programs, and the one or more programs may perform, or include instructions for performing, one or more of the operations / methods according to the embodiments. The executable instructions for performing the methods / operations of the devices of the embodiments may be stored in non-transitory CRMs or other computer program products configured to be executed by one or more processors, or may be stored in temporary CRMs or other computer program products configured to be executed by one or more processors. In addition, the memory according to the embodiments may be used as a concept including not only volatile memory (e.g., RAM, etc.), but also non-volatile memory, flash memory, PROM, etc. Additionally, it may include implementations in the form of carrier waves, such as transmissions via the Internet. Furthermore, processor-readable recording media may be distributed across network-connected computer systems, allowing processor-readable code to be stored and executed in a distributed manner.

[1836] In this document, “ / ” and “,” are interpreted as “and / or”. For example, “A / B” is interpreted as “A and / or B”, and “A, B” is interpreted as “A and / or B”. Additionally, “A / B / C” means “at least one of A, B, and / or C”. Also, “A, B, C” means “at least one of A, B, and / or C”. Additionally, “or” in this document is interpreted as “and / or”. For example, “A or B” can mean 1) “A” only, 2) “B” only, or 3) “A and B”. In other words, “or” in this document can mean “additionally or alternatively”.

[1837] Terms such as "first" and "second" may be used to describe various components of the embodiments. However, the various components according to the embodiments should not be interpreted in a limited manner by these terms. These terms are merely used to distinguish one component from another. For example, a first user input signal may be referred to as a "second user input signal." Similarly, a second user input signal may be referred to as a "first user input signal." The use of these terms should be interpreted as not departing from the scope of the various embodiments. Although "first user input signal" and "second user input signal" are both user input signals, they do not necessarily mean the same user input signals unless the context clearly indicates otherwise.

[1838] The terminology used to describe the embodiments is for the purpose of describing particular embodiments and is not intended to be limiting of the embodiments. As used in the description of the embodiments and in the claims, the singular is intended to include the plural unless the context clearly dictates otherwise. The expressions “and / or” are used to mean all possible combinations of terms. The expression “includes” describes the presence of features, numbers, steps, elements, and / or components, but does not mean that additional features, numbers, steps, elements, and / or components are not included. Conditional expressions such as “if” or “when” used to describe the embodiments are not intended to be limited to only optional cases. When a specific condition is satisfied, a related action is performed in response to a specific condition, or a related definition is intended to be interpreted.

[1839] Additionally, the operations according to the embodiments described in this document may be performed by a transceiver device including a memory and / or a processor according to the embodiments. The memory may store programs for processing / controlling the operations according to the embodiments, and the processor may control various operations described in this document. The processor may be referred to as a controller, etc. The operations according to the embodiments may be performed by firmware, software, and / or a combination thereof, and the firmware, software, and / or a combination thereof may be stored in the processor or in the memory.

[1840] Meanwhile, the operations according to the embodiments described above may be performed by a transmitting device and / or a receiving device according to the embodiments. The transmitting / receiving device may include a transmitting / receiving unit for transmitting and receiving media data, a memory for storing instructions (program code, algorithm, flowchart, and / or data) for a process according to the embodiments, and a processor for controlling the operations of the transmitting / receiving device.

[1841] The processor may be referred to as a controller or the like, and may correspond to, for example, hardware, software, and / or a combination thereof. The operations according to the above-described embodiments may be performed by the processor. Furthermore, the processor may be implemented as an encoder / decoder or the like for the operations of the above-described embodiments.

[1842] As described above, the relevant contents have been described in the best form for carrying out the embodiments.

[1843] As described above, the embodiments may be applied in whole or in part to a point cloud data transmission and reception device and system.

[1844] Those skilled in the art may make various changes or modifications to the embodiments within the scope of the embodiments.

[1845] Embodiments may include modifications / changes, which do not depart from the scope of the claims and their equivalents.

Claims

Step of decoding the base mesh in the bitstream; A step of decoding an atlas within the above bitstream; and A step of decoding an attribute within the bitstream; comprising: How to decrypt. In the first paragraph, The above bitstream contains syntax information about the atlas sequence parameter set, The above syntax information is: Based on information about the number of subdivisions for the above base mesh, including a parameter related to the number of subdivisions, How to decrypt. In the second paragraph, If the information about the number of subdivisions for the above base mesh is not 0, a transformation parameter related to the number of subdivisions is included in the syntax information, If the information about the number of subdivisions for the above base mesh is 0, the transformation parameter related to the number of subdivisions is not included in the syntax information. How to decrypt. In the first paragraph, The above bitstream contains syntax information about the atlas frame parameter set, The above syntax information is: Contains information about the number of subdivisions for the above base mesh, If the information about the number of subdivisions for the above base mesh is not 0, a transformation parameter related to the number of subdivisions is included in the syntax information, If the information about the number of subdivisions for the above base mesh is 0, the transformation parameter related to the number of subdivisions is not included in the syntax information. How to decrypt. In the first paragraph, The above bitstream contains syntax information about the mesh patch data unit, The above syntax information is: Contains information about the number of mesh patch subdivisions for the above base mesh, If the information about the number of mesh patch subdivisions for the above base mesh is not 0, a transformation parameter related to the number of mesh patch subdivisions is included in the syntax information, If the information about the number of mesh patch subdivisions for the above base mesh is 0, the transformation parameter related to the number of mesh patch subdivisions is not included in the syntax information. How to decrypt. In the first paragraph, The above bitstream contains syntax information about the atlas sequence parameter set, The above syntax information is: Contains a flag indicating whether displacement data for the base mesh exists, How to decrypt. In the first paragraph, The bitstream includes syntax information about a merge mesh patch data unit, and the syntax information includes a flag indicating whether displacement data for the base mesh exists, and based on the value of the flag, a transformation parameter for the displacement data is included in the syntax information. The bitstream further includes syntax information about an inter-mesh patch data unit, and the syntax information includes position information and size information about displacement data based on a flag indicating whether displacement data exists about the base mesh. How to decrypt. In the first paragraph, The steps to decode the above atlas are: comprising a step of decoding intra-mesh patch data, If the value of the flag indicating whether there is displacement data for the base mesh in the bitstream is 1, the transformation parameters related to the displacement data are obtained, The steps to decode the above atlas are: Further comprising the step of decoding the merge mesh patch data, If the value of the flag indicating whether there is displacement data for the base mesh in the bitstream is 1, the transformation parameters related to the displacement data are obtained. How to decrypt. memory; and At least one processor connected to the memory; wherein the at least one processor comprises: Decode the basemesh within the bitstream; Decoding the atlas within the above bitstream; and configured to decode an attribute within the above bitstream; Decryption device. Step of encoding the base mesh of mesh data; a step of encoding an atlas of the above mesh data; and A step of encoding attributes of the above mesh data; comprising: Encoding method. In Article 10, The above bitstream contains syntax information about the atlas sequence parameter set, The above syntax information is: Based on information about the number of subdivisions for the above base mesh, including a parameter related to the number of subdivisions, Encoding method. In Article 11, If the information about the number of subdivisions for the above base mesh is not 0, a transformation parameter related to the number of subdivisions is included in the syntax information, If the information about the number of subdivisions for the above base mesh is 0, the transformation parameter related to the number of subdivisions is not included in the syntax information. Encoding method. memory; and At least one processor connected to the memory; wherein the at least one processor comprises: Encode the base mesh of mesh data; Encode an atlas of the above mesh data; and Encoding attributes of the above mesh data; configured to do so; Encoding device. A computer-readable storage medium storing a bitstream generated by the method according to Article 10. Step of obtaining a bitstream for mesh data, The bitstream is generated based on the steps of encoding a base mesh of the mesh data; encoding an atlas of the mesh data; and encoding an attribute of the mesh data; and A method comprising the step of transmitting data including the bitstream.

Images