Integer quantization of the v-dmc displacement vector

Description

1 / 88 INTEGER QUANTIZATION OF THE DISPLACEMENT VECTOR V-DMC

[001] This application claims priority from U.S. Patent Application No. 18 / 638,221, filed April 17, 2024, U.S. Provisional Patent Application No. 63 / 586,120, filed September 28, 2023, U.S. Provisional Patent Application No. 63 / 514,041, filed July 17, 2023, and U.S. Provisional Patent Application No. 63 / 496,875, filed April 18, 2023, the entire content of each being incorporated by reference in the present invention. US patent application No. 18 / 638,221, filed on April 17, 2024, claims the benefit of US provisional patent application No. 63 / 586,120, filed on September 28, 2023, US provisional patent application No. 63 / 514,041, filed on July 17, 2023, and US provisional patent application No. 63 / 496,875, filed on April 18, 2023. TECHNICAL FIELD

[002] This disclosure refers to dynamic mesh video-based coding. BACKGROUND

[003] Meshes can be used to represent the physical content of a three-dimensional space. Meshes can be useful in a wide variety of situations. For example, meshes can be used in the context of representing the physical content of an environment for the purpose of positioning virtual objects in an extended reality, e.g., augmented reality (AR), virtual reality (VR), or mixed reality (MR) application. Mesh compression is a process for encoding and decoding meshes. Mesh encoding can reduce the amount of data required for mesh storage and transmission. SUMMARY Petition 870250093109, dated 10 / 10 / 2025, pp. 438 / 541 2 / 88

[004] To reduce the number of bits needed to signal shift vectors, a base mesh encoder can transform the shift vectors into a set of coefficients and scale, for example, quantize the coefficients. Existing techniques for encoding the set of coefficients include converting the coefficients from floating-point values ​​to fixed-point or integer values ​​before encoding. A VDMC decoder takes the integer values ​​and converts the integer values ​​back to floating-point values ​​before performing inverse scaling and inverse transformation. The implementation of floating-point arithmetic varies across different hardware platforms, thus leading to variations in how different systems can encode and decode shift data.Performing inverse scaling that uses integer-precision arithmetic on the set of coefficients to determine a set of dequantized coefficients, as disclosed in the present invention, can reduce or eliminate this hardware variation, thereby making encoding and decoding processes more normative across different hardware implementations.

[005] According to an example in this disclosure, a device for decoding encoded loop data includes one or more memory units and one or more processing units implemented in a circuit set, coupled to the one or more memory units and configured to determine, based on the encoded loop data, a base loop; determine, based on the encoded loop data, a set of coefficients; receive a quantization parameter value from the encoded loop data; determine an inverse scaling factor based on the quantization parameter value; perform inverse scaling, based on the inverse scaling factor and using integer-precision arithmetic, on the Petition 870250093109, dated 10 / 10 / 2025, pp. 439 / 541 3 / 88 set of coefficients to determine a set of dequantized coefficients; determine a displacement vector based on the set of dequantized coefficients; deform the basis mesh based on the displacement vector to determine a decoded mesh; and output the decoded mesh.

[006] According to an example in this disclosure, a method for decoding encoded mesh data includes determining, based on the encoded mesh data, a base mesh; determining, based on the encoded mesh data, a set of coefficients; receiving in the encoded mesh data a quantization parameter value; determining an inverse scaling factor based on the quantization parameter value; performing an inverse scaling, based on the inverse scaling factor and using integer precision arithmetic, on the set of coefficients to determine a set of dequantized coefficients; determining a displacement vector based on the set of dequantized coefficients; deforming the base mesh based on the displacement vector to determine a decoded mesh; and outputting the decoded mesh.

[007] A computer-readable storage medium stores instructions that, when executed by one or more processors, cause the one or more processors to determine, based on encoded mesh data, a base mesh; determine, based on the encoded mesh data, a set of coefficients; receive a quantization parameter value from the encoded mesh data; determine an inverse scaling factor based on the quantization parameter value; perform an inverse scaling, based on the inverse scaling factor and using integer-precision arithmetic, on the set of coefficients to determine a set of dequantized coefficients; determine Petition 870250093109, dated 10 / 10 / 2025, pages 440 / 541 4 / 88 a displacement vector based on the set of dequantized coefficients; deform the basis mesh based on the displacement vector to determine a decoded mesh; and output the decoded mesh.

[008] The details of one or more examples are set out in the attached drawings and in the description below. Other attributes, objectives and advantages will become apparent from the description, drawings and claims. BRIEF DESCRIPTION OF THE DRAWINGS

[009] Figure 1 is a block diagram that illustrates an example of an encoding and decoding system that can perform the techniques of this disclosure.

[010] Figure 2 shows an example of a V-DMC decoder.

[011] Figure 3 shows an example of resampling to enable efficient compression of a 2D curve.

[012] Figure 4 shows a shifted curve that has a subdivision structure, while approaching the shape of the original mesh.

[013] Figure 5 shows a block diagram of a preprocessing system.

[014] Figure 6 shows an example of an intra-frame encoder.

[015] Figure 7 shows an example of an intra-frame encoder.

[016] Figure 8 shows an example of a midpoint subdivision scheme.

[017] Figure 9 is a flowchart that illustrates an example process for decoding a compressed bitstream of mesh data. DETAILED DESCRIPTION

[018] A mesh, in general, refers to a collection of vertices in Petition 870250093109, dated 10 / 10 / 2025, pp. 441 / 541 5 / 88 A three-dimensional (3D) space that collectively represents an object in 3D space. Vertices are connected by edges, and the edges form polygons, which form faces of the mesh. Each vertex can also have one or more associated attributes, such as a texture or a color. In most scenarios, having more vertices produces higher quality meshes, for example, more detailed and more realistic. Having more vertices, however, also requires more data to represent the mesh.

[019] To reduce the amount of data needed to represent the mesh, the mesh can be encoded, using lossy or lossless encoding. In lossless encoding, the decoded version of the encoded mesh corresponds exactly to the original mesh. In lossy encoding, on the other hand, the process of encoding and decoding the mesh causes loss, such as distortion, in the decoded version of the encoded mesh.

[020] In an example of a lossy coding technique for meshes, a mesh encoder decimates an original mesh to determine a base mesh. To decimate the original mesh, the mesh encoder will subsample, or otherwise reduce, the number of vertices in the original mesh so that the base mesh is a close approximation, with fewer vertices, of the original mesh. The mesh encoder then subdivides the decimated mesh. This is the mesh encoder that estimates the locations of additional vertices between the vertices of the base mesh. The mesh encoder then deforms the subdivided base mesh by moving the additional vertices in a way that makes the deformed mesh more closely match the original mesh.

[021] After determining a desired base mesh and the deformation of the subdivided mesh, the mesh encoder generates a bitstream that includes data to construct the base mesh and data to perform the deformation. The data Petition 870250093109, dated 10 / 10 / 2025, pp. 442 / 541 6 / 88 which define the deformation can be signaled as a series of displacement vectors that indicate the movement, or displacement, of the additional vertices determined by the subdivision process. To decode a mesh from the bitstream, a mesh decoder reconstructs the base mesh based on the signaled information, applies the same subdivision process as the mesh encoder, and then shifts the additional vertices based on the signaled displacement vectors.

[022] To reduce the number of bits needed to signal shift vectors, the base mesh encoder can transform the shift vectors into a set of coefficients and scale, for example, quantize the coefficients. Existing techniques for encoding the set of coefficients include converting the coefficients from floating-point values ​​to fixed-point or integer values ​​before encoding. A VDMC decoder takes the integer values ​​and converts the integer values ​​back to floating-point values ​​before performing inverse scaling and inverse transformation. The implementation of floating-point arithmetic varies across different hardware platforms, thus leading to variations in how different systems can encode and decode shift data.Performing inverse scaling that uses integer-precision arithmetic on the set of coefficients to determine a set of dequantized coefficients, as disclosed in the present invention, can reduce or eliminate this hardware variation, thereby making encoding and decoding processes more normative across different hardware implementations.

[023] Figure 1 is a block diagram illustrating an example encoding and decoding system 100 that can perform the techniques of this disclosure. The techniques of this disclosure are, in general, directed to Petition 870250093109, dated 10 / 10 / 2025, pp. 443 / 541 7 / 88 Mesh encoding (encoding and / or decoding). Encoding can be effective in compressing and / or decompressing mesh data.

[024] As shown in Figure 1, the system 100 includes a source device 102 and a destination device 116. The source device 102 provides encoded data to be decoded by a destination device 116. In particular, in the example in Figure 1, the source device 102 provides the data to the destination device 116 by means of a computer-readable medium 110. The source device 102 and the destination device 116 may comprise any of a wide range of devices, including desktop computers, notebook computers (i.e., laptop computers), tablet computers, set-top boxes, telephone handsets such as smartphones, televisions, cameras, display devices, digital media players, video game consoles, video streaming devices, land or sea vehicles, spacecraft, aircraft, robots, LIDAR devices, satellites, or similar devices.In some cases, source device 102 and destination device 116 can be equipped for wireless communication.

[025] In the example in Figure 1, source device 102 includes a data source 104, a memory 106, a V-DMC encoder 200, and an output interface 108. Destination device 116 includes an input interface 122, a V-DMC decoder 300, a memory 120, and a data consumer 118. According to this disclosure, the V-DMC encoder 200 of source device 102 and the V-DMC decoder 300 of destination device 116 can be configured to apply the techniques of this disclosure related to shift vector quantization. Thus, source device 102 represents an example of an encoding device, while destination device 116 represents an example of Petition 870250093109, dated 10 / 10 / 2025, pp. 444 / 541 8 / 88 a decoding device. In other examples, the source device 102 and the destination device 116 may include other components or arrangements. For example, the source device 102 may receive data from an internal or external source. Similarly, the destination device 116 may interface with an external data consumer, rather than including a data consumer in the same device.

[026] As shown in Figure 1, system 100 is merely an example. In general, other digital encoding and / or decoding devices can perform the techniques of this disclosure related to displacement vector quantization. Source device 102 and destination device 116 are merely examples of devices in which source device 102 generates encoded data for transmission to destination device 116. This disclosure refers to an encoding device as a device that performs the encoding (encoding and / or decoding) process of data. Thus, the V-DMC 200 encoder and the V-DMC 300 decoder represent examples of encoding devices, in particular, an encoder and a decoder, respectively.In some examples, the source device 102 and the destination device 116 may operate in a substantially symmetrical manner, such that each of the source device 102 and the destination device 116 includes encoding and decoding components. In this way, the system 100 can support unidirectional or bidirectional transmission between the source device 102 and the destination device 116, for example, for streaming, playback, broadcast, telephony, navigation, and other applications.

[027] In general, data source 104 represents a data source (i.e., raw, unencoded data) and can provide a sequential series of frames) of data to the V-DMC 200 encoder, which encodes the data. Petition 870250093109, dated 10 / 10 / 2025, pp. 445 / 541 9 / 88 for the frames. The data source 104 of the source device 102 may include a mesh capture device, such as any of a variety of cameras or sensors, for example, a three-dimensional scanning device or a light detection and ranging (LIDAR) device, one or more video cameras, a file containing previously captured data, and / or a data feed interface for receiving data from a data content provider. Alternatively or additionally, the mesh data may be computer-generated from a scanning device, camera, sensor, or other data. For example, the data source 104 may generate computer graphics-based data, like the source data, or produce a combination of live data, archived data, and computer-generated data. In each case, the VDMC 200 encoder encodes the captured, pre-captured, or computer-generated data.The V-DMC 200 encoder can rearrange the frames of the received order (sometimes called the display order) into an encoding order for encoding. The V-DMC 200 encoder can generate one or more bitstreams including encoded data. The source device 102 can then output the encoded data via the output interface 108 to the computer-readable medium 110 for reception and / or retrieval, for example, by the input interface 122 of the destination device 116.

[028] Memory 106 of source device 102 and memory 120 of destination device 116 may represent general-purpose memories. In some instances, memory 106 and memory 120 may store raw data, for example, raw data from data source 104 and raw and decoded data from V-DMC decoder 300. Additionally or alternatively, memory 106 and memory 120 may store executable software instructions, for example, by V-DMC encoder 200 and decoder 200. Petition 870250093109, dated 10 / 10 / 2025, pp. 446 / 541 10 / 88 of V-DMC 300, respectively. Although memory 106 and memory 120 are shown separately from the V-DMC 200 encoder and V-DMC 300 decoder in this example, it should be understood that the V-DMC 200 encoder and V-DMC 300 decoder may also include internal memories for functionally similar or equivalent purposes. Furthermore, memory 106 and memory 120 may store encoded data, for example, output from the V-DMC 200 encoder and input to the V-DMC 300 decoder. In some examples, portions of memory 106 and memory 120 may be allocated as one or more buffers, for example, to store raw, decoded, and / or encoded data. For example, memory 106 and memory 120 may store data representing a loop.

[029] The computer-readable medium 110 may represent any type of medium or device capable of carrying encoded data from the source device 102 to the destination device 116. In one example, the computer-readable medium 110 represents a communication medium to enable the source device 102 to transmit encoded data directly to the destination device 116 in real time, for example, via a radio frequency network or computer-based network. The output interface 108 may modulate a transmission signal that includes the encoded data, and the input interface 122 may demodulate the received transmission signal, according to a communication standard, such as a wireless communication protocol. The communication medium may comprise any wireless or wired communication medium, such as a radio frequency (RF) spectrum or one or more physical transmission lines.The communication medium can be part of a packet-based network, such as a local area network, a wide area network, or a global network like the Internet. The communication medium can include routers, switches, base stations, or any other device. Petition 870250093109, dated 10 / 10 / 2025, pp. 447 / 541 11 / 88 equipment that may be useful to facilitate communication between source device 102 and destination device 116.

[030] In some examples, source device 102 may output encoded data from output interface 108 to storage device 112. Similarly, destination device 116 may access encoded data from storage device 112 via input interface 122. Storage device 112 may include any of several distributed or locally accessed data storage media, such as a hard disk, Blu-ray discs, DVDs, CD-ROMs, flash memory, volatile or non-volatile memory, or any other digital storage media suitable for storing encoded data.

[031] In some examples, source device 102 may output encoded data to file server 114 or another intermediate storage device that can store the encoded data generated by source device 102. Destination device 116 may access stored data from file server 114 via streaming or download. File server 114 may be any type of server device with the ability to store encoded data and transmit that encoded data to destination device 116. File server 114 may represent a web server (e.g., for a website), a file transfer protocol (FTP) server, a content delivery network device, or a network attached storage (NAS) device.The target device 116 can access encrypted data from the file server 114 through any standard data connection, including an internet connection. This can include a wireless channel (e.g., a Wi-Fi connection), a wired connection (e.g., a digital subscriber line). Petition 870250093109, dated 10 / 10 / 2025, pp. 448 / 541 12 / 88 (DSL - digital subscriber line), cable modem, etc.) or a combination of both that is suitable for accessing encrypted data stored on file server 114. File server 114 and input interface 122 can be configured to operate according to a streaming protocol, a download protocol, or a combination thereof.

[032] Output interface 108 and input interface 122 may represent wireless transmitters / receivers, modems, wired network communication components (e.g., Ethernet cards), wireless communication components operating in accordance with any of a variety of Institute of Electrical and Electronics Engineers (IEEE) 802.11 standards, or other physical components. In examples where output interface 108 and input interface 122 comprise wireless components, output interface 108 and input interface 122 may be configured to transfer data, such as encoded data, in accordance with a cellular communication standard such as fourth generation (4G), 4G-LTE (long-term evolution), advanced LTE, fifth generation (5G), or similar.In some instances where output interface 108 comprises a wireless transmitter, output interface 108 and input interface 122 may be configured to transfer data, such as encoded data, according to other wireless standards, such as an IEEE 802.11 specification, an IEEE 802.15 specification (e.g., ZigBee™), a Bluetooth™ standard, or similar standards. In some instances, source device 102 and / or destination device 116 may include their respective system-on-a-chip (SoC) devices. For example, source device 102 may include a SoC device to perform the functionality assigned to the V-DMC 200 encoder and / or to... Petition 870250093109, dated 10 / 10 / 2025, pp. 449 / 541 Output interface 108 and destination device 116 may include a SoC device to perform the functionality assigned to the V-DMC 300 decoder and / or input interface 122.

[033] The techniques in this disclosure can be applied to encode and decode in support of any of a variety of applications, such as communication between autonomous vehicles, communication between scanning devices, cameras, sensors and processing devices, such as local or remote servers, geographic mapping or other applications.

[034] The input interface 122 of the destination device 116 receives an encoded bitstream from the computer-readable medium 110 (e.g., a communication medium, storage device 112, file server 114, or similar). The encoded bitstream may include signaling information defined by the V-DMC encoder 200, which is also used by the V-DMC decoder 300, such as syntax elements that have values ​​describing characteristics and / or processing encoded units (e.g., tracks, images, image groups, sequences, or similar). The data consumer 118 uses the decoded data. For example, the data consumer 118 may use the decoded data to determine the locations of physical objects. In some examples, the data consumer 118 may understand a display to present images based on grids.

[035] The V-DMC 200 encoder and the V-DMC 300 decoder can each be implemented as any of several suitable encoder and / or decoder circuit sets, such as one or more microprocessors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), discrete logic, software, Petition 870250093109, dated 10 / 10 / 2025, pp. 450 / 541 14 / 88 hardware, firmware, or any combination thereof. When the techniques are implemented partially in software, a device may store instructions for the software on a suitable non-transient, computer-readable medium and execute the instructions in hardware using one or more processors to perform the techniques of this disclosure. Each of the V-DMC 200 encoder and V-DMC 300 decoder may be included in one or more encoders or decoders, any of which may be integrated as part of a combined encoder / decoder (CODEC) in a respective device. A device that includes the V-DMC 200 encoder and / or the V-DMC 300 decoder may comprise one or more integrated circuits, microprocessors, and / or other types of devices.

[036] The V-DMC 200 encoder and the V-DMC 300 decoder may operate according to an encoding standard. This disclosure may refer generally to the process of encoding (e.g., encoding and decoding) images to include the process of encoding or decoding data. An encoded bitstream generally includes a series of values ​​for syntax elements representing decisions of the encoding process (e.g., encoding modes).

[037] This disclosure may refer, in general, to the signaling of certain information, such as syntax elements. The term signaling may refer, in general, to the communication of values ​​for syntax elements and / or other data used to decode the encoded data. That is, the V-DMC 200 encoder can signal values ​​for syntax elements in the bitstream. In general, signaling refers to the generation of a value in the bitstream. As mentioned above, the source device 102 can transport the bitstream to the destination device 116 substantially in real time or Petition 870250093109, dated 10 / 10 / 2025, pp. 451 / 541 15 / 88 in non-real-time, as may occur during the storage of syntax elements on storage device 112 for later retrieval by destination device 116.

[038] This disclosure discusses several improvements to the displacement vector quantization process in video-based coding of dynamic meshes (V-DMC) technology that is being standardized in MPEG WG7 (3DGH).

[039] The MPEG 7 working group (WG7), also called the 3D graphics and haptics coding group (3DGH), is currently standardizing video-based coding of dynamic mesh representations (V-DMC) targeting XR use cases. The current test model is based on the result of the call for proposals, Khaled Mammou, Jungsun Kim, Alexandros Tourapis, Dimitri Podborski, Krasimir Kolarov, [V-CG] Apple Dynamic Mesh Coding CfP Response, ISO / IEC JTC1 / SC29 / WG7, m59281, April 2022, and encompasses the preprocessing of input meshes into approximate meshes with typically fewer vertices called base meshes, which are encoded with a static mesh encoder (cfr. Draco, etc.). Furthermore, the encoder can estimate the movement of the basis mesh vertices and encode the movement vectors in the bitstream.The reconstructed base meshes can be subdivided into finer meshes with additional vertices and therefore additional triangles. The encoder can refine the positions of the subdivided mesh vertices to approximate the original mesh. The refinements or vertex displacement vectors can be encoded into the bitstream. In the current test model, the displacement vectors are wavelet-transformed, quantized, and the coefficients are compressed into a 2D frame. The frame sequence is encoded with a typical video encoder, for example, HEVC. Petition 870250093109, dated 10 / 10 / 2025, pp. 452 / 541 16 / 88 or VVC, in the bitstream. Additionally, the texture frame sequence is encoded with a video encoder.

[040] Figure 2 shows an example of a V-DMC decoder implementation 300, which can be configured to perform the decoding process as set out in V-DMC WD 2.0, ISO / IEC JTC1 / SC29 / WG7, N00546, January 2023. The processes described in relation to Figure 2 can also be performed, in whole or in part, by the V-DMC encoder 200.

[041] The V-DMC 300 decoder includes the demultiplexer (DMUX) 302, which receives the compressed bitstream b(i) and separates the compressed bitstream into a base mesh bitstream (BMB), a displacement bitstream (DB), and an attribute bitstream (AB). The mode selection unit 304 determines whether the base mesh data is encoded in an intra mode or an inter mode. If the base mesh is encoded in an intra mode, then the static mesh decoder 306 decodes the mesh data without relying on any previously decoded meshes. If the base mesh is encoded in an inter mode, then the movement decoder 308 decodes the movement, and the base mesh reconstruction unit 310 applies the movement to an already decoded mesh stored in the mesh buffer 312 to determine a reconstructed quantized base mesh (m'(i)).The inverse quantization unit 314 applies an inverse quantization to the reconstructed quantized basis mesh to determine a reconstructed basis mesh (m(i)).

[042] The 316 video decoder decodes the offset bitstream to determine a set or frame of quantized transform coefficients. For encoding and decoding purposes, the quantized transform coefficients can be considered as Petition 870250093109, dated 10 / 10 / 2025, pp. 453 / 541 17 / 88 being in a two-dimensional structure, for example, a frame. The image decompression unit 318 unpacks, for example, serializes, the quantized transform coefficients of the frame. The inverse quantization unit 320 inversely quantizes, for example, inverse scales, quantized transform coefficients to determine dequantized transform coefficients. The inverse wavelet transform unit 322 applies an inverse transform to the dequantized transform coefficients to determine a set of displacement vectors. The deformed mesh reconstruction unit 324 deforms the reconstructed basis mesh using the decoded displacement vectors to determine a decoded mesh (M(i)).

[043] The 326 video decoder decodes the attribute bitstream to determine decoded attribute values ​​(A'(i)) and the 328 color space conversion unit converts the decoded attribute values ​​into a desired color space to determine final attribute values ​​(A(i)). The final attribute values ​​correspond to attributes, such as color or texture, for the vertices of the decoded mesh.

[044] A detailed description of the proposal that was selected as the starting point for the V-DMC standardization can be found in m59281. The following description will detail the displacement vector encoding in the current V-DMC test model and WD 2.0.

[045] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to perform preprocessing. Figure 3 illustrates the basic idea behind the proposed preprocessing scheme using a 2D curve. The same concepts are applied to the 3D input mesh M(i) to produce a basis mesh m(i) and a displacement field d(i).

[046] In Figure 3, the 2D input curve (represented by a polyline) Petition 870250093109, dated 10 / 10 / 2025, pp. 454 / 541 18 / 88 The 2D curve), called the original curve, is first subsampled to generate a baseline curve / polyline, called the decimated curve. A subdivision scheme, as described in Garland et al., Surface Simplification Using Quadric Error Metrics (https: / / www.cs.cmu.edu / ~garland / Papers / quadrics.pdf), is then applied to the decimated polyline to generate a subdivided curve. For example, in Figure 3, a subdivision scheme using an iterative interpolation scheme is applied. The scheme includes inserting a new point in the middle of each edge of the polyline at each iteration. In the illustrated example, two subdivision iterations are applied.

[047] The proposed scheme is independent of the chosen subdivision scheme and can be combined with other subdivision schemes. The subdivided polyline is then deformed to obtain a better approximation of the original curve. A displacement vector is computed for each vertex of the subdivided mesh (arrows 302 in Figure 3) so that the shape of the displaced curve is as close as possible to the shape of the original curve (see Figure 4). As illustrated by portion 404 of the displaced curve and portion 406 of the original curve, for example, the displaced curve may not perfectly match the original curve.

[048] One advantage of the subdivided curve is that the subdivided curve has a subdivision structure that allows for efficient compression, offering a faithful approximation of the original curve. Compression efficiency is obtained based on: - The decimated / base curve has a low number of vertices and requires a limited number of bits to be encoded / transmitted. The subdivided curve is automatically generated by the decoder once the base / decimated curve is decoded (i.e., no information is needed beyond the subdivision scheme type and count). Petition 870250093109, dated 10 / 10 / 2025, pp. 455 / 541 19 / 88 subdivision iteration). The shifted curve is generated by decoding the displacement vectors associated with the vertices of the subdivided curve. In addition to enabling spatial / quality scalability, the subdivision structure enables efficient transformations, such as wavelet decomposition, which can offer high compression performance.

[049] Figure 5 shows a block diagram of the 500 preprocessing system that can be included in the V-DMC 200 encoder. In the example in Figure 5, the 500 preprocessing system includes a mesh decimation unit 510, an atlas parameterization unit 520, and a subdivision surface fitting unit 530.

[050] The mesh decimation unit 510 uses a simplification technique to decimate the input mesh M(i) and produce the decimated mesh dm(T). The decimated mesh dm(V) is then reparameterized by the atlas parameterization unit 520, which can, for example, use the UVAtlas tool. The generated mesh is denoted as pm(i). The UVAtlas tool only considers the geometry information of the decimated mesh dm(i) when computing the atlas parameterization, which is probably suboptimal for compression purposes. Other parameterization schemes or tools can also be used with the proposed structure.

[051] Applying reparameterization to the input mesh makes it possible to generate a smaller number of patches. This reduces parameterization discontinuities and can lead to better rate distortion (RD) performance. The 530 subdivision surface fitting unit takes as input the reparameterized mesh pm(i) and the input mesh M(i) and produces the base mesh m(i) along with a set of offsets d(i). First, pm(i) is subdivided by applying the subdivision scheme. The Petition 870250093109, dated 10 / 10 / 2025, pp. 456 / 541 20 / 88 displacement field d(i) is computed by determining for each vertex of the subdivided mesh the nearest point on the surface of the original mesh M(i).

[052] For the random access (RA) condition, a temporally consistent remeshing can be computed by considering the base mesh m(j) of a reference frame with index j as the input to the subdivision surface fitting unit 530. This makes it possible to produce the same subdivision structure for the current mesh M'(i) as that computed for the reference mesh M'(y). Such a remeshing process makes it possible to skip encoding the base mesh m(i) and reuse the base mesh m(j) associated with the reference frame M(y). This can also enable better temporal prediction for both attribute and geometry information. For example, a motion field f(i) describing how to move the vertices of m(j) to match the positions of m(l) is computed and encoded. This time-consistent remeshing may not always be possible.The techniques for this disclosure may also include comparing the distortion obtained with and without the temporal consistency constraint and choosing the mode that offers the best compromise of distortion.

[053] Note that the preprocessing system is not normative and can be replaced by any other system that produces offset subdivision surfaces. A possible efficient implementation would restrict the 3D reconstruction unit to directly generate the offset subdivision surface and avoid the need for such preprocessing.

[054] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to perform displacement encoding. Depending on the application and the targeted bit rate / visual quality, the V-DMC 200 encoder can optionally encode a set of displacement vectors associated with the subdivided mesh vertices, called in Petition 870250093109, dated 10 / 10 / 2025, pp. 457 / 541 21 / 88 present invention of the displacement field d(i). The intra-encoding process, which can be performed by the V-DMC 200 encoder, is illustrated in Figure 6.

[055] Figure 6 includes the following abbreviations: m(i) - Baseline grid d(i) - Displacements m(i) - Reconstructed baseline grid d(i) - Reconstructed displacements A(i) - Attribute map A'(i) - Updated attribute map M(i) - Static / dynamic mesh DM(i) - Reconstructed deformed mesh m'(i) - Reconstructed quantized basis mesh d'(i) - Updated displacements e(i) - Wavelet coefficients e'(i) - Quantized wavelet coefficients pe'(i) - Packed quantized wavelet coefficients rpe'(i) - Reconstructed packed quantized wavelet coefficients AB - Compressed attribute bitstream DB - Compressed Offset Bitstream BMB - Compressed base mesh bitstream b (i) - Compressed bitstream.

[056] The V-DMC 200 encoder receives the basis mesh m(i) and the offsets d(i), for example, from the 500 preprocessing system in Figure 5. The V-DMC 200 encoder also retrieves the mesh M(i) and the attribute map A(i).

[057] The quantization unit 602 quantizes the basis loop and the Petition 870250093109, dated 10 / 10 / 2025, pp. 458 / 541 The 22 / 88 static mesh encoder 604 encodes the quantized base mesh to generate a compressed base mesh (BMB) bitstream.

[058] The displacement update unit 608 uses the reconstructed quantized basis mesh m'(i) to update the displacement field d(i) to generate an updated displacement field d'(i). This process considers the differences between the reconstructed basis mesh m'(i) and the original basis mesh m(i). By exploiting the subdivision surface mesh structure, the wavelet transform unit 610 applies a wavelet transform to d'(Q) to generate a set of wavelet coefficients (e(i)). The scheme is agnostic of the applied transform and can leverage any other transform, including the identity transform. The quantization unit 612 quantizes the wavelet coefficients, and the image compression unit 614 packages the quantized wavelet coefficients into a 2D image / video that can be compressed using a traditional image / video encoder (e.g., using VVC-like techniques) to generate a shift bitstream.

[059] The attribute transfer unit 630 converts the original attribute map A(i) into an updated attribute map that corresponds to the reconstructed deformed mesh DM(i). The filling unit 632 fills the updated attribute map, for example, filling frame patches that have empty samples with interpolated samples that can improve encoding efficiency and reduce artifacts. The color space conversion unit 634 converts the attribute map to a different color space, and the video encoding unit 636 encodes the updated attribute map in the new color space, using, for example, a video codec, to generate an attribute bitstream.

[060] The 638 multiplexer combines the compressed attribute bitstream, Petition 870250093109, dated 10 / 10 / 2025, pp. 459 / 541 23 / 88 compressed offset bitstream and compressed base mesh bitstream into a single compressed bitstream (b(i)).

[061] The image decompression unit 618 and the inverse quantization unit 620 apply image decompression and inverse quantization to the reconstructed compressed quantized wavelet coefficients generated by the video encoding unit 616 to obtain the reconstructed version of the wavelet coefficients. The inverse wavelet transform unit 622 applies the inverse wavelet transform to the reconstructed wavelet coefficient to determine the reconstructed shifts d(i).

[062] The inverse quantization unit 624 applies an inverse quantization to the reconstructed quantized basis mesh m'(i) to obtain a reconstructed basis mesh m”(i). The deformed mesh reconstruction unit 628 subdivides m''(i) and applies the reconstructed displacements d”(Q) to its vertices to obtain the reconstructed deformed mesh DM(V).

[063] The image decompression unit 618, the inverse quantization unit 620, the inverse wavelet transform unit 622, and the warped mesh reconstruction unit 628 represent a shift decoding loop. The inverse quantization unit 624 and the warped mesh reconstruction unit 628 represent a base mesh decoding loop. The mesh encoder 600 includes the shift decoding loop and the base mesh decoding loop, so that the mesh encoder 600 can make encoding decisions, such as determining an acceptable rate distortion compensation, based on the same decoded mesh that a mesh decoder will generate, which may include distortion due to quantization and transformations. The mesh encoder 600 can also use decoded versions of the base mesh, reconstructed mesh, and shifts to encode meshes and base shifts. Petition 870250093109, dated 10 / 10 / 2025, pp. 460 / 541 24 / 88 subsequent.

[064] The 650 control unit generally represents the decision-making functionality of the V-DMC 200 encoder. During a coding process, the 650 control unit can, for example, make determinations regarding mode selection, rate allocation, quality control, and other such decisions.

[065] Figure 7 shows a block diagram of an intra decoder that can, for example, be part of the V-DMC 300 decoder. The demultiplexer (DMUX) 702 separates the compressed bitstream (b(i)) into a mesh substream, a shift substream for positions and potentially for each vertex attribute, zero or more attribute map substreams, and an atlas substream containing patch information in the same way as in V3C / V-PCC.

[066] Demultiplexer 702 feeds the mesh substream to static mesh decoder 706 to generate the reconstructed quantized basis mesh m'(i). Inverse quantization unit 714 inversely quantizes the basis mesh to determine the decoded basis mesh m”(i). Video / image decoding unit 716 decodes the displacement substream and image decompression unit 718 unpacks the image / video to determine quantized transform coefficients, e.g., wavelet coefficients. Inverse quantization unit 720 inversely quantizes the quantized transform coefficients to determine dequantized transform coefficients. Inverse transform unit 722 generates the decoded displacement field ά”(Γ) by applying the inverse transform to the dequantized coefficients.The warped mesh reconstruction unit 724 generates the final decoded mesh (M(i)) by applying the reconstruction process to the decoded base mesh m''(i) e. Petition 870250093109, dated 10 / 10 / 2025, pp. 461 / 541 25 / 88 adding the decoded displacement field d''(i). The attribute substream is decoded directly by the 728 video / image decoding unit to generate an attribute map A”(i). The 728 format / color space conversion unit can convert the attribute map to a different format or color space.

[067] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to implement a subdivision scheme. Several subdivision schemes can be used. One possible solution is the midpoint subdivision scheme, which in each subdivision iteration subdivides each triangle into 4 subtriangles, as described in Figure 8. New vertices are introduced in the middle of each edge. The subdivision process is applied independently to the geometry and texture coordinates, since the connectivity for the geometry and texture coordinates is, in general, different. The subdivision scheme computes the position Pos(u12) of a newly introduced vertex v12 at the center of an edge (v1,v2), as follows: Pos(v12^ =1(Pos(v1) + Posfaf), Equation (1) where Pos(u1) and Pos(u2) are the positions of vertices v1 and v2.

[068] The same process is used to calculate the texture coordinates of the newly created vertex. For normal vectors, an extra normalization step is applied as follows: ^λ_ Ν(υι) + N(V2)(V12)\\N(V1)+ N^' Equation (2) here: • N(u12), N(u1), and N(u2) are the normal vectors associated with Petition 870250093109, dated 10 / 10 / 2025, pp. 462 / 541 26 / 88 vertices v12, v1, and v2, respectively. • ||x|| is the norm² of the vector x.

[069] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to apply wavelet transforms. Multiple wavelet transforms can be applied. The results reported for CfP are based on a linear wavelet transform.

[070] The prediction process is defined as follows: Signal(v) ^ Signal(v) — 1(Si^nuZ(v1) + Signal(v2))Equation (3) where • v is the vertex introduced in the middle of the boundary (v1, v2), and • Signal (v), Signal(v1), and Signal(v2) are the values ​​of the geometry / vertex attribute signals at vertices v, v1, and v2, respectively.

[071] The updated process is defined as follows: Signal(v) ^ Signal(v) + -ΣπΕν* $signal(w)Equation (4) 8 8 8 8 8^,^„ where v* is the set of neighboring vertices of vertex v.

[072] Note that the scheme makes it possible to skip the update process. The wavelet coefficients can be quantized, for example, using a uniform quantizer with a dead zone.

[073] The local vs. canonical coordinate system for displacements will now be discussed. The displacement field d(C) is defined in the same Cartesian coordinate system as the input mesh. One possible optimization is to transform d(i) from this canonical coordinate system into a local coordinate system, which is defined by the normal mesh subdivided at each vertex.

[074] A potential advantage of considering a local coordinate system for displacements is the possibility of more strongly quantifying the tangential components of displacements compared to Petition 870250093109, dated 10 / 10 / 2025, pp. 463 / 541 27 / 88 normal component. In fact, the normal component of the displacement has a more significant impact on the quality of the reconstructed mesh than the two tangential components.

[075] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to implement wavelet coefficient compression. The following scheme is used to pack the wavelet coefficients into a 2D image: • Iterate through the coefficients from low to high frequency. • For each coefficient, determine the index of the NxM pixel block (e.g., N = M = 16) in which it should be stored following a raster-to-block order. • The position within the NxM pixel block is computed using a Morton order to maximize locality.

[076] Other compression schemes can be used (e.g., zigzag order, raster order). The encoder can explicitly signal in the bitstream the compression scheme used (e.g., atlas sequence parameters). This can be done at the patch, patch group, tile, or sequence level.

[077] The V-DMC 200 encoder can be configured for displacement video coding. The techniques in this proposed disclosure scheme are agnostic of which video coding technology is used. When encoding the displacement wavelet coefficients, a lossless approach can be used, since quantization is applied in a separate module. Another approach is to rely on the video encoder (e.g., 636 video coding) to compress the coefficients in a lossy manner and apply quantization in the original or transform domain.

[078] The V-DMC 200 encoder and the V-DMC 300 decoder Petition 870250093109, dated 10 / 10 / 2025, pp. 464 / 541 28 / 88 can be configured to process a set of elevation transform parameters and associated semantics, an example of which is shown in the table below. Table 1 vmc_lifting_transform_parameters(index, ltpIndex){ Descritor vmc_transform_lifting_skip_update_flag[index][ltpIndex] u(1) vmc_transform_lifting_quantization_parameters_x[index][ltpIndex] u(6) vmc_transform_lifting_quantization_parameters_y[index][ltpIndex] u(6) vmc_transform_lifting_quantization_parameters_z[index][ltpIndex] u(6) vmc_transform_log2_lifting_lod_inverse_scale_x[index][ltpIndex] ue(v) vmc_transform_log2_lifting_lod_inverse_scale_y[index][ltpIndex] ue(v) vmc_transform_log2_lifting_lod_inverse_scale_z[index][ltpIndex] ue(v) vmc_transform_log2_lifting_update_weight[index][ltpIndex] ue(v) vmc_transform_log2_lifting_prediction_weight[index][ltpIndex] ue(v)}

[079] syntax_element[i][ltpIndex] com i igual a 0 pode ser aplicado ao deslocamento. syntax_element[i][ltpIndex] com i igual a diferente de zero pode ser aplicado ao (i-1)-ésimo atributo, onde ltpIndex é o índice da lista de conjuntos de parâmetros de transformada de elevação.

[080] vmc_transform_lifting_skip_update_flag[i][ltpIndex] equal to 1 indicates that the elevation transform step applied to the offset is skipped in the syntax structure vmc_lifting_transform_parameters(index, lptIndex), where ltpIndex is the index of the elevation transform parameter set list. vmc_transform_lifting_skip_update_flag[i][ltpIndex] with i equal to 0 can be applied to the offset. vmc_transform_lifting_skip_update_flag[i][ltpIndex] with i equal to non-zero can be applied to the (i-1)-th attribute.

[081] vmc_transform_lifting_quantization_parameters_x[i][ltpIndex] indicates the quantization parameter to be used for inverse quantization of the x-component of the displacement wavelet coefficients. The value of vmc_transform_lifting_quantization_parameters_x[index][ltpIndex] must be in the range of 0 to 51, inclusive. Petition 870250093109, dated 10 / 10 / 2025, pp. 465 / 541 29 / 88

[082] vmc_transform_lifting_quantization_parameters_y[i][ltpIndex] indicates the quantization parameter to be used for inverse quantization of the y-component of the displacement wavelet coefficients. The value of vmc_transform_lifting_quantization_parameters_x[index][ltpIndex] must be in the range of 0 to 51, inclusive.

[083] vmc_transform_lifting_quantization_parameters_z[i][ltpIndex] indicates the quantization parameter to be used for inverse quantization of the z-component of the displacement wavelet coefficients. The value of vmc_transform_lifting_quantization_parameters_x[index][ltpIndex] must be in the range of 0 to 51, inclusive.

[084] vmc_transform_log2_lifting_lod_inverse_scale_x[i][ltpIndex] indicates the scaling factor applied to the x component of the displacement wavelet coefficients for each level of detail.

[085] vmc_transform_log2_lifting_lod_inverse_scale_y[i][ltpIndex] indicates the scaling factor applied to the y component of the displacement wavelet coefficients for each level of detail.

[086] vmc_transform_log2_lifting_lod_inverse_scale_z[i][ltpIndex] indicates the scaling factor applied to the z-component of the displacement wavelet coefficients for each level of detail.

[087] vmc_transform_log2_lifting_update_weight[i][ltpIndex] indicates the weighting coefficients used for the wavelet transform update filter.

[088] vmc_transform_log2_lifting_prediction_weight[i][ltpIndex] the weighting coefficients used for the wavelet transform prediction filter.

[089] The V-DMC 300 decoder can be configured to perform wavelet coefficient inverse image compression. Inputs for this Petition 870250093109, dated 10 / 10 / 2025, pp. 466 / 541 30 / 88 processes are: • width, which is a variable that indicates the width of the displacement video frame, • height, which is a variable that indicates the height of the displacement video frame, • bitDepth, which is a variable that indicates the bit depth of the displacement video frame, • dispQuantCoeffFrame, which is a 3D array of size width x height x 3 that indicates the compressed quantized displacement wavelet coefficients. • blockSize, which is a variable that indicates the size of the displacement coefficient blocks, • positionCount, which is a variable that indicates the number of positions in the subdivided subgrid.

[090] The output of this process is dispQuantCoeffArray, which is a 2D array of size positionCount x 3 that indicates the quantized wavelet displacement coefficients.

[091] Let the extracOddBits(x) function be defined as follows: x = extracOddBits(x) { x = x & 0x55555555 x = (x | (x >> 1)) & 0x33333333 x = (x | (x >> 2)) & 0x0F0F0F0F x = (x | (x >> 4)) & 0x00FF00FF x = (x | (x >> 8)) & 0x0000FFFF} Let the computeMorton2D(i) function be defined as follows: (x, y) = computeMorton2D(i) { Petition 870250093109, dated 10 / 10 / 2025, pp. 467 / 541 31 / 88 x = extracOddBits(i » 1) y = extracOdd Bits(i)}·

[092] The inverse wavelet coefficient packing process proceeds as follows: pixelsPerBlock = blockSize * blockSize widthlnBlocks = width / blockSize shift = (1 « bitDepth)» 1 for( v = 0; v < position Count; v++ ) { blockindex = v / pixelsPerBlock indexWithinBlock = v % pixelsPerBlock xO = (blockindex % widthlnBlocks) * blockSize yO = (blockindex / widthlnBlocks) * blockSize (x, y ) = computeMorton2D(indexWithinBlock) x = xO + xy = yO + y for( d = 0; d < 3; d++ ) { dispQuantCoeffArray[ v ][ d ] = dispQuantCoeffFrame[ x ][ y ][ d ] - shift}

[093] The V-DMC 300 decoder can be configured to perform inverse quantization of wavelet coefficients. Inputs for this process are: • positionCount, which is a variable that indicates the number of positions in the subdivided submesh. • dispQuantCoeffArray, which is a 2D array of size positionCount x 3 that indicates the quantized wavelet displacement coefficients. • subdivisionlterationCount, which is a variable that indicates the number of subdivision iterations. • liftingQP, which is a 1D array of size 3 that indicates the quantization parameter associated with the three dimensions of displacement. • liftingLevelOfDetailInverseScale, which is a 1D arrangement of size 3 that Petition 870250093109, dated 10 / 10 / 2025, pp. 468 / 541 32 / 88 indicates the reverse scaling factor associated with the three displacement dimensions. • levelOfDetailAttributeCounts, a 1D array of size (subdivisionlterationCount + 1) that indicates the number of attributes associated with each subdivision iteration. • bitDepthPosition, which is a variable that indicates the bit depth of the mesh positions.

[094] The output of this process is dispCoeffArray, which is a 2D array of size positionCount χ 3 that indicates the dequantized wavelet displacement coefficients.

[095] The inverse quantization process of the wavelet coefficients proceeds as follows: for ( d =0; d < 3; ++d) { qp = liftingQP[ d ] iscale[ d ] = qp >= 0 ? pow( 0.5, 16 - bitDepthPosition + ( 4 - qp ) / 6): 0.0 ilodScalef d ] = liftingLevelOfDetailtnverseScale[ d ] vcountO = 0 for( i = 0; i < subdivisionlterationCount; i++ ) { vcountl = levelOfDetailAttributeCounts[ i ] for( v = vcountO; v < vcountl; v++ ) { for( d = 0; d < 3; d++ ) { dispCoeffArray[ v ][ d ] = dispQuantCoeffArray[ v ][ d ] * iscale[ k ]} vcountO =vcount 1 for( d = 0; d < 3; d++ ) { iscalefd] *= ilodScalef d ]

[096] Above and elsewhere in this publication, equations in the form Petition 870250093109, dated 10 / 10 / 2025, pp. 469 / 541 33 / 88 of A = x ? y:z means that if x is TRUE or not equal to 0, then A is equal to the value of y, and if x is false or equal to zero, then A is equal to the value of z.

[097] The V-DMC 300 decoder can be configured to apply an inverse linear wavelet transform. Inputs for this process are: • positionCount, which is a variable that indicates the number of positions in the subdivided submesh. • dispCoeffArray, which is a 2D array of size positionCount x 3 that indicates the wavelet displacement coefficients. • levelOfDetailAttributeCounts, a 1D array of size (subdivisionIterationCount + 1) that indicates the number of attributes associated with each subdivision iteration. • edges, which is a 2D array of size positionCount x 2 that indicates for each vertex v produced by the subdivision process described above, the two indices (a, b) of the two vertices used to generate it (i.e., v generated as the middle of edge (a, b)). • updateWeight, which is a variable that indicates the elevation update weight. • predWeight, which is a variable that indicates the elevation prediction weight. • skipUpdate, which is a variable that indicates whether the update operation should be skipped (when 1) or not (when 0).

[098] The output of this process is dispArray, which is a 2D array of size positionCount x 3 that indicates the offsets to be applied to the mesh positions.

[099] The inverse wavelet transform process proceeds as follows: Petition 870250093109, dated 10 / 10 / 2025, pp. 470 / 541 34 / 88 for( i = 0; i < subdivisionlterationCount; i++ ) { vcountO = levelOfDetailAttributeCountsfi] vcountl = levelOfDetailAttributeCountsfi + 1] for ( v = vcountO, skipUpdate == 0 && v < vcountl; ++v ) { a = edges[v][0] b = edges[v][l] for( d = 0, d < 3; d++) { disp = updateWeight * dispCoefFArray[v][d] signal [a] [d] -= disp signal[b][d] -= disp for (v = vcountO; skipUpdate == 0 && v < vcountl; ++v ) { a = edges [v][0] b = edges[v][l] for( d = 0; d < 3; d++ ) { dispCoeffArray[v][d] += predWeight * (dispCoeffArray[a][d] + dispCoeffArray[b][d]) for ( v = 0, v < positionCount; ++v ) { for( d = 0, d < 3, d++) { disp Array [v][d] = dispCoeffArray[v][d]

[100] The V-DMC 300 decoder can be configured to perform position shifting. The inputs for this process are: • positionCount, which is a variable that indicates the number of positions in the subdivided submesh. • positionsSubdiv, which is a 2D array of size positionCount χ 3 that Petition 870250093109, dated 10 / 10 / 2025, pp. 471 / 541 35 / 88 indicates the positions of the subdivided subgrid. • dispArray, which is a 2D array of size positionCount χ 3 that indicates the displacements to be applied to the mesh positions. • normals, which is a 2D array of size positionCount χ 3 that indicates the norms to be used when applying displacements to subgrid positions. • tangents, which is a 2D array of size positionCount χ 3 that indicates the tangents to be used when applying displacements to subgrid positions. • bitangents, which is a 2D array of size positionCount χ 3 that indicates the tangents to be used when applying displacements to subgrid positions.

[101] The output of this process is positionsDisplaced, which is a 2D array of size positionCount χ 3 that indicates the positions of the displaced subgrid.

[102] The process of shifting positions proceeds as follows: for (v = 0; v < positionCount; ++v) { for(d = 0; d < 3; d++) { positionsDisplaced[v][d] = positionsSubdiv[v][d] + dispArray[v][0] * normals[v][d] + dispArray[v][1] * tangents[v][d] + dispArray[v][2] * bitangents[v][d]}}

[103] As described above in relation to the inverse quantization of wavelet coefficients, the inverse quantization scale to be applied to the d-component wavelet coefficient is obtained based on the quantization parameter (qp or QP or Petition 870250093109, dated 10 / 10 / 2025, pp. 472 / 541 36 / 88 vmc_transform_lifting_quantization_parameters_x / y / z) which uses the following pseudocode formula: iscale[d] = qp >= 0 ? pow(0,5, 16 - bitDepthPosition + (4 - qp) / 6):0,0 Formula (1) where bitDepthPosition is the bit depth of the position coordinates.

[104] On the other hand, the direct quantization scale to be applied to the wavelet coefficient of the d component is obtained based on the quantization parameter using the following pseudocode formula: scale[d] = qp >= 0 ? pow(2,0, 16 - bitDepthPosition + (4 - qp) / 6):0,0 Formula (2)

[105] In general, the applied transform is not restricted to the wavelet transform (elevation), but can be any transform that includes the identity transform.

[106] Table 2 below lists the scale and inverse scale (iScale) values ​​obtained for various position bit depths and quantization parameters. For example, it can be observed that the lossless quantization parameter is 4, or scale / iScale equals 1.0, for a bit depth of 16, while for a bit depth of 8 it is 52. For each decrease in position bit depth by 2, the QP value corresponding to lossless quantization increases by 12 units. For example, for a position bit depth of 12, the lossless QP value is equal to 28, while it is equal to 40 for a bit depth of 10, 52 for a bit depth of 8, 64 for a bit depth of 6, and so on. Table 2. Scaling and reverse scaling values ​​for various position bit depths. Petition 870250093109, dated 10 / 10 / 2025, pp. 473 / 541 37 / 88 Scale bitDepthPosition iScale bitDepthPosition QP 8 10 12 16 8 10 12 16 0 406.37467 101.59367 25.39842 1.58740 0.0025 0.008 0.0940 0.639 362.03867 90.50967 22.62742 1.41421 0.0028 0.0110 0.0442 0.7071 2 322.53979 80.63495 20.15874 1.2599 0.021 0.031 0.0496 0.7937 3 287.35028 71.83757 17.95939 1.12246 0.0035 0.0139 0.0557 0.8909 4 256.00000 64.000 1.000000 0.0039 0.0156 0.0625 1.0000 5 228.07007 57.01752 14.25438 0.89090 0.0044 0.0175 0.0702 1.1225 6 2033.738383 12.69921 0.79370 0.0049 0.0197 0.0787 1.2599 7 181.01934 45.25483 11.31371 0.70711 0.0055 0.0221 0.0884 18414 161.26989 40.31747 10.07937 0.62996 0.0062 0.0248 0.0992 1.5874 9 143.67514 35.91879 8.97970 0.560.0270.0270 0.1114 1.7818 10 128.00000 32.00000 8.00000 0.50000 0.0078 0.0313 0.1250 2.0000 0.0088 0.0351 0.1403 2.2449 12 101.59367 25.39842 6.34960 0.39685 0.0098 0.0394 0.1575 2.5198 13 .1497 20.627 5.65685 0.35355 0.0110 0.0442 0.1768 2,8284 14 80,63495 20,15874 5,03968 0,31498 0,0124 0,0496 0,1984 3,1748 15 71,83757 17,95939 4,48985 0,28062 0,0139 0,0557 0,2227 3,5636 16 64,00000 16,00000 4,00000 0,25000 0,0156 0,0625 0,2500 4,0000 17 57,01752 14,25438 3,56359 0,22272 0,0175 0,0702 0,2806 4,4898 18 50,79683 12,69921 3,17480 0,19843 0,0197 0,0787 0,3150 5,0397 19 45,25483 11,31371 2,82843 0,17678 0,0221 0,0884 0,3536 5,6569 20 40,31747 10,07937 2,51984 0,15749 0,0248 0,0992 0,3969 6,3496 21 35,91879 8,97970 2,24492 0,14031 0,0278 0,1114 0,4454 7,1272 22 32,00000 8,00000 2,00000 0,12500 0,0313 0,1250 0,5000 8,0000 23 28,50876 7,12719 1,78180 0,11136 0,0351 0,1403 0,5612 8,9797 24 25,39842 6,34960 1,58740 0,09921 0,0394 0,1575 0,6300 10,0794 25 22,62742 5,65685 1,41421 0,08839 0,0442 0,1768 0,7071 11,3137 26 20,15874 5,03968 1,25992 0,07875 0,0496 0,1984 0,7937 12,6992 27 17,95939 4,48985 1,12246 0,07015 0,0557 0,2227 0,8909 14,2544 28 16,00000 4,00000 1,00000 0,06250 0,0625 0,2500 1,0000 16,0000 29 14,25438 3,56359 0,89090 0,05568 0,0702 0,2806 1,1225 17,9594 30 12,69921 3,17480 0,79370 0,04961 0,0787 0,3150 1,2599 20,1587 31 11,31371 2,82843 0,70711 0,04419 0,0884 0,3536 1,4142 22,6274 32 10,07937 2,51984 0,62996 0,03937 0,0992 0,3969 1,5874 25,3984 33 8,97970 2,24492 0,56123 0,03508 0,1114 0,4454 1,7818 28,5088 34 8,00000 2,00000 0,50000 0,03125 0,1250 0,5000 2,0000 32,0000 35 7,12719 1,78180 0,44545 0,02784 0,1403 0,5612 2,2449 35,9188 36 6,34960 1,58740 0,39685 0,02480 0,1575 0,6300 2,5198 40,3175 37 5,65685 1,41421 0,35355 0,02210 0,1768 0,7071 2,8284 45,2548 38 5,03968 1,25992 0,31498 0,01969 0,1984 0,7937 3,1748 50,7968 39 4,48985 1,12246 0,28062 0,01754 0,2227 0,8909 3,5636 57,0175 40 4,00000 1,00000 0,25000 0,01563 0,2500 1,0000 4,0000 64,0000 41 3,56359 0,89090 0,22272 0,01392 0,2806 1,1225 4,4898 71,8376 42 3,17480 0,79370 0,19843 0,01240 0,3150 1,2599 5,0397 80,6349 43 2,82843 0,70711 0,17678 0,01105 0,3536 1,4142 5,6569 90,5097, Petition 870250093109, dated 10 / 10 / 2025, pp. 474 / 541 38 / 88 Scale bitDepthPosition iScale bitDepthPosition QP 8 10 12 16 8 10 12 16 44 2.51984 0.62996 0.15749 0.00984 0.3969 1.5874 6.3496 9745 2.24492 0.56123 0.14031 0.00877 0.4454 1.7818 7.1272 114.0350 46 2.00000 0.50000 0.12500 0.00781 0.5000 0.8000 0.8000 128.0000 47 1.78180 0.44545 0.11136 0.00696 0.5612 2.2449 8.9797 143.6751 48 1.58740 0.39685 0.00990.0630 2.5198 10.0794 161.2699 49 1.41421 0.35355 0.08839 0.00552 0.7071 2.8284 11.3137 181.0193 50 1.2599 70.783 0.00492 0.7937 3.1748 12.6992 203.1873 51 1.12246 0.28062 0.07015 0.00438 0.8909 3.5636 14.2544 2.28020 1.050 0.25000 0.06250 0.00391 1.0000 4.0000 16.0000 256.0000 53 0.89090 0.22272 0.05568 0.00348 1.1225 4.4898 1.795 9 287.3503 54 0.79370 0.19843 0.04961 0.00310 1.2599 5.0397 20.1587 322.5398 55 0.70711 0.17678 0.01494020.416 5.6569 22.6274 362.0387 56 0.62996 0.15749 0.03937 0.00246 1.5874 6.3496 25.3984 406.3747 57 0.536 20.0381035 0.00219 1.7818 7.1272 28.5088 456.1401 58 0,50000 0,12500 0,03125 0,00195 2,0000 8,0000 32,0000 512,0000 59 0,44545 0,11136 0,02784 0,00174 2,2449 8,9797 35,9188 574,7006 60 0,39685 0,09921 0,02480 0,00155 2,5198 10,0794 40,3175 645,0796 61 0,35355 0,08839 0,02210 0,00138 2,8284 11,3137 45,2548 724,0773 62 0,31498 0,07875 0,01969 0,00123 3,1748 12,6992 50,7968 812,7493 63 0,28062 0,07015 0,01754 0,00110 3,5636 14,2544 57,0175 912,2803 64 0,25000 0,06250 0,01563 0,00098 4,0000 16,0000 64,0000 1024,0000 65 0,22272 0,05568 0,01392 0,00087 4,4898 17,9594 71,8376 1149,4011 66 0,19843 0,04961 0,01240 0,00078 5,0397 20,1587 80,6349 1290,1592 67 0,17678 0,04419 0,01105 0,00069 5,6569 22,6274 90,5097 1448,1547 68 0,15749 0,03937 0,00984 0,00062 6,3496 25,3984 101,5937 1625,4987 69 0,14031 0,03508 0,00877 0,00055 7,1272 28,5088 114,0350 1824,5606 70 0,12500 0,03125 0,00781 0,00049 8,0000 32,0000 128,0000 2048,0000 71 0,11136 0,02784 0,00696 0,00044 8,9797 35,9188 143,6751 2298,8023 72 0,09921 0,02480 0,00620 0,00039 10,0794 40,3175 161,2699 2580,3183 73 0,08839 0,02210 0,00552 0,00035 11,3137 45,2548 181,0193 2896,3094 74 0,07875 0,01969 0,00492 0,00031 12,6992 50,7968 203,1873 3250,9974 75 0,07015 0,01754 0,00438 0,00027 14,2544 57,0175 228,0701 3649,1211 76 0,06250 0,01563 0,00391 0,00024 16,0000 64,0000 256,0000 4096,0000 77 0,05568 0,01392 0,00348 0,00022 17,9594 71,8376 287,3503 4597,6045 78 0,04961 0,01240 0,00310 0,00019 20,1587 80,6349 322,5398 5160,6366 79 0,04419 0,01105 0,00276 0,00017 22,6274 90,5097 362,0387 5792,6188 80 0,03937 0,00984 0,00246 0,00015 25,3984 101,5937 406,3747 6501,9947 81 0,03508 0,00877 0,00219 0,00014 28,5088 114,0350 456,1401 7298,2423 82 0,03125 0,00781 0,00195 0,00012 32,0000 128,0000 512,0000 8192,0000 83 0,02784 0,00696 0,00174 0,00011 35,9188 143,6751 574,7006 9195,2091 84 0,02480 0,00620 0,00155 0,00010 40,3175 161,2699 645,0796 10321,273 2 85 0,02210 0,00552 0,00138 0,00009 45,2548 181,0193 724,0773 11585,237 5 86 0,01969 0,00492 0,00123 0,00008 50,7968 203,1873 812,7493 13003.989, Petition 870250093109, dated 10 / 10 / 2025, pp. 475 / 541 39 / 88 Scale bitDepthPosition iScale bitDepthPosition QP 8 10 12 16 8 10 12 16 4 87 0.01754 0.00438 0.00110 0.00007 57.0175 228.07 0.28092 14596.484 6 88 0.01563 0.00391 0.00098 0.00006 64.0000 256.0000 1024.0000 16384.000 0 89 0.01392 0.0040 80.070 0.00005 71.8376 287.3503 1149.4011 18390.418 2 90 0.01240 0.00310 0.00078 0.00005 80.6349 322.5398 11298 20642.546 5 91 0.01105 0.00276 0.00069 0.00004 90.5097 362.0387 1448.1547 23170.475 0 92 0.00984 0.00202026 0.00004 101.5937 406.3747 1625.4987 26007.978 8 93 0.00877 0.00219 0.00055 0.00003 114.0350 456.101010.564 29192.969 2 94 0.00781 0.00195 0.00049 0.00003 128.0000 512.0000 2048.0000 32768.000 0 95 0.00696 0.007040404 0.00003 143.6751 574.7006 2298.8023 36780.836 4 96 0.00620 0.00155 0.00039 0.00002 161.2699 645.097 2.838 41285.093 0 97 0.00552 0.00138 0.00035 0.00002 181.0193 724.0773 2896.3094 46340.950 0 98 0.00492 0.0020.0103 0.00002 203.1873 812.7493 3250.9974 52015.957 7 99 0.00438 0.00110 0.00027 0,00002 228,0701 912,2803 3649,1211 58385,938 4 100 0,00391 0,00098 0,00024 0,00002 256,0000 1024,0000 4096,0000 65536,000 0,

[107] The quantization process used to quantize (directly / inversely) the coefficients of the displacement vector components after the transformation has the following shortcomings: • The quantization parameter (QP) is in the range of 0 to 51 (as described above in relation to the lift-transform and semantic parameter set), which restricts the quantization of large coefficients depending on the maximum position bit depth. For example, the maximum iScale value is only 14.25 in the case of a bit depth of 12. On the other hand, for small position bit depths, such as 8, the lossless QP or iScale value of 1.0 is not available. This means that, for a bit depth of 8, only scaling values ​​that increase the scale of the coefficient values ​​or scaling values ​​are available. Petition 870250093109, dated 10 / 10 / 2025, pp. 476 / 541 40 / 88 equivalents that increase the precision of coefficients in floating-point arithmetic. • Although quantization formulas do not restrict the bit depth of position coordinates, in practice, the bit depth of position coordinates is restricted to a maximum of 16 bits by the quantization process formulas, because for bit depths greater than 16 the lossless scaling value of 1.0 is not available. At the same time, the maximum value of position bit depth that can be signaled appears to be 32 according to the vmesh extension syntax of the WD 2.0 V3C parameter set: vps_ext_mesh_attribute_bitdepth_minus1[j][i] indicates the bit depth of the i-th attribute for the atlas with atlas ID j. vps_ext_mesh_attribute_bitdepth_minus1[j] must be in the range 0 to 31, inclusive. • In the case of large QP values, or equivalently, a large inverse scaling factor, the reconstructed position coordinates may exceed the maximum position bit depth. This can occur in the case of a rogue bitstream signaling large, quantized wavelet coefficients. • In addition, the iLodScale factor (liftingLevelOfDetailInverseScale or vmc_transform_log2_lifting_lod_inverse_scale_x / y / z) can further increase the scaling factor with increasing level of detail (as described in relation to inverse quantization of wavelet coefficients). • There is no restriction on its value. • Quantization scaling formulas are designed so that the inverse scale doubles in value for every 6-unit increase in the parameter. Petition 870250093109, dated 10 / 10 / 2025, pp. 477 / 541 41 / 88 quantization. For certain applications, this may be restrictive and additional units are needed, or fewer units.

[108] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to use an extended QP range. Given the current quantization scale (floating-point precision) formulas in WD 2.0 by offset dimension: iscale[d] = qp >= 0 ? pow(0,5, 16 - bitDepthPosition + (4 - qp) / 6):0,0 Formula (1) scale[d] = qp >= 0 ? pow(2,0, 16 - bitDepthPosition + (4 - qp) / 6):0,0 Formula (2)

[109] The current QP range 0...51 is extended to the range 0...100. The value 100 is determined as follows. Given a position bit depth B and given that the position coordinates are unsigned integer values, the maximum positive value is equal to (pow(2,B-1)-1) while the smallest negative value is -(pow(2,B-1)), where the function pow(M,E) represents M to the power of E. For example, for a bit depth B equal to 16, the range of values ​​is -32768.32767. From Table 2, it can be determined that, for a given bit depth, the scaling value corresponding to QP equal to 100 can be such that when a value is quantized with this scaling value, the value can be rounded to the integer 0. For example, in the case of bit depth 16, the range of values ​​-32768...32767 can be quantized to the range -0.5...0.499 and after rounding to an integer with a typical function floor (x + 0.5), the value 0 is obtained.In some examples, the current QP range can be extended to the range 0...99 or a maximum QP value close to 100.

[110] Similarly, to mitigate the problem that, for lower bit depths, such as 8, the lossless scaling factor Petition 870250093109, dated 10 / 10 / 2025, pp. 478 / 541 42 / 88 Since 1.0 is not available for the current QP range 0...51, the QP range requires extension. For example, to include lossless scaling for bit depth 8, the QP range needs to be extended to at least 0...52. In another example, to include lossless scaling for bit depth 6, the QP range needs to be extended to at least 0...64. However, these ranges are insufficiently large because all scaling values ​​within these ranges would correspond to scaling of the coefficients or an equivalent increase in the coefficient values. Therefore, the QP range 0...100 would include scaling values ​​that quantize the coefficient values.

[111] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured for extended position bit depth support. Given the current quantization scale (floating-point precision) formulas in WD2.0 per offset dimension: iscale[d] = qp >= 0 ? pow(0,5, 16 - bitDepthPosition + (4 - qp) / 6):0,0 Formula (1) scale[d] = qp >= 0 ? pow(2,0, 16 - bitDepthPosition + (4 - qp) / 6):0,0 Formula (2)

[112] The value 16 in the formulas is a constant that influences which maximum position bit depth has useful scaling factors, as listed in Table 2. For example, if the bit depth exceeds 16, the lossless scaling value of 1.0 may be unavailable as explained above. To support higher position bit depths, the value 16 would need to be increased. For example, for a bit depth of 20, the value should be adjusted to at least the value 20. In this way, the lossless scaling of 1.0 would be included. The modified value can be signaled in the bitstream, for example, in a sequence parameter set or equivalent. In Petition 870250093109, dated 10 / 10 / 2025, pp. 479 / 541 43 / 88 some examples, an integer offset value with or without sign (shown between << >> below) on top of the default value, in this case 16, can be signed, for example, in a sequence parameter set or equivalent: iscale[d] = qp >= 0 ? pow(0.5, 16 + < <offset>> - bitDepthPosition + (4 - qp) / 6):0,0 Formula (3) scale[d] = qp >= 0 ? pow(2,0, 16 + < <offset>>- bitDepthPosition + (4 - qp) / 6):0.0 Formula (4)

[113] In some examples, the bitDepthPosition variable can be modified into the bitDepthDisplacement variable, which indicates the maximum bit depth of the displacement vector coefficients after the transformation (incl. identity), as described above. In this case, the bit depth corresponds only to the data per displacement dimension that is undergoing the quantization process, as follows: iscale[d] = qp >= 0 ? pow(0.5, 16 + < <offset>>- bitDepthDisplacement + (4 - qp) / 6):0,0 Formula (5) scale[d] = qp >= 0? pow(2.0, 16 + < <offset>>- bitDepthDisplacement + (4 - qp) / 6):0.0 Formula (6) Or without the compensation variable: iscale[d] = qp >= 0 ? pow(0.5, 16 - bitDepthDisplacement + (4 - qp) / 6):0.0 Formula (7) scale[d] = qp >= 0 ? pow(2.0, 16 - bitDepthDisplacement + (4 - qp) / 6):0.0 Formula (8) Petition 870250093109, dated 10 / 10 / 2025, pp. 480 / 541 44 / 88

[114] The bit depth variable of the bitDepthDisplacement vector component can be signaled in the bitstream, for example, in the sequence parameter set.

[115] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to implement a detail scaling factor restriction level.

[116] The ilodScale factor (liftingLevelOfDetailInverseScale or vmc_transform_log2_lifting_lod_inverse_scale_x / y / z) can further modify the inverse scaling factor with increasing level of detail (as described above in relation to inverse quantization of wavelet coefficients). There is no restriction on its value range in WD 2.0, other than being signaled in the bitstream as an unsigned integer, meaning that the inverse scale can remain the same (value 0) or increase (value greater than 0): liftingLevelOfDetailInverseScale is a 1D array of size 3 that indicates the inverse scaling factor associated with the three dimensions of displacement. Table 3 vmc_lifting_transform_parameters(index, ltpIndex){ Descritor vmc_transform_lifting_skip_update_flag[index][ltpIndex] u(1) vmc_transform_lifting_quantization_parameters_x[index][ltpIndex] u(6) vmc_transform_lifting_quantization_parameters_y[index][ltpIndex] u(6) vmc_transform_lifting_quantization_parameters_z[index][ltpIndex] u(6) vmc_transform_log2_lifting_lod_inverse_scale_x[index][ltpIndex] ue(v) vmc_transform_log2_lifting_lod_inverse_scale_y[index][ltpIndex] ue(v) vmc_transform_log2_lifting_lod_inverse_scale_z[index][ltpIndex] ue(v) vmc_transform_log2_lifting_update_weight[index][ltpIndex] ue(v) vmc_transform_log2_lifting_prediction_weight[index][ltpIndex] ue(v)}

[117] vmc_transform_log2_lifting_lod_inverse_scale_x[i][ltpIndex] indica o fator de escalamento aplicado ao componente x dos coeficientes de wavelets de deslocamentos para cada nível de detalhe.

[118] vmc_transform_log2_lifting_lod_inverse_scale_y[i][ltpIndex] Petition 870250093109, dated 10 / 10 / 2025, pp. 481 / 541 45 / 88 indicates the scaling factor applied to the y-component of the displacement wavelet coefficients for each level of detail.

[119] vmc_transform_log2_lifting_lod_inverse_scale_z[i][ltpIndex] indicates the scaling factor applied to the z component of the displacement wavelet coefficients for each level of detail.

[120] syntax_element[i][ltpIndex] with i equal to 0 can be applied to the offset. syntax_element[i][ltpIndex] with i equal to non-zero can be applied to the (i-1)-th attribute, where ltpIndex is the index of the elevation transform parameter set list.

[121] A potential benefit of restricting the LoD scaling factor is a reduced number of decoder compliance tests required, for example, fewer test bitstreams, etc. In this disclosure, it is proposed to have a maximum value for the inverse LoD scaling factor, for example, a value of 8 (u(2) indicates a 2-bit unsigned integer with a maximum value of 3 => 2Λ3): Table 4 vmc_lifting_transform_parameters(index, ltpIndex){ Descriptor vmc_transform_lifting_skip_update_flag[index][ltpIndex] u(1) vmc_transform_lifting_quantization_parameters_x[index][ltpIndex] u(6) vmc_transform_lifting_quantization_parameters_y[index][ltpIndex] u(6) vmc_transform_lifting_quantization_parameters_z[index][ltpIndex] u(6) vmc_transform_log2_lifting_lod_inverse_scale_x[index][ltpIndex] u(2) vmc_transform_log2_lifting_lod_inverse_scale_y[index][ltpIndex] u(2) vmc_transform_log2_lifting_lod_inverse_scale_z[index][ltpIndex] u(2) vmc_transform_log2_lifting_update_weight[index][ltpIndex] ue(v) vmc_transform_log2_lifting_prediction_weight[index][ltpIndex] ue(v)}

[122] Potentially, this maximum value may depend on the number of levels of detail. For example, a LoD scaling factor value may be signaled separately per LoD. For example, in WD 2.0: `subdivisionIterationCount` is a variable that indicates the number of subdivision iterations.

[123] asps_vmc_ext_subdivision_iteration_count indicates the number of Petition 870250093109, dated 10 / 10 / 2025, pp. 482 / 541 46 / 88 iterations are used for subdivision. When not present, the value of asps_vmc_ext_subdivision_iteration_count is inferred to be 0. Table 5 vmc_lifting_transform_parameters(index, ltpIndex){ Descritor vmc_transform_lifting_skip_update_flag[index][ltpIndex] u(1) vmc_transform_lifting_quantization_parameters_x[index][ltpIndex] u(6) vmc_transform_lifting_quantization_parameters_y[index][ltpIndex] u(6) vmc_transform_lifting_quantization_parameters_z[index][ltpIndex] u(6) for(i = 0; i< asps_vmc_ext_subdivision_iteration_count; i++){ vmc_transform_log2_lifting_lod_inverse_scale_x[index][ltpIndex][i] ue(v) ou u(2) vmc_transform_log2_lifting_lod_inverse_scale_y[index][ltpIndex][i] ue(v) ou u(2) vmc_transform_log2_lifting_lod_inverse_scale_z[index][ltpIndex][i] ue(v) ou u(2)} vmc_transform_log2_lifting_update_weight[index][ltpIndex] ue(v) vmc_transform_log2_lifting_prediction_weight[index][ltpIndex] ue(v)}

[124] Em alguns exemplos, os parâmetros de quantização podem ser sinalizados por nível de detalhe, no lugar dos valores de escala. Tabela 6 vmc_lifting_transform_parameters(index, ltpIndex){ Descriptor vmc_transform_lifting_skip_update_flag[index][ltpIndex] u(1) for(i = 0; i< asps_vmc_ext_subdivision_iteration_count; i++){ vmc_transform_lifting_quantization_parameters_x[index][ltpIndex][i] u(6) vmc_transform_lifting_quantization_parameters_y[index][ltpIndex][i] u(6) vmc_transform_lifting_quantization_parameters_z[index][ltpIndex][i] u(6)} vmc_transform_log2_lifting_update_weight[index][ltpIndex] ue(v) vmc_transform_log2_lifting_prediction_weight[index][ltpIndex] ue(v)}

[125] In some examples, quantization parameters may be signaled separately for LODs in addition to base QP signaled for lifting (i.e., vmc_transform_lifting_quantization_parameters_x / y / z). The syntax table may be as follows: Table 7 vmc_lifting_transform_parameters(index, ltpIndex){ Descritor vmc_transform_lifting_skip_update_flag[index][ltpIndex] u(1) vmc_transform_lifting_quantization_parameters_x[index][ltpIndex] u(6) vmc_transform_lifting_quantization_parameters_y[index][ltpIndex] u(6) Petição 870250093109, de 10 / 10 / 2025, pág. 483 / 541 47 / 88 vmc_lifting_transform_parameters(index, ltpIndex){ Descritor vmc_transform_lifting_quantization_parameters_z[index][ltpIndex] u(6) for(i = 0; i< asps_vmc_ext_subdivision_iteration_count; i++){ vmc_transform_lifting_lod_qp_offset_x[index][ltpIndex][i] u(6) vmc_transform_lifting_lod_qp_offset_y[index][ltpIndex][i] u(6) vmc_transform_lifting_lod_qp_offset_z[index][ltpIndex][i] u(6)} vmc_transform_log2_lifting_update_weight[index][ltpIndex] ue(v) vmc_transform_log2_lifting_prediction_weight[index][ltpIndex] ue(v)}

[126] The QP applied to a particular LOD can be obtained by combining the base QP parameters and one or more QP compensation parameters for the respective dimension.

[127] - In one example, LOD offsets are signaled wrt for the base QP. Thus, for dimension x, QP applied to LOD level L, QPl can be derived as vmc_transform_lifting_quantization_parameters_x[index][ltpIndex]+ vmc_transform_lifting_lod_qp_offset_x[index][ltpIndex][i].

[128] - In another example, LOD offsets are signaled relative to the QP of the previous LOD level. Thus, for dimension x, QPL is derived as (L == 0? vmc_transform_lifting_quantization_parameters_x[index][ltpIndex]:QPL-1)+ vmc_transform_lifting_lod_qp_offset_x[index][ltpIndex][i].

[129] (The above examples also apply similarly to the other yez dimensions).

[130] Note that although the examples above show that the QP parameters are signaled as a 6-bit value, depending on the allowed QP range, the number of bits may be different. For example, if the QP range is 0 to 100, then the QP offsets may range from [-100, 100] and an 8-bit value may be used to signal the QP offsets. Petition 870250093109, dated 10 / 10 / 2025, pp. 484 / 541 48 / 88

[131] In some examples, a QP offset / scale can be signaled for each LOD level and applied to all three dimensions x, y, and z.

[132] In another example, the signaling of QP offset / scaling values ​​for LODs can be controlled by a flag that specifies whether QP offset / scaling values ​​are signaled at the LOD level granularity. An example of such signaling is as follows (shown between ** ** below): Table 8 vmc_lifting_transform_parameters(index, ltpIndex){ Descritor vmc_transform_lifting_skip_update_flag[index][ltpIndex] u(1) vmc_transform_lifting_quantization_parameters_x[index][ltpIndex] u(6) vmc_transform_lifting_quantization_parameters_y[index][ltpIndex] u(6) vmc_transform_lifting_quantization_parameters_z[index][ltpIndex] u(6) **vmc_transform_lifting_lod_qp_present_flag[index][ltpIndex]** **u(1)** **if(vmc_transform_lifting_lod_qp_present_flag[index][ltpIndex])** for(i = 0; i< asps_vmc_ext_subdivision_iteration_count; i++){ vmc_transform_lifting_lod_qp_offset_x[index][ltpIndex][i] u(6) vmc_transform_lifting_lod_qp_offset_y[index][ltpIndex][i] u(6) vmc_transform_lifting_lod_qp_offset_z[index][ltpIndex][i] u(6)} vmc_transform_log2_lifting_update_weight[index][ltpIndex] ue(v) vmc_transform_log2_lifting_prediction_weight[index][ltpIndex] ue(v)}

[133] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to implement a reconstructed vertex position constraint.

[134] As described above regarding position displacement, vertex positions are reconstructed using displacement vectors as follows: for (v = 0; v < positionCount; ++v) { for(d = 0; d < 3; d++) { positionsDisplaced[v][d] = positionsSubdiv[v][d] + dispArray[v][0] * normals[v][d] + Petition 870250093109, dated 10 / 10 / 2025, pp. 485 / 541 49 / 88 dispArray[v][1] * tangents[v][d] + dispArray[v][2] * bitangents[v][d]}}

[135] It can be observed that the positionsDisplaced array is obtained by summing the coordinates of the subdivided mesh vertex and the corresponding displacement vector components projected onto the coordinate system, for example, the local system (normal, tangential, bitangential). However, given that the inverse quantization / scaling operation is unbounded, the reconstructed displaced positions may exceed the maximum position bit depth. This disclosure establishes possible solutions to this problem. • After adding the displacement vector components, the reconstructed positions (positionsDisplaced) values ​​are clipped depending on the minimum and maximum position values, for example: Clip3(min position, max position, positionsDisplaced) or Clip3(0, max position, positionsDisplaced) with maximum position determined by ((1 << bitDepthPosition) - 1) and Clip3() a function defined as: Clip3(x, y, z)-' < Otherwise Equation (5) • In some examples, a normative restriction is imposed that a compatible bitstream may not result in reconstructed vertex positions that exceed the minimum and maximum position values ​​as determined, for example, based on the bit depth value of the position: 0...((1 << bitDepthPosition) - 1)

[136] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to perform parameter granularity adjustment. Petition 870250093109, dated 10 / 10 / 2025, pp. 486 / 541 50 / 88 quantization. Given the current quantization scale formulas (floating-point precision) in WD 2.0 per displacement dimension: iscale[d] = qp >= 0 ? pow(0.5, 16 - bitDepthPosition + (4 - qp) / 6):0.0 Formula (1) scale[d] = qp >= 0 ? pow(2,0, 16 - bitDepthPosition + (4 - qp) / 6):0,0 Formula (2)

[137] Additional quantization scale granularity is achieved by increasing the value 6, for example, to the value 8, while granularity is reduced by decreasing the value 6, for example, to the value 4 or 2.

[138] The quantization process is in floating-point precision, while the quantized wavelet coefficients are encoded in a 2D video frame with integer precision. Possible solutions to this problem will now be discussed.

[139] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured for integer precision implementation. According to the techniques of this disclosure, the shift bitstream decoding process is converted from floating-point to integer arithmetic. The shift bitstream encoding process is described above in relation to Figure 9. Having the decoding process in integer arithmetic makes the decoder conformance feasible, because integer arithmetic is deterministic, while floating-point arithmetic can be platform implementation dependent.

[140] The offset bitstream is first decoded by the video decoder (e.g., 716 video / picture decoding) resulting in a 2D frame with pixels that correspond to the compressed quantized wavelet coefficients. In some examples, a different decoding process may be employed, such as a decoder Petition 870250093109, dated 10 / 10 / 2025, pp. 487 / 541 51 / 88 context-adaptive arithmetic. In both cases, the uncompressed quantized wavelet coefficients are integer values, and in the current implementation, these integer values ​​are converted to floating-point values ​​which are subsequently inversely quantized (floating-point) and inverse wavelet transformed (floating-point) before the resulting displacement vector values ​​are added to the reconstructed basis mesh. According to the techniques of this disclosure, integer arithmetic is preserved for inverse quantization and inverse wavelet transform. This enables efficient and accurate arithmetic.

[141] Similarly, the encoding process is adapted to integer arithmetic (quantization, wavelet transform), however, the encoder side is non-normative from a standard perspective. The following sections of this disclosure describe the entire implementations.

[142] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured for precision adjustment. In current implementations, displacement vectors are computed in floating-point precision as the difference between the subdivided basis mesh and the original mesh. Subsequently, the forward lift scheme and forward quantization are both implemented in floating-point precision up to the point where the 2D frame is compressed and conversion to integer values ​​is required. Given that the encoder process is non-normative, it depends on the implementation whether floating-point precision or integer precision should be used for transformation and quantization processes. In either case, the encoder implementation can also benefit from an efficient integer implementation.

[143] In one example, the V-DMC 200 encoder and the decoder Petition 870250093109, dated 10 / 10 / 2025, pp. 488 / 541 52 / 88 V-DMC 300s can be configured to round floating-point displacement vector values ​​(assuming these are floating-point precision meshes; otherwise, retain integer values) to integer or fixed-point values. Alternatively, the precision of integer values ​​is adjusted or increased by multiplying the floating-point values ​​before rounding. Typically, the precision increase is achieved by multiplying by a power of two value. The increased precision makes the transform and quantization process calculations more accurate.

[144] In one example, reverse precision boosting is performed before compressing the 2D frame and video encoding or any other encoding process. Reverse precision is achieved by dividing by the applied value or by a right bit shift if the value is a power of two. Rounding can also be applied, for example, symmetric rounding. The following pseudocode is an example of precision boosting: double precision = (double)(1 << PRECISION); for (int32_t i = 0; i < 3; ++i) { dispint[v][i] = (int32_t)round(disp[v][i] * precision);} where i is an index indicating the v component of the displacement vector in the dispint array. An example of the reverse process: int32_t precision = PRECISION; int32_t offset = 1 << (PRECISION - 1); for (int32_t i = 0; i < 3; ++i) { int32_t val = dispint[v][i]; dispint[v][i] = (val < 0 ? -((-val + offset) >> precision):((val + offset) >> precision)));} Petition 870250093109, dated 10 / 10 / 2025, pp. 489 / 541 53 / 88

[145] In another example, precision reversal can be integrated with the direct quantization process, as illustrated in the following section.

[146] On the decoder side, a similar adjustment or increase in precision can be implemented for the inverse quantization and transform processes, which would be normative from a standard perspective. After decoding the 2D quantized coefficients with a video decoder (2D compressed frame) or other decoding process, in the current implementation, floating-point precision is used for the quantization and inverse transform processes. This disclosure proposes techniques to increase the precision of the quantized coefficients after decoding and maintain them as integers throughout the inverse quantization and inverse transform processes, while only converting to floating-point when the mesh is reconstructed (assuming the mesh is floating-point, otherwise keep them as integers). This makes it possible for the decoder's conformity to a standard to be verified before reconstructing the mesh.

[147] The following pseudocode illustrates the precision increase operation: int32_t precision = PRECISION; for (int32_t i = 0; i < 3; ++i) { plane = dispVideoFrame.plane(i); dispint[v][i] = (plane.get(y1, x1) - shift) << precision;} where i is an index indicating the quantized coefficient of the v component of the displacement vector in the dispint array, as well as the video frame component (dispVideoFrame). Shift represents a value used to compensate for negative values ​​before compressing the video frame.

[148] In one example, before adding the displacement vectors to the reconstructed and subdivided base mesh, the precision increase is reversed as in the following pseudocode example: Petition 870250093109, dated 10 / 10 / 2025, pp. 490 / 541 54 / 88 int32_t precision = PRECISION, int32_t offset = 1 « (PRECISION - 1); for(int32_t i = 0; i < 3; ++i) { int32_t val = dispint[v][i]; dispint[v][i] = (val < 0 ? -((-val + offset) » precision) : ((val + offset) » precision));}

[149] In another example, precision reversal is implemented in floating-point precision as illustrated in the following pseudocode: const auto& disp = frame.dispint; double precision = (double)(l«PRECISION); for (int32_t v = 0, vcount = rec.pointCountQ, v < vcount, ++v) { auto d = disp[v]; if (displacementCoordinateSystem = DisplacementCoordinateSystem: LOCAL) { const auto n = rec.normal(v), Vec3 <meshtype>t{}; Vec3 <meshtype>b{}; computeLocalCoordinatesSystem(n, t, b); rec.point(v) += (double)d[0] * n / precision + (double)d[ l] * t / precision + (double)d[2] * b / precision; } else { for(int32_t i = 0; i < 3; ++i) rec.point(v)[i] += (double)d[i] / precision;

[150] In this code, the dispint array contains the components of the displacement vector after inverse quantization and inverse transform, but before Petition 870250093109, dated 10 / 10 / 2025, pp. 491 / 541 55 / 88 of the precision reversal. The for-loop traverses the vertex positions to be corrected with the displacement vectors, with the normal vector if the local coordinate system is used.

[151] Furthermore, or as an alternative to precision adjustment before the forward transform, precision adjustment can be performed as part of the transform. Similarly, precision adjustment can be performed as part of inverse quantization.

[152] In addition, or as an alternative to adjusting the precision of the quantization and transform processes, the precision of these processes can be adjusted separately or the precision of only one of them can be adjusted as needed.

[153] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to perform integer precision quantization. The actual quantization process is implemented in floating-point precision, while the quantized wavelet coefficients are encoded into a 2D video frame with integer precision. According to the techniques of this disclosure, the quantization process can also be implemented with integer precision arithmetic.

[154] Given the current quantization scale (floating-point precision) formulas in WD2.0 per displacement dimension d: iscale[d] = qp[d] >= 0 ? pow(0.5, 16 - bitDepth + (4 - qp[d]) / 6):0.0 Formula (9) scale[d] = qp[d] >= 0 ? pow(2,0, 16 - bitDepth + (4 - qp[d]) / 6):0,0 Formula (10) with iscale the inverse scaling factor, escale the forward scaling factor, bitDepth the position bit depth or the offset bit depth, qp[d] the quantization parameter applied to the dimension of Petition 870250093109, dated 10 / 10 / 2025, pp. 492 / 541 56 / 88 shift of pow(x,y) the function x in the power y (xAy).

[155] The reverse and forward scaling functions can be rewritten as follows (the notation qp[d] is simplified to qp): iscale[d] = qp >= 0 ? pow(2, (qp - 4) / 6 + bitDepth - 16):0 scale[d] = qp >= 0 ? pow(2, - (qp - 4) / 6 + 16 - bitDepth):0 and: iscale[d] = qp >= 0 ? pow(2, (qp - 4) / 6) * pow(2, bitDepth - 16):0 scale[d] = qp >= 0 ? pow(2, - (qp - 4) / 6) * pow(2, 16 - bitDepth):0 Then, (qp - 4) is expanded as follows: (qp - 4) = 6 * q + r with q the quotient after dividing (qp - 4) by 6 and the remainder. Then, the formulas can be written as: iscale[d] = qp >= 0 ? pow(2, r / 6) * pow(2, bitDepth + q 16):0 Formula (11) scale[d] = qp >= 0 ? pow(2, - r / 6) * pow(2, 16 - bitDepth q):0 Formula (12)

[156] It can be observed that the second factors (powers of 2) in both cases can be implemented with bitwise shift operators (<< and >>), while the first factors are approximated with lookup tables as follows: iscale[d] = qp >= 0 ? irtable[r] * pow(2, bitDepth + q - 16):0 Equation (6) scale[d] = qp >= 0 ? irtable[r] * pow(2, 16 - bitDepth - q):0 Equation (7) In one example, the tables are defined as follows: irtable [r] = { 64, 72, 81, 91, 102, 114} / 64 rtable [r] = { 64, 57, 51, 45, 40, 36} / 64 Petition 870250093109, dated 10 / 10 / 2025, pp. 493 / 541 57 / 88 where r is in the range of 0 to 5, inclusive. The denominator 64 can be implemented with the right bit shift operator (» 6). Note that the inverse quantization process on the decoder side is normative (standards perspective), while the quantization process on the encoder side is non-normative. This means that the precision of irtable and rtable can be different, or the values ​​in the table can be different. Other irtable values ​​and precisions can also be constructed, and the table above is an example; however, from a standards perspective, such a table is normative. For example, tables with a denominator of 128 are as follows: irtable [r] = { 128, 144, 161, 181, 203, 228} / 128 rtable [r] = { 128, 114, 102, 91, 81, 72} / 128

[157] For the interval qp from 0 to 100, as described above, the quotient q is in the interval from 0 to 16. However, since (qp - 4) = 6 * q + r, with q r positive integers, the allowed interval of qp is adjusted to 4...100: iscale[d] = qp >= 4 ? irtable[r] * pow(2, bitDepth + q - 16):0 scale[d] = qp >= 4 ? rtable[r] * pow(2, 16 - bitDepth - q):0

[158] The inverse and direct quantization processes are modified as follows in some examples: • Inverse quantization / scaling process (as described above in relation to the inverse quantization of wavelet coefficients): irtable [ r ] = { 64, 72,81,91, 102, 114} for ( d = 0; d < 3; ++d ) { qp = QP[d] q = (qp-4) / 6 r = (qp-4)-6*q Petition 870250093109, dated 10 / 10 / 2025, pp. 494 / 541 58 / 88 iscale[d] = qp >= 4 ? (irtablefr] « ( bitDepth + q )): 0 ilodScale[ d ] = liftingLevelOfDetailInverseScale[ d ] vcountO = 0 for( i = 0; i < subdivisionlterationCount, i++ ) { vcountl = levelOfDetailAttributeCountsf i ] for( v = vcountO; v < vcountl, v++ ) { fbr( d = 0; d < 3; d++) { val = dispQuantCoeffArrayf v ][ d ] * iscale[ k ] dispQuantCoeffArray [ v ][ d ] = val < 0 ? -((-val+ (1 «(16+ 5))) »(16+ 6)) : ((val + (1 «(16 + 5)))»(16 + 6))} } vcountO = vcountl for( d = 0; d < 3; d++) { iscale[d] *= ilodScale[ d ]

[159] In some examples, the value of irtable[r] « (bitDepth + q) can be stored as a table, such as Table 9 below, instead of just irtable[r]; this makes it possible for more precise values ​​to be stored. Table 9 r bitDepth + q 0 1 2 3 4 5 6 ... 16 0 64 128 256 512 1024 2048 4096 4194304 1 72 144 287 575 1149 2299 4598 4707947 2 81 161 323 645 1290 2580 5161 5284492 Petition 870250093109, dated 10 / 10 / 2025, pp. 495 / 541 59 / 88 I r bitDepth + q 0 1 2 3 4 5 6 ... 16 1 5 114 228 456 912 1825 3649 7298 7473400

[160] For large bitdepth + q values, table insertions can become very large. Therefore, a maximum precision can be defined (e.g., 8 or 16); in addition, the values ​​are shifted to the left as follows: prec = min(16, bitDepth + q) The term irtable[r] << (bitDepth + q) is replaced as irtable_higherPrec[r][prec] << (bitdepth + q - prec) Table 10: irtable_higherPrec[r][prec] r prec 0 1 2 3 4 5 6 ··· 16 0 64 128 256 512 1024 2048 4096 • · · 4194304 1 72 144 287 575 1149 2299 4598 • · · 4707947 2 81 161 323 645 1290 2580 5161 · 5284492 3 91 181 362 724 1448 2896 5793 • · · 5931642 4 102 203 406 813 1625 3251 6502 • · · 6658043 5 114 228 456 912 1825 3649 7298 • · · 7473400

[161] If the maximum precision value is set to 9, then the highest value in the table would be 114 << 9, and each insertion in the table can be stored within 2 bytes.

[162] A similar table can be used by the encoder for direct scaling.

[163] The definition and signaling of liftingLevelOfDetailInverseScale[d] can be modified to eliminate the multiplication operation (iscale[d] *= ilodScale[d]) and instead, bit shift operators can be used (iscale[d] <<= ilodScale[d]). For example, the factor 2.0 is modified to a left bit shift by 1. Normally, the inverse scaling factor would increase with increasing level of detail. Alternatively, liftingLevelOfDetailInverseScale[d] can be represented and signaled in Petition 870250093109, dated 10 / 10 / 2025, pp. 496 / 541 60 / 88 bitstream as a quantization parameter offset value that is added to the quantization parameter value with each increase in the level of detail.

[164] In this example, irtable and rtable are defined independently of bitDepth and the precision is in units of 1 / 64. However, the precision of the table and therefore the precision of the quantization process can be increased if the tables are bitDepth dependent. As can be seen from the formulas, the factor pow(2, bitDepth) can be used to increase the table precision depending on the bitDepth: iscale[d] = qp >= 4 ? irtable[r] * pow(2, bitDepth) * pow(2, q - 16):0 scale[d] = qp >= 4 ? rtable[r] * pow(2, - bitDepth) * pow(2,16 - q):0

[165] In this example, pow(2, bitDepth), which is equivalent to a left bit shift, can be used wholly or partially to increase the precision of irtable and, similarly, the precision of rtable.

[166] The following is an example of a direct quantization / scaling process: rtable [r] = { 64, 57, 51, 45, 40, 36} for ( d = 0; d < 3; ++d ) { qp = QP[d] q = ( qp - 4 ) / 6 r=(qp-4)-6*q scale[ d ] = qp >= 4 ? ( rtablefr] « 16 ): 0 ilodScalef d ] = liftingLevelOfDetail!nverseScale[ d ] vcountO = 0 for( I = 0; I < subdivisionlterationCount; i++ ) { vcountl = levelOfDetailAttributeCounts[ I ] for( v = vcountO; v < vcountl; v++ ) { for( d = 0; d < 3; d++ ) { qp = QP[d] Petition 870250093109, dated 10 / 10 / 2025, pp. 497 / 541 61 / 88 q = (qp—4) / 6 rshift = bitDepth + q + 6 val - dispCoeffArray[ v ][ d ] * scale[ k ] dispCoeffArray [ v ][ d ] = val < 0 ? -((-val + liftingBiasf d ])» rshift) : ((val + liftingBiasf d ])» rshift )} vcountO = vcountl for( d = 0, d < 3; d++) { scalefd] / = ilodScale[ d ]}

[167] In another example, precision reversal, as described in the previous section, is integrated into the forward quantization process as follows: rtable [ r ] = { 64, 57, 51, 45, 40, 36} for ( d = 0; d < 3; ++d) { qp = QP[ d ] q = ( qp - 4 ) / 6 r=(qp-4)-6*q scale[ d ] = qp >= 4 ? ( rtable[r] «16 ): 0 ilodScale[ d ] = liftingLevelOfDetaillnverseScalef d ] vcountO = 0 for( I = 0; I < subdivisionlterationCount; i++ ) { vcount l = 1evelOfDetailAttributeCounts[ I ] for( v = vcountO; v < vcountl; v++) ( for( d = 0; d < 3; d++ ) { qp = QP[ d ] q = ( qp-4 ) / 6 rshift = bitDepth + q + 6 + PRECISION val = dispCoeffArray[ v ][ d ] * scale[ k ] Petition 870250093109, dated 10 / 10 / 2025, pp. 498 / 541 62 / 88 dispCoeffArray [ v ][ d ] = val < 0 ? -(( -val + liftingBias[ d ]) » rshift) : ((val + liftingBiasf d ]) » rshift) vcountO = vcountl for( d = 0; d < 3; d++ ) { scale[d] / = ilodScale[ d ]

[168] In the pseudocode above, PRECISION represents the number of bits that were used to increase precision.

[169] Regarding inverse scaling, the definition and signaling of ÜftingLevelOfDetailInverseScale[d] can be modified to eliminate the division operation (iscale[d] / = ilodScale[d]) and instead, bitshift operators can be used (iscale[d] »= ilodScale[d]). For example, the factor 2.0 is modified for right bitshift by 1. Typically, the forward scaling factor would decrease with increasing level of detail, meaning that quantization can become coarser with increasing level of detail. Alternatively, ÜftingLevelOfDetailInverseScale[d] can represent and be signaled in the bitstream as a quantization parameter offset value that is added to the quantization parameter value with each increase in level of detail.

[170] In the pseudocode above, liftingBias [d] is added before the final right shift operation. This value may be related to the wavelet lifting scheme that is used before the forward quantization process or it may be related to the quantization process itself, or a combination of both. According to the techniques of this disclosure, Petition 870250093109, dated 10 / 10 / 2025, pp. 499 / 541 63 / 88 liftingBias[d] can be an integer value and typically a fraction of the rshift value, for example, 1 / 3. In another example, a fraction of rshift can be obtained with the right bitshift operator (rshift»liftingBiasShift), and in this case, liftingBiasShift is signed as a positive integer value. Alternatively, an integer division operator can be used to obtain a fractional value.

[171] As an alternative to the proposed integer implementation of the inverse quantization process based on the value 6 to double the scaling value, the V-DMC 200 encoder and the V-DMC 300 decoder can be configured to perform the processes defined in G-PCC Ed.l for attribute coefficient scaling (see, for example, sections 10.5.4, 10.6.9, 10.7, etc.).

[172] In one implementation, rtable and irtable can be as follows: Table 11 Rounded Table Rounded Table Rounded Table 0 1.00 512 1.00 512 1 0.89 456 1.12 575 2 0.79 406 1.26 645 3 0.71 362 1.41 724 4 0.63 323 1.59 813 5 0.56 287 1.78 912

[173] The implementation of the direct quantization function can be implemented as follows: bool VMCEncoder: :quantizeDisplacements(VMCFrame& frame, const VMCEncoderParameters& params) { const auto& infoLevelOfDetails = frame.subdivtnfoLevelOfDetails; const auto lodCount = int32_t(infoLevelOfDetails.size()); assert(lodCount > 0); Petição 870250093109, de 10 / 10 / 2025, pág. 500 / 541 64 / 88 const auto dispDimensions = params.applyOneDimensionalDisplacement ? 1 : 3; std: :vector<std::vector<int64_t>> scales( lodCount, std::vector<int64_t>(dispDimensions, 0)); std: :vector<std::vector<int64_t>> qvals( lodCount, std::vector<int64_t>(dispDimensions, 0)); int32_t q, r; int64_t r6table[6] = {512, 456, 406, 362, 323, 287}; if (params.lodDisplacementQuantizationFlag) { / / Caso: Parâmetros QP por LoD especificado for (int32_t it = 0; it < lodCount; ++it) { auto& scale = seales[it], auto& qval = qvals[it]; for (int32_t k = 0; k < dispDimensions; ++k) { const auto qp = params. liftingQuantizationParametersPerLevelOfDetails[it][k]; assert(qp >= 4 && qp <= 100), q = (qp - 4) / 6, / / integer division -> lookup table r = (qp-4)-6 *q; assert(q >= 0 && q <= 16); assert(r >= 0 && r <= 5); assert(params.bitDepthPosition >= 4 && params.bitDepthPosition <= 16); scale[k] = (qp _ 4) >= 0 ? (rótable[r] «(16 - 7 - 2)): 0, qvalfk] = q; } else { / / Case: scaling per LoD using LoDScale factor std: :vector<int64_t> lodScale(dispDimensions); auto&scale = scales[0]; auto& qval = qvals[0]; for (int32_t k = 0; k < dispDimensions; ++k) { Petition 870250093109, dated 10 / 10 / 2025, pages 501 / 541 65 / 88 const auto qp = params.liftingQPfk]; assert(qp >= 4 && qp <= 100), q — (qp - 4) / 6; / / integer division -> lookup table r = (qp - 4) - ó * q; assert(q >= 0 && q <= 16); assert(r >= 0 && r <= 5); assert(params.bitDepthPosition >= 4 && params.bitDepthPosition <= 16), scalefk] = (qp - 4) >= 0 ? (rótablefr] « (16 - 7 - 2)): 0; qval [k] = q; lodScale[k] =!; / / »! (0.5) / / lodScale[k] =1.0 / params.liftingLevelOfDetaillnverseScalefk]; / / pesos a serem sinalizados corretamente (também arquivos de configuração) int32_t lodScaleoffset, for (int32_t it = 1, it < lodCount; ++it) { for (int32_t k = 0; k < dispDimensions; ++k) { lodScaleoffset = (1 «lodScale[k]) » 1; scales[it][k] = (scales[it - l][k] + lodScaleoffset)» lodScale[k], qvals[it][k] = qvalsfit - 1 ][k]; }} } auto& disp = frame.disp, for (int32_t it = 0, vcountO = 0; it < lodCount; ++it) { const auto& scale = scalesfit]; const auto& qval = qvals[it]; const auto vcountl = infoLevelOfDetails[it].pointCount, for (int32_t v = vcountO; v < vcountl, ++v) { Petição 870250093109, de 10 / 10 / 2025, pág. 502 / 541 66 / 88 auto& d = disp[v]; for (int32_t k = 0; k < dispDimensions; ++k) { int64_t rshift = params.bitDepthPosition + qvalfk] + 5; d[k] = d[k] >= 0 ? ((d[k] * scale[k] + (l«rshift) / 3) » rshift) : -((-d[k] * seal[k] + (l«rshift) / 3) » rshift); / / params.liftingBias[k] 0.333 / / bias weights to be correctly signaled (also configuration files)} vcountO = vcountl; return true,

[174] Inverse quantization functions can be implemented as follows: static int32_t inverseQuantizeDisplacements( / / Case: scaling by LoD using LoDScale factor VMCFrame& frame, const int32_t bitDepthPosition, const double (&liftingLevelOfDetailInverseScale)[3], const int32_t (&liftingQP)[3]) { printf(Inverse quantize displacements \n); fflush(stdout), const auto& infoLevelOfDetails = frame.subdivInfoLevelOfDetails; const auto lodCount = int32_t(infoLevelOfDetails.size()); assert(lodCount > 0); int64_t iscale[3]; int64_t ilodScale[3]; int32_t q, r; int64_t r6table[6] = {512, 575, 645, 724, 813, 912}; Petition 870250093109, dated 10 / 10 / 2025, pp. 503 / 541 67 / 88 for (Ínt32_t k = 0; k < 3; ++k) { const auto qp = HftingQP[k]; / / qp range [4...100] assert(qp >= 4 && qp <= 100); q = (qp - 4) / 6; / / integer division -> lookup table r = (qp - 4) - 6 * q; assert(q >= 0 && q <= 16); assert(r >= 0 && r <= 5); assert(bitDepthPosition >= 4 && bitDepthPosition <= 16), iscale[k] = (qp - 4) >= 0 ? (r6table[r] « (bitDepthPosition + q - 2)): 0; iLodScale[k] = I; / / « 1 / / liftingLevelOfDetail InverseScale[k]; / / weights to be correctly assigned (also configuration files) auto& disp = frame.disp; for (Ínt32_t it = 0, vcountO = 0; it < lodCount; ++it) { const auto vcountl = infoLevelOfDetails[it].pointCount; for (int32_t v = vcountO, v < vcountl; ++v) { auto& d = disp[v], for (int32_t k = 0; k < 3; ++k) { int64_t vai = d[k] * iscale[k]; d[k] = (vai < 0 ? -((-vai + (I « 22)) » (16 + 7)): ((vai + (1 « 22)) » (16 + 7))), vcountO = vcountl; for (int32_t k = 0, k < 3; ++k) { iscale[k] «= ilodScale[k];}} return 0; static int32_t inverseQuantizeDisplacements( / / Caso: Parâmetros QP por LoD especificado VMCFrame& frame, Petição 870250093109, de 10 / 10 / 2025, pág. 504 / 541 68 / 88 const int32_t bitDepthPosition, const std::vector<std::array<int32_t, 3»& liftingQuantizationParametersPerLevelOfDetails) { const auto& infoLevelOfDetails = frame. subdivInfoLevelOfDetails; const auto lodCount = int32_t(infoLevelOfDetails.size()); assert(lodCount > 0), assert(lodCount == static_cast<int32_t>( liftingQuantizationP arametersPerLevelOfD etails. size())); auto& disp = frame.disp; int32_t q, r; int64_t r6table[6] = {512, 575, 645, 724, 813, 912}; for (int32_t it = 0, vcountO = 0; it < lodCount; ++it) { int64_t iscale[3]; for (int32_t k = 0; k < 3; ++k) { const auto qp = liftingQuantizationParametersPerLevelOfDetails[it][k]; assert(qp >= 4 && qp <= 100); q = (qp - 4) / 6; / / divisão de número inteiro -> tabela de consulta r = (qp - 4) - 6 * q; assert(q >= 0 && q <= 16); assert(r >= 0 && r <= 5); assert(bitDepthPosition >= 4 && bitDepthPosition <= 16); iscalefk] = (qp - 4) >= 0 ? (r6table[r] « (bitDepthPosition + q - 2)) : 0; const auto vcountl = infoLevelOfDetailsfit],pointCount; for (int32_t v = vcountO; v < vcountl; ++v) { auto& d = dispfv]; Petição 870250093109, de 10 / 10 / 2025, pág. 505 / 541 69 / 88 for (int32_t k = 0; k < 3; ++k) { int64_t val = d[k] * iscale[k]; d[k] = (val < 0 ? -((-val + (1 « 22)) » (16 + 7)): ((val + (1 « 22)) (16 + 7))); vcountO = vcountl; return 0; }

[175] In another implementation, rtable and irtable can be as follows: Table 12 Rounded Table Rounded Table Rounded Table 0 1.00 2048 1.00 2048 1 0.89 1825 1.12 2299 2 0.79 1625 1.26 2580 3 0.71 1448 1.41 2896 4 0.63 1290 1.59 3251 5 0.56 1149 1.78 3649

[176] The implementation of the direct quantization function can be implemented as follows: bool VMCEncoder::quantizeDisplacements(VMCFrame& frame, const VMCEncoderParameters& params) { const auto& infoLevelOfDetalls = frame.subdivInfoLevelOfDetails; const auto lodCount = int32_t(infoLevelOfDetails.size()); assert(lodCount > 0); const auto dispDimensions = params.applyOneDimensionalDisplacement ? 1 std: :vector<std: :vector<int64_t» scales( lodCount, std::vector<int64_t>(dispDimensÍons, 0)); std: :vector<std: :vector<int64_t» qvals( Petição 870250093109, de 10 / 10 / 2025, pág. 506 / 541 70 / 88 lodCount, std::vector<int64_t>(dÍspDÍmensions, 0)); int32_t q, r, int64_t r6table[6] = {2048, 1825, 1625, 1448, 1290, 1149}; if (params.lodDisplacementQuantizationFlag) { for (int32_t it = 0; it < lodCount; ++it) { auto& scale = scales[it]; auto& qval = qvals[it]; for (int32_t k = 0; k < dispDimensions; ++k) { const auto qp = params. liftingQuantizationParametersPerLevelOfDetails[it][k]; assert(qp >= 4 && qp <= 100); q = (qp - 4) / 6; / / divisão de número inteiro -> tabela de consulta r = (qp - 4) - 6 * q; assert(q >= 0 && q <= 16), assert(r >= 0 && r <= 5); assert(params.bitDepthPosition >= 4 && params.bitDepthPosition <= 16); scalefk] = (qp - 4) >= 0 ? (r6table[r] « (16 - 7 - 2 - 2)): 0; qval[k] = q; } else { std:: vector 1 od Seal e(di spDi men sions); auto& scale = scales[0], auto& qval = qvalsfO]; for (int32_t k = 0; k < dispDimensions; ++k) { const auto qp = params.liftingQP[k]; assert(qp >= 4 && qp <= 100); q = (qp - 4) / 6; / / integer division -> lookup table r = (qp - 4) - 6 * q; assert(q >= 0 && q <= 16); assert(r >= 0 && r <= 5); assert(params.bitDepthPosition >= 4 && params.bitDepthPosition <= 16); Petition 870250093109, dated 10 / 10 / 2025, pp. 507 / 541 71 / 88 scale[k] = (qp - 4) >- 0(r6table[r] « (16 - 7 - 2 - 2)) : 0; qval[k] = q; lodScale[k] = 1; / / » 1 (0.5) / / lodScale[k] = 1.0 / params.liftingLevelOfDetailInverseScale[k]; / / weights to be correctly assigned (also configuration files)} Int32_t lodScaleoffset; for (int32_t it = 1; it < lodCount; ++it) { for (int32_t k = 0; k < dispDimensions; ++k) { lodScaleoffset = (1 « lodScalefk])» 1; scales[it][k] = (scalesfit - 1 ][k] + lodScaleoffset) » lodScale[k]; qvals[it][k] = qvalsfit - 1 ] [k]; }} } auto& disp = frame, disp; for (int32_t it = 0, vcountO = 0; ít < lodCount; ++it) { const auto& scale = seal es [it]; const auto& qval = qvals[it]; const auto vcountl = infoLevelOfDetails[it].pointCount; for (int32_t v = vcountO; v < vcountl; ++v) { auto& d = disp[v], for (int32_t k = 0; k < dispDimensions; ++k) { int64 t rshift = params.bitDepthPosition + qval[k] + 5; d[k] = d[k] >= 0 ? ((d[k] * scale[k] + (l«rshift) / 3)» rshift) : -((-d[k] * scale[k] + (l«rshift) / 3) » rshift); / / params.liftingBias[k] 0,333 / / pesos de viés a serem sinalizados corretamente (também arquivos de configuração)} vcountO =vcountl; } return true; } Petição 870250093109, de 10 / 10 / 2025, pág. 508 / 541 72 / 88

[177] As funções de quantização inversa podem ser implementadas da seguinte forma: static int32_t inverseQuantizeDi splacements( VMCFrame& frame, const int32_t bitDepthPosition, const double (&liftingLevelOfDetailInverseScale)[3], const int32_t (&liftingQP)[3]) { printf(Inverse quantize displacements \n); fílush(stdout); const auto& infoLevelOfDetails = frame.subdivInfoLevelOfDetails; const auto lodCount = int32_t(infoLevelOfDetails.size()); assert(lodCount > 0); int64_t i scale [3], int64_t ilodScale[3]; int32_t q, r; int64_t r6table[6] = {2048, 2299, 2580, 2896, 3251, 3649}; for (int32_t k = 0, k < 3; ++k) { const auto qp = liftingQP[k]; / / qp range [4...100] assert(qp >= 4 && qp <= 100); q = [qp - 4) / 6; / / integer division -> lookup table r = (qp - 4) - 6 * q; assert(q >= 0 && q <= 16); assert(r >= 0 && r <= 5); assert(bitDepthPosition >= 4 && bitDepthPosition <= 16); iscalefk] = (qp - 4) >= 0 ? (r6table[r] « (bitDepthPosition + q - 2 - 2)) : 0; iLodScale[k] =!; / / «! / / liftingLevelOfDetailInverseScale[k]; / / weights to be correctly assigned (also configuration files) ) auto& disp = frame.disp; for (int32 t it = 0, vcountO = 0; it < lodCount; ++it) { const auto vcountl = infoLevelOfDetails[it].pointCount, for (Ínt32 tv = vcountO; v < vcountl; ++v) { Petition 870250093109, dated 10 / 10 / 2025, pages 509 / 541 73 / 88 auto& d = disp[v], for (int32_t k = 0, k < 3; ++k) { int64_t val = d[k] * i scale [kJ; d[k] = (val < 0 ? -((-val + (1 « 22)) » (16 + 7)): ((val + (1 « 22)) > (16 + 7))); vcountO = vcountl; for (int32_t k = 0; k < 3; ++k) {iscale[k] «= ilodScale[k];} return 0; } static int32_t i nverseQuanti zeDi sp 1 acements( VMCFrame& frame, const int32_t bitDepthPosition, const std::vector<std::array<int32_t, 3»& liftingQuantizationParametersPerLevelOfDetails) { const auto& infoLevelOfDetails = frame.subdivlnfoLevelOfDetails; const auto lodCount = int32_t(infoLevelOfDetails.size()); assert(lodCount > 0); assert(lodCount == static_cast<int32_t>( liftingQuantizationParametersPerLevelOfDetails.sizeO)), auto& disp = frame.disp, int32_t q, r, int64_t r6table[6] = {2048, 2299, 2580, 2896, 3251, 3649}; for (int32_t it = 0, vcountO = 0; it < lodCount, ++it) { int64_t iscale[3], for (int32_t k = 0; k < 3; ++k) { const auto qp = liftingQuantizationParametersPerLevelOfDetails[it][k], assert(qp >= 4 && qp <= 100), Petição 870250093109, de 10 / 10 / 2025, pág. 510 / 541 74 / 88 q — (qp - 4) / 6; / / divisão de número inteiro -> tabela de consulta r = (qp - 4) - 6 * q; assert(q >= 0 && q <= 16); assert(r >= 0 && r <= 5); assert(bitDepthPosition >= 4 && bitDepthPosition <= 16); iscalefk] = (qp - 4) >= 0 ? (r6table[r] « (bitDepthPosition + q - 2 - 2)) : 0; const auto vcountl = infoLevelOfDetails[it].pointCount; for (int32_t v = vcountO, v < vcountl, ++v) { auto& d = disp[v]; for (int32_t k = 0; k < 3; ++k) { int64_t vai = d[k] * i scale [k], d[k] = (vai < 0 ? -((-vai + (1 « 22))»(16 + 7)): ((vai + (1 « 22)) » (16 + 7))); vcountO = vcountl; } return 0; }

[178] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to implement an alternative quantization scale granularity. Given the current quantization scale (floating-point precision) formulas in WD2.0 per vector displacement dimension d: iscale[d] = qp[d] >= 0 ? pow(0.5, 16 - bitDepth + (4 - qp[d]) / 6):0.0 Formula (9) scale[d] = qp[d] >= 0 ? pow(2,0, 16 - bitDepth + (4 - qp[d]) / 6):0,0 Formula (10) with iscale the inverse scaling factor, scale the scaling factor Petition 870250093109, dated 10 / 10 / 2025, pp. 511 / 541 75 / 88 direct, bitDepth the position bit depth or the offset bit depth, qp[d] the quantization parameter applied to the offset dimension, pow(x,y) the function x to the power y (xAy). Note that the scale value doubles with each increase of qp by 6 units, which involves a division by 6 in the formulas. This disclosure proposes techniques to replace the value 6 with a power of 2 value, so that the division can be replaced by a right bit shift operation (>>), for example, values ​​2, 4, 8, pow(2, n), etc. The formulas can be rewritten as follows: iscale[d] = qp[d] >= 0 ? pow(0.5, 16 - bitDepth + (4 - qp[d]) / pow(2, n)):0.0 Formula (13) scale[d] = qp[d] >= 0 ? pow(2,0, 16 - bitDepth + (4 - qp[d]) / pow(2, n)):0.0 Formula (14)

[179] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to perform the geometry position quantization processes described in G-PCC Ed.1 (see, for example, sections 9.2.14.6, 9.3.4.2, etc.). US Patent Application No. 17 / 492,095, filed October 1, 2021, incorporated by reference in the present invention, also describes geometry position quantization processes. The QP interval would be different for different values ​​of n. The value of n can be signaled (or derived from the syntax element) in the bitstream.

[180] The V-DMC 200 encoder and the V-DMC 300 decoder can be configured to perform integer transformation.

[181] The inverse lift-off transform process is described above in relation to the inverse linear wavelet transform and proceeds briefly as follows: for(i = 0; i < subdivisionIterationCount; i++) { vcount0 = levelOfDetailAttributeCounts[i] Petition 870250093109, dated 10 / 10 / 2025, pp. 512 / 541 76 / 88 vcountl = levelOfDetailAttributeCounts[i + 1] for (v = vcount0; skipUpdate == 0 && v < vcount1; ++v) { a = edges[v][0] b = edges[v][1] for(d = 0; d < 3; d++) { disp = updateWeight * dispCoeffArray[v][d] / / Note: reverse update step signal[a][d] -= disp signal[b][d] -= disp}} for (v = vcount0; skipUpdate == 0 && v < vcount1; ++v) { a = edges[v][0] b = edges[v][1] for(d = 0; d < 3; d++) { dispCoeffArray[v][d] += predWeight * (signal[a][d] + signal[b][d]) / / Note: prediction step}} }

[182] Note that both the update and inverse prediction steps are currently implemented in floating-point arithmetic. Below is an example of an integer precision implementation if updateWeight equals 1 / 8 and predWeight equals 1 / 2: for(i = 0; i < subdivisionIterationCount; i++) { vcount0 = levelOfDetailAttributeCounts[i] Petition 870250093109, dated 10 / 10 / 2025, pp. 513 / 541 77 / 88 vcountl = levelOfDetailAttributeCounts[i + 1] for (v = vcount0; skipUpdate == 0 && v < vcount1; ++v) { a = edges[v][0] b = edges[v][1] for(d = 0; d < 3; d++) { val = dispCoeffArray[v][d] disp = (val < 0 ? -((-val + 4) >> 3):(val + 4) >> 3) / / Note: reverse update step signal[a][d] -= disp signal[b][d] -= disp} } for (v = vcount0; skipUpdate == 0 && v < vcount1; ++v) { a = edges[v][0] b = edges[v][1] for(d = 0; d < 3; d++) { val = (signal[a][d] + signal[b][d]) dispCoeffArray[v][d] += (val < 0 ? -((-val + 1) >> 1):((val + 1) >> 1)) / / Note: prediction step} }}

[183] ​​Similarly, on the encoder side, the forward raising process can be implemented with integer precision as follows: updateWeight equals 1 / 8 and predWeight equals 1 / 2: for(i = 0; i < subdivisionIterationCount; i++) { Petition 870250093109, dated 10 / 10 / 2025, pp. 514 / 541 78 / 88 vcountO = levelOfDetailAttributeCounts[i] vcountl = levelOfDetailAttributeCounts[i + 1] for (v = vcount0; skipUpdate == 0 && v < vcount1; ++v) { a = edges[v][0] b = edges[v][1] for(d = 0; d < 3; d++) { val = (signal[a][d] + signal[b][d]) dispCoeffArray[v][d] -= (val < 0 ? -((-val + 1) >> 1):((val + 1) >> 1)) / / Note: prediction step} } for (v = vcount0; skipUpdate == 0 && v < vcount1; ++v) { a = edges[v][0] b = edges[v][1] for(d = 0; d < 3; d++) { val = dispCoeffArray[v][d] disp = (val < 0 ? -((-val + 4) >> 3):(val + 4) >> 3) / / Note: update step signal[a][d] += disp signal[b][d] += disp}} }

[184] Alternative integer transforms can also be substituted. Here are some examples: Petition 870250093109, dated 10 / 10 / 2025, pp. 515 / 541 79 / 88 * (2,2) interpolation transform ; — >0 2.' · 1 ~ L -5.::.2 / : 2 -J And Ll-74( / ¾ j...j +í^)+ i / 2 j. * (4,2) trí(4,2) interpolation transform í4j ~ L9-H6(;Va..2i + "" 1 / 16(522---2 + 4 1 / 2-J ^3t + 4- 4.0 * 1721 Equation (8)

[185] Examples in the various aspects of this disclosure may be used individually or in any combination.

[186] Figure 9 is a flowchart illustrating an example process for decoding a compressed mesh data bitstream. Although described with respect to the V-DMC 300 decoder (Figures 1 and 2), it should be understood that other devices can be configured to perform a process similar to that in Figure 9.

[187] In the example in Figure 9, the V-DMC 300 decoder determines, based on the encoded mesh data, a base mesh (902). The V-DMC 300 decoder determines, based on the encoded mesh data, a set of coefficients, wherein the set of coefficients comprises integer values ​​(904). The V-DMC 300 decoder receives in the encoded mesh data a quantization parameter value (906). The quantization parameter value can, for example, have a minimum value of 4 and a maximum value of 100.

[188] The V-DMC 300 decoder determines an inverse scaling factor based on the quantization parameter value (908). The V-DMC 300 decoder performs an inverse scaling, based on the inverse scaling factor and using integer precision arithmetic, on the set of coefficients to determine a set of dequantized coefficients (910). To perform the inverse scaling using arithmetic of Petition 870250093109, dated 10 / 10 / 2025, pp. 516 / 541 With 80 / 88 integer precision, the V-DMC 300 decoder can, for example, determine the inverse scaling factor according to any of the equations above. In some examples, the V-DMC 300 decoder can additionally or alternatively use a lookup table as described above.

[189] The V-DMC 300 decoder determines a shift vector based on the set of dequantized coefficients (912). To determine the shift vector based on the set of dequantized coefficients, the V-DMC 300 decoder can be configured to apply an inverse transform using integer precision arithmetic to the set of dequantized coefficients.

[190] The V-DMC 300 decoder deforms the base mesh based on the displacement vector to determine a decoded mesh (914). The V-DMC 300 decoder can, for example, subdivide the base mesh to determine additional vertices and modify the locations of the additional vertices based on displacement vectors.

[191] The V-DMC 300 decoder outputs the decoded mesh (916). The V-DMC 300 decoder can, for example, output the decoded mesh for storage, transmission or display.

[192] The following numbered clauses illustrate one or more aspects of the techniques and devices described in this disclosure.

[193] Clause 1A: A method for processing mesh data, wherein the method comprises: any technique or combination of techniques described in this disclosure.

[194] Clause 2A: The method of either of clause 1A, which additionally comprises generating the mesh data.

[195] Clause 3A: A device for processing data of Petition 870250093109, dated 10 / 10 / 2025, pp. 517 / 541 81 / 88 mesh, where the device comprises: a memory configured to store mesh data; and one or more memory-coupled processors, implemented in a circuit array and configured to perform any technique or combination of techniques described in this disclosure.

[196] Clause 4A: Clause 3A of the device, where the device comprises a decoder.

[197] Clause 5A: The device of clause 3A, wherein the device comprises an encoder.

[198] Clause 6A: The device of any of clauses 3A to 4A, which additionally comprises a device for generating the mesh data.

[199] Clause 7A: The device of any of clauses 3A to 6A, which additionally comprises a display for presenting images based on data.

[200] Clause 8A: A computer-readable storage medium containing stored instructions that, when executed, cause one or more processors to perform any technique or combination of techniques described in this disclosure.

[201] Clause 1B: A device for decoding encoded loop data, wherein the device comprises: one or more memory units; one or more processing units implemented in a circuit assembly, coupled to the one or more memory units and configured to: determine, based on the encoded loop data, a base loop; determine, based on the encoded loop data, a set of coefficients; receive in the encoded loop data a quantization parameter value; determine an inverse scaling factor based on the quantization parameter value; perform inverse scaling, based on the inverse scaling factor and using precision arithmetic of Petition 870250093109, dated 10 / 10 / 2025, pp. 518 / 541 82 / 88 integer, in the set of coefficients to determine a set of dequantized coefficients; determine a displacement vector based on the set of dequantized coefficients; deform the basis mesh based on the displacement vector to determine a decoded mesh; and output the decoded mesh.

[202] Clause 2B: The device of clause 1B, wherein to determine the displacement vector based on the set of dequantized coefficients, one or more processing units are configured to apply an inverse transform using integer precision arithmetic to the set of dequantized coefficients.

[203] Clause 3B: The device of clause 1B or 2B, in which the quantization parameter value has a minimum value of 4 and a maximum value of 100.

[204] Clause 4B: The device of any of clauses 1B to 3B, in which to determine an inverse scaling factor based on the quantization parameter value, one or more processing units are configured to determine the inverse scaling factor according to the equation: iscale[d] = qp >= 0 ? pow(2, r / 6) * pow(2, bitDepth + q - 16):0 (Equation (9)), where iscale represents the inverse scaling factor, qp represents a quantization value, bitDepth represents a bit depth of the shift vector, q represents a quotient value after the division (qp-x) / y, where x and y are integer values, r represents a remainder value after the division (qp-x) / y pow(M,E) represents a function from M to the power E.

[205] Clause 5B: The device of clause 4B, where x equals 4 and y equals 6.

[206] Clause 6B: The device of any of clauses 1B to 3B, in which to determine the inverse scaling factor based on the quantization parameter value, one or more processing units are Petition 870250093109, dated 10 / 10 / 2025, pp. 519 / 541 83 / 88 configured to determine the inverse scaling factor according to the equation: iscale[d] = qp >= 0 ? irtable[r] * pow(2, bitDepth + q - 16):0 (Equation (6)), where iscale represents the inverse scaling factor, qp represents a quantization value, bitDepth represents a bit depth of the shift vector, q represents a quotient value after the division (qp-x) / y, where x and y are integer values, r represents a remainder value after the division (qp-x) / y, irtable[r] represents a value determined from a lookup table based on the remainder value, and pow(M,E) represents a function from M to the power E.

[207] Clause 7B: The device of clause 6B, where x equals 4 and y equals 6.

[208] Clause 8B: The device of clause 6B or 7B, where irtable[r] includes values ​​128 / 128, 144 / 128, 161 / 128, 181 / 128, 203 / 128 and 228 / 128.

[209] Clause 9B: The device of clause 6B or 7B, where irtable[r] includes values ​​2048 / 2048, 2299 / 2048, 2580 / 2048, 2896 / 2048, 3251 / 2048, 3649 / 2048.

[210] Clause 10B: The device of any of clauses 1B to 9B, which additionally comprises: a display configured to display the decoded mesh.

[211] Clause 11B: A method for decoding encoded mesh data, wherein the method comprises: determining, based on the encoded mesh data, a base mesh; determining, based on the encoded mesh data, a set of coefficients; receiving in the encoded mesh data a quantization parameter value; determining an inverse scaling factor based on the quantization parameter value; performing an inverse scaling, based on the inverse scaling factor and using integer precision arithmetic, on the set of coefficients for Petition 870250093109, dated 10 / 10 / 2025, pp. 520 / 541 84 / 88 determine a set of desquantized coefficients; determine a displacement vector based on the set of desquantized coefficients; deform the basis mesh based on the displacement vector to determine a decoded mesh; and output the decoded mesh.

[212] Clause 12B: The method of clause 11B, in which the determination of the displacement vector based on the set of dequantized coefficients comprises applying an inverse transform using integer precision arithmetic to the set of dequantized coefficients.

[213] Clause 13B: The method of clause 11B or 12B, in which the quantization parameter value has a minimum value of 4 and a maximum value of 100.

[214] Clause 14B: The method of any of clauses 11B to 13B, wherein the determination of the inverse scaling factor based on the quantization parameter value comprises determining the inverse scaling factor according to the equation: iscale[d] = qp >= 0 ? pow(2, r / 6) * pow(2, bitDepth + q - 16):0 (Equation (9)), where iscale represents the inverse scaling factor, qp represents a quantization value, bitDepth represents a bit depth of the shift vector, q represents a quotient value after the division (qp-x) / y, where x and y are integer values, r represents a remainder value after the division (qp-x) / y and pow(M,E) represents a function from M to the power E.

[215] Clause 15B: The method of clause 14B, where x equals 4 and y equals 6.

[216] Clause 16B: The method of any of clauses 11B to 13B, wherein the determination of the inverse scaling factor based on the quantization parameter value determines an inverse scaling factor according to the equation: iscale[d] = qp >= 0 ? irtable[r] * pow(2, bitDepth + q 16):0 (Equation (6)), where iscale represents the inverse scaling factor, qp Petition 870250093109, dated 10 / 10 / 2025, pages 521 / 541 85 / 88 represents a quantization value, bitDepth represents a bit depth of the shift vector, q represents a quotient value after the division (qp-x) / y, where x and y are integer values, r represents a remainder value after the division (qp-x) / y, irtable[r] represents a value determined from a lookup table based on the remainder value, and pow(M,E) represents a function from M to the power E.

[217] Clause 17B: The method of clause 16B, where x equals 4 and y equals 6.

[218] Clause 18B: The method of clause 16B or 17B, where irtable[r] includes values ​​128 / 128, 144 / 128, 161 / 128, 181 / 128, 203 / 128 and 228 / 128.

[219] Clause 19B: The method of clause 16B or 17B, wherein irtable[r] includes values ​​2048 / 2048, 2299 / 2048, 2580 / 2048, 2896 / 2048, 3251 / 2048, 3649 / 2048.

[220] Clause 20B: A computer-readable storage medium that stores instructions that, when executed by one or more processors, cause the one or more processors to: determine, based on encoded mesh data, a base mesh; determine, based on the encoded mesh data, a set of coefficients; receive in the encoded mesh data a quantization parameter value; determine an inverse scaling factor based on the quantization parameter value; perform an inverse scaling, based on the inverse scaling factor and using integer precision arithmetic, on the set of coefficients to determine a set of dequantized coefficients; determine a displacement vector based on the set of dequantized coefficients; deform the base mesh based on the displacement vector to determine a decoded mesh; and output the decoded mesh. Petition 870250093109, dated 10 / 10 / 2025, pp. 522 / 541 86 / 88

[221] It should be recognized that, depending on the example, certain actions or events of any of the techniques described in the present invention may be performed in a different sequence, may be added, combined or completely omitted (for example, not all actions or events described are necessary for the practice of the techniques). Furthermore, in certain examples, the actions or events may be performed simultaneously, for example, through multi-threaded processing, interrupt processing or multiple processors, instead of sequentially.

[222] In one or more examples, the functions described may be implemented in hardware, software, firmware, or any combination thereof. If implemented in software, the functions may be stored or transmitted as one or more instructions or code in a computer-readable medium and executed by a hardware-based processing unit. Computer-readable media may include computer-readable storage media, which correspond to a tangible medium, such as data storage media, or communication media, including any medium that facilitates the transfer of a computer program from one place to another, for example, according to a communication protocol. In this way, computer-readable media may generally correspond to (1) tangible computer-readable storage media that are non-transient or (2) a communication medium, such as a signal or a carrier wave.Data storage media can be any available media that can be accessed by one or more computers or one or more processors to retrieve instructions, code, and / or data structures for implementing the techniques described in this disclosure. A computer program product may include a computer-readable medium. Petition 870250093109, dated 10 / 10 / 2025, pp. 523 / 541 87 / 88

[223] By way of example, and not limitation, such computer-readable storage media may comprise random access memory (RAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), CD-ROM or other optical disk storage, magnetic disk storage or other magnetic storage devices, flash memory or any other media that can be used to store the desired program code in the form of instructions or data structures and that can be accessed by a computer. In addition, any connection is properly termed a computer-readable medium.For example, if instructions are transmitted from a website, server, or other remote source using a coaxial cable, fiber optic cable, twisted pair, digital subscriber line (DSL), or wireless technologies such as infrared, radio, and microwave, then the coaxial cable, fiber optic cable, twisted pair, DSL, or wireless technologies such as infrared, radio, and microwave will be included in the definition of medium. It should be understood, however, that computer-readable storage media and data storage media do not include connections, carrier waves, signals, or other transient media, but instead refer to tangible, non-transient storage media.As used in the present invention, disks (disk and disc) include compact disc (CD), laser disc, optical disc, digital versatile disc (DVD), floppy disk, and Blu-ray disc, where disks typically reproduce data magnetically, while discs reproduce data optically by means of lasers. Combinations of the above items should also be included within the scope of computer-readable media. Petition 870250093109, dated 10 / 10 / 2025, pp. 524 / 541 88 / 88

[224] The instructions may be executed by one or more processors, such as one or more digital signal processors (DSPs), general-purpose microprocessors, application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), or other distinct or equivalent integrated logic circuit assemblies. Consequently, the terms processor and processing circuit assembly, as used in the present invention, may refer to any of the foregoing structures or any other structure suitable for implementing the techniques described in the present invention. Furthermore, in some respects, the functionality described in the present invention may be provided in dedicated hardware and / or software modules configured for encoding and decoding, or may be incorporated into a combined codec. Additionally, the techniques may be fully implemented in one or more logic circuits or elements.

[225] The techniques in this disclosure can be implemented in a wide variety of devices or appliances, including a wireless handset, an integrated circuit (IC), or a set of ICs (e.g., a chipset). Various components, modules, or units are described in this disclosure to emphasize functional aspects of devices configured to perform the disclosed techniques, but do not necessarily require implementation by different hardware units. Instead, as described above, multiple units can be combined into a codec hardware unit or provided by a collection of interoperable hardware units, including one or more processors, as described above, in conjunction with suitable software and / or firmware.

[226] Several examples have been described. These and other examples are within the scope of the following claims. Petition 870250093109, dated 10 / 10 / 2025, pages 525 / 541 < / meshtype> < / meshtype> < / offset> < / offset> < / offset> < / offset>

Claims

1 / 6 CLAIMS 1. Device for decoding encoded loop data, the device characterized by comprising: one or more memory units; one or more processing units implemented in a set of circuits, coupled to one or more memory units, and configured to: determine, based on the encoded loop data, a base loop; determine, based on the encoded loop data, a set of coefficients; receive in the encoded loop data a quantization parameter value; determine an inverse scaling factor based on the quantization parameter value; perform an inverse scaling, based on the inverse scaling factor and using integer precision arithmetic, on the set of coefficients to determine a set of dequantized coefficients; determine a shift vector based on the set of dequantized coefficients;Deform the base mesh based on the displacement vector to determine a decoded mesh; and output the decoded mesh.

2. Device according to claim 1, characterized in that, to determine the displacement vector based on the set of dequantized coefficients, one or more processing units are configured to apply an inverse transform using integer precision arithmetic to the set of dequantized coefficients.

3. Device according to claim 1, characterized in that the quantization parameter value has a minimum value of 4 and a maximum value of 100.

4. Device according to claim 1, characterized in that, to determine an inverse scaling factor based on the quantization parameter value, one or more processing units are configured to determine the inverse scaling factor according to the equation: iscale[d] = qp >= 0 ? pow(2, r / 6) * pow(2, bitDepth + q - 16):0 (Equation (9)) where iscale represents the inverse scaling factor, qp represents a quantization value, bitDepth represents a bit depth of the shift vector, q represents a quotient value after dividing (qp-x) / y, where x and y are integer values, r represents a remainder value after dividing (qp-x) / y, and pow(M,E) represents a function from M to the power E.

5. Device according to claim 4, characterized in that x equals 4 and y equals 6.

6. Device according to claim 1, characterized in that, to determine the inverse scaling factor based on the quantization parameter value, one or more processing units are configured to determine the inverse scaling factor according to the equation: iscale[d] = qp >= 0 ? irtable[r] * pow(2, bitDepth + q - 16):0 (Equation (6)) wherein Petition 870250093109, of 10 / 10 / 2025, p. 527 / 541 3 / 6 iscale represents the inverse scaling factor, qp represents a quantization value, bitDepth represents a bit depth of the shift vector, q represents a quotient value after dividing (qp-x) / y, where x and y are integer values, r represents a remainder value after dividing (qp-x) / y, irtable[r] represents a value determined from a lookup table based on the remainder value, and pow(M,E) represents a function from M to the power E.

7. Device according to claim 6, characterized in that x equals 4 and y equals 6.

8. Device according to claim 6, characterized in that irtable[r] includes values ​​128 / 128, 144 / 128, 161 / 128, 181 / 128, 203 / 128 and 228 / 128.

9. Device according to claim 6, characterized in that irtable[r] includes values ​​2048 / 2048, 2299 / 2048, 2580 / 2048, 2896 / 2048, 3251 / 2048, 3649 / 2048.

10. Device according to claim 1, characterized by further comprising: a display configured to show the decoded mesh.

11. Method for decoding encoded mesh data, the method characterized by comprising: determining, based on the encoded mesh data, a base mesh; determining, based on the encoded mesh data, a set of coefficients; receiving in the encoded mesh data a quantization parameter value; determining an inverse scaling factor based on the quantization parameter value; performing an inverse scaling, based on the inverse scaling factor and using integer precision arithmetic, on the set of coefficients to determine a set of dequantized coefficients; determining a displacement vector based on the set of dequantized coefficients; deforming the base mesh based on the displacement vector to determine a decoded mesh; and outputting the decoded mesh.

12. Method, according to claim 11, characterized in that the determination of the displacement vector based on the set of dequantized coefficients comprises applying an inverse transform using integer precision arithmetic to the set of dequantized coefficients.

13. Method according to claim 11, characterized in that the quantization parameter value has a minimum value of 4 and a maximum value of 100.

14. Method according to claim 11, characterized in that the determination of the inverse scaling factor based on the quantization parameter value comprises determining the inverse scaling factor according to the equation: iscale[d] = qp >= 0 ? pow(2, r / 6) * pow(2, bitDepth + q - 16):0 (Equation (9)) where iscale represents the inverse scaling factor, qp represents a quantization value, Petition 870250093109, dated 10 / 10 / 2025, p. 529 / 541 5 / 6 bitDepth represents a bit depth of the shift vector, q represents a quotient value after dividing (qp-x) / y, where x and y are integer values, r represents a remainder value after dividing (qp-x) / y, and pow(M,E) represents a function from M to the power E.

15. Method according to claim 14, characterized in that x equals 4 and y equals 6.

16. Method according to claim 11, characterized by comprising: determining the inverse scaling factor based on the quantization parameter value; determining an inverse scaling factor according to the equation: iscale[d] = qp >= 0 ? irtable[r] * pow(2, bitDepth + q - 16):0 (Equation (6)) wherein iscale represents the inverse scaling factor, qp represents a quantization value, bitDepth represents a bit depth of the shift vector, q represents a quotient value after the division of (qp-x) / y, wherein x and y are integer values, r represents a remainder value after the division of (qp-x) / y, irtable[r] represents a value determined from a lookup table based on the remainder value, and pow(M,E) represents a function from M to the power E.

17. Method according to claim 16, characterized in that x equals 4 and y equals 6. Petition 870250093109, dated 10 / 10 / 2025, pp. 530 / 541 6 / 6 18. Method according to claim 16, characterized in that irtable[r] includes values ​​128 / 128, 144 / 128, 161 / 128, 181 / 128, 203 / 128 and 228 / 128.

19. Method according to claim 16, characterized in that irtable[r] includes values ​​2048 / 2048, 2299 / 2048, 2580 / 2048, 2896 / 2048, 3251 / 2048, 3649 / 2048.

20. A computer-readable storage medium characterized by storing instructions that, when executed by one or more processors, cause the one or more processors to: determine, based on encoded mesh data, a base mesh; determine, based on the encoded mesh data, a set of coefficients; receive a quantization parameter value from the encoded mesh data; determine an inverse scaling factor based on the quantization parameter value; perform inverse scaling, based on the inverse scaling factor and using integer-precision arithmetic, on the set of coefficients to determine a set of dequantized coefficients; determine a displacement vector based on the set of dequantized coefficients; deform the base mesh based on the displacement vector to determine a decoded mesh; and output the decoded mesh. Petition 870250093109, dated 10 / 10 / 2025, pp. 531 / 541

Images