Edge breaker with face identifier compression

Abstract

And encoding and decoding the surface parameters in the grid. A grid coding method includes: for a current face having associated current face parameters in a grid, identifying edge-adjoining faces, each edge-adjoining face sharing one edge and two vertices with the current face; for at least a first edge-adjoining surface, identifying a first encoded surface associated with the first edge-adjoining surface, where the first encoded surface is identified from among a first set of surfaces including surfaces sharing at least one vertex with both the current surface and the first edge-adjoining surface, excluding any edge-adjoining surface that is not the first edge-adjoining surface; and encoding a first indication of whether a first adjoining surface parameter associated with the first encoding surface is equal to the current surface parameter. In some embodiments, the most recently encoded face is excluded from the first set.

Description

[0001] Cross-referencing This application claims priority to European Patent Application No. 23306292.6, filed on July 26, 2023, entitled “edgebreaker with face identifier compression”, which is incorporated herein by reference in its entirety. Background Technology

[0002] This disclosure relates to systems and methods for encoding and decoding networks based on edge-breaker techniques. An edge-breaker is a technique capable of efficiently encoding the connectivity of triangular meshes. In its simplest implementation, a mesh encoded using an edge-breaker is represented by an ordered sequence of symbols C, L, E, R, and S, called a "CLERS" sequence. Generally, starting with an initial triangle, these symbols describe different ways of attaching new triangles, thus providing information about whether or how different edges of the new triangles connect to one or more existing triangles. Edge-breaker techniques are described in more detail, for example, in the following sources: • J. Rossignac, “3D Compression Made Simple: Edge Breakers with ZipandWrap on Corner Tables” Proceedings of the International Conference on Shape Modeling and Applications Genoa, Italy, 2001. Describes decoding using a gridded corner table (CT) representation in the forward direction, which results in a very compact algorithm.

[0003] • H. Lopes, G. Tavares, J. Rossignac, A. Szymczak and A. Safonova, “Edge Destroyers: Simple Compression of Handled Surfaces,” At the ACM Solid Modeling and Applications Conference Saarbrücken, 2002.

[0004] • J. Rossignac, “Edge Breakers: Connectivity Compression of Triangular Meshes,” Georgia Tech GVU Center, 1999. Describes decoding in the forward direction using half-edge representations.

[0005] • J. Rossigniac, “A Course on Triangular Mesh and Angle Tables”, 2006.

[0006] • M. Isenburg and J. Snoeyink, “Spirale Reversi: Reversal Decoding of Edge-Breaker Encoding” Computational geometry Volume 20, pp. 39-52, 2001. Describes the “spiral inversion” technique, which uses half-side representation but performs decoding in an inverted manner, resulting in faster decoding at O(n).

[0007] Following the call for proposals for MPEG V-Mesh (now renamed V-DMC), Apple's proposed solution was selected as the basis for the MPEG V-Mesh Test Model (TM). K. Mammou, J. Kim, A. Tourapis, and D. Podborski described the proposal in “m59281 - [V-CG] Apple's Dynamic Mesh Coding CfP Response,” Apple Inc., 2022. In this publication… Figure 1 and Figure 2 A summary diagram from the proposal is provided in the document.

[0008] For certain frames, the test model encodes the base mesh using a static mesh encoder, then subdivides it to obtain an approximation of the original mesh. Currently, the V-Mesh test model encodes the base mesh using a Google Draco implementation of an edge-breaker-based mesh encoder. Specifically, this implementation uses methods described in M. Isenburg and J. Snoeyink's "Spiral Inversion: Inverse Decoding of Edge-Breaker Encoding". Computational geometry Volume 20, pp. 39-52, 2001, describes the “spiral inversion” version of the edge destroyer.

[0009] While edge-breaker coding provides an efficient way to encode the connectivity of the underlying mesh, it has certain limitations. For example, edge-breaker coding, by itself, only works for manifold surfaces without "holes" or "handles." Additional processing is required to transform such non-manifold surfaces into a format that can be encoded using edge-breaker techniques. Furthermore, edge-breaker coding, by itself, only encodes the connectivity of the mesh. The CLERS sequence itself does not encode additional properties of the mesh, such as vertex positions and any other vertex attributes (such as color, normal direction, UV coordinates, etc.). Summary of the Invention

[0010] A mesh encoding method according to some embodiments includes: identifying at least one edge-adjacent face for a current face in a mesh having associated current face parameters, each edge-adjacent face sharing one edge and two vertices with the current face; identifying a first coded face associated with at least a first edge-adjacent face among the edge-adjacent faces, wherein the first coded face is identified from a first face set, the first face set including a plurality of faces sharing at least one vertex with both the current face and the first edge-adjacent face, excluding any edge-adjacent face that is not the first edge-adjacent face; and encoding a first indication of whether the first adjacent face parameter associated with the first coded face is equal to the current face parameter.

[0011] In some embodiments, the first indication is an indication that a first adjacent face parameter associated with the first coded face is not equal to the current face parameter. The method further includes: for a second edge-adjacent face in the edge-adjacent faces, identifying a second coded face associated with the second edge-adjacent face, wherein the second coded face is identified from a second face set, the second face set including a plurality of faces that share at least one vertex with both the current face and the first edge-adjacent face, excluding any edge-adjacent face that is not the second edge-adjacent face; and encoding a second indication of whether the second adjacent face parameter associated with the second coded face is equal to the current face parameter.

[0012] In some embodiments, the second indication is an indication that a second adjacent face parameter associated with the second coded face is not equal to the current face parameter. The method further includes: for a third edge adjacent face in the edge adjacent faces, identifying a third coded face associated with the second edge adjacent face, wherein the third coded face is identified from a third face set, the third face set including a plurality of faces that share at least one vertex with both the current face and the third edge adjacent face, excluding any edge adjacent face that is not the third edge adjacent face; and encoding a third indication of whether the adjacent face parameter associated with the third coded face is equal to the current face parameter.

[0013] In some embodiments, the third indication is an indication that a third adjacent surface parameter associated with the third coded surface is not equal to the current surface parameter, and the method further includes encoding the value of the current surface parameter.

[0014] Some embodiments further include identifying the most recently encoded face in the mesh; and encoding a fourth indication of whether a fourth parameter associated with the most recently encoded face is equal to the current face parameter.

[0015] In some embodiments, the first instruction is executed only in response to determining that the fourth parameter is not equal to the current face parameter.

[0016] In some embodiments, identifying a first coded face associated with the first edge adjacent face includes: traversing faces in the first set according to a predetermined order; and selecting the earliest coded face encountered according to the predetermined order as the first coded face.

[0017] In some embodiments, traversing faces in the first set according to a predetermined order includes: traversing the first edge-adjacent faces; in response to determining that the first edge-adjacent face is not encoded, traversing at least one face that shares a first vertex with both the current face and the first edge-adjacent face; and in response to determining that there are no encoded faces in the first set that have not yet been traversed, traversing at least one face that shares a second vertex with both the current face and the first edge-adjacent face. A similar search order can be used for other sets.

[0018] In some embodiments, the current face parameter is a face identifier.

[0019] In some embodiments, one or more of the first face set, the second face set, and the third face set exclude the most recently encoded face.

[0020] In some embodiments, identifying the first coded face associated with the first edge's adjacent face includes: traversing faces in the first set according to a predetermined order; and selecting the earliest encountered coded face in the predetermined order as the first coded face, rather than selecting the most recently coded face. Similar search techniques can be used for the second set and the third set.

[0021] In some embodiments, the first indication is encoded only in response to determining that the first encoded surface is not the most recently encoded surface. Similar conditions may be applied to the encoding of the second and third indications.

[0022] A mesh encoding method according to some embodiments includes encoding parameters of corresponding faces in a mesh using a set of vectors, the set of vectors including: a first vector (faceIdEqualToPrevious), which includes entries for each of a plurality of faces in the mesh, each entry in the first vector indicating whether the parameter of the corresponding face is equal to the parameter of the corresponding most recently encoded face; a second vector (faceIdIsRight), which includes entries for each face in the mesh, each face (1) not indicated by the first vector to have a parameter equal to the parameter of the corresponding most recently encoded face, and (2) having a valid first encoded face in a first set of faces associated with the corresponding face, each entry in the second vector indicating whether the parameter of the corresponding face is equal to the parameter of the corresponding first encoded face; and a third vector (faceIdIsLeft), which includes entries for each face in the mesh, each face (1) not indicated by the second vector to have a parameter equal to the parameter of the corresponding most recently encoded face. The third vector includes an entry for each face in the grid, which has a parameter equal to the parameter of the corresponding first coded face, and (2) has a valid second coded face in the set of second faces associated with the corresponding face, each entry in the third vector indicating whether the parameter of the corresponding face is equal to the parameter of the corresponding second coded face; a fourth vector (faceIdIsForward) including an entry for each face in the grid, which (1) is not indicated by the third vector to have a parameter equal to the parameter of the corresponding second coded face, and (2) has a valid third coded face in the set of third faces associated with the corresponding face, each entry in the fourth vector indicating whether the parameter of the corresponding face is equal to the parameter of the corresponding third coded face; and a fifth vector (notPredictedFaceId) including an entry for each face in the grid that is not indicated by the fourth vector to have a parameter equal to the parameter of the corresponding third coded face, each entry in the fourth vector identifying the parameter of the corresponding face.

[0023] In some such embodiments, in response to determining that the coded face is the same as the most recently coded face, it is determined that the coded face in the first face set, the second face set, or the third face set is not a valid first coded face.

[0024] The example embodiments further include the following: a corresponding decoding technique; means including one or more processors configured to perform the methods described herein; means including at least one processor and a computer-readable medium storing instructions for performing the methods described herein; a computer-readable medium storing a grid encoded according to the methods described herein; and a signal conveying the grid encoded according to the methods described herein. Attached Figure Description

[0025] Figure 1This is a functional block diagram of an example grid coding system.

[0026] Figure 2 This is a functional block diagram of an example grid decoding system.

[0027] Figure 3 An example of an edge-breaker mesh codec according to some embodiments is illustrated.

[0028] Figure 4 This is a flowchart of the encoding process according to some embodiments.

[0029] Figure 5 This is a flowchart of the decoding process according to some embodiments.

[0030] Figure 6 The illustration shows an example of a portion of a grid, illustrating the information that can be stored in a corner table data structure.

[0031] Figure 7 The illustration shows an example of an extended angle table that supports UV coordinate attributes and normal vector attributes.

[0032] Figure 8 The diagram illustrates the extended corner table data structure used in the memory for the algorithm.

[0033] Figure 9 The example code entry point program is illustrated.

[0034] Figure 10 The diagram illustrates a sample program, preProcess, used to perform input model transformation, cleaning, filling, and quantization.

[0035] Figure 11 The diagram illustrates the program encoding, which includes edge destroyer topological encoding and attribute prediction.

[0036] Figure 12 The example program startCompression is illustrated.

[0037] Figure 13 illustrates the program compressRec.

[0038] Figure 14 The diagram illustrates the checkHandle procedure.

[0039] Figure 15 The example decoding entry point program is illustrated.

[0040] Figure 16 illustrates the program initDecompression, which allocates memory to store the decompression output and initializes other tag tables.

[0041] Figure 17 illustrates the example program startDecompression.

[0042] Figure 18 The diagram illustrates the statement `connectivityCompression`.

[0043] Figure 19 illustrates the example program decompressConnectivity.

[0044] Figure 20 An example of a CheckHandle procedure that supports shifting is illustrated.

[0045] Figure 21 The diagram illustrates the statement `attributesDecompression`.

[0046] Figure 22 illustrates an example of the program DecompressVertices.

[0047] Figure 23-26 The diagram illustrates an example of the program decompressUvWithSeparateIndex, which includes statement A ( Figure 24 Statement B Figure 25 ) and statement C ( Figure 26 ).

[0048] Figure 27 The illustration shows an example of the postProcess program, which removes pseudopoints while converting the reconstructed CT mesh into a set of indexed faces, and optionally recreates the nonmanifold if lossless encoding is used.

[0049] Figure 28 The diagram shows the preProcess and postProcess programs side by side.

[0050] Figure 29A and 29B The diagram illustrates a mesh with non-manifold vertices. Figure 29C The illustration shows an example technique for fixing a problem by splitting vertices.

[0051] Figure 30 The illustration shows how to fix two of the three surfaces generated by replicating non-manifold vertices by re-stitching them together.

[0052] Figures 31A-31D The illustration depicts filtering on a non-manifold surface according to some embodiments. One example technique could be referred to as cutting and re-stitching.

[0053] Figure 32 The illustration shows an example vertex copying phase.

[0054] Figure 33The illustration shows an example preprocessing operation that uses a table of matching opposites for re-stitching.

[0055] Figures 34A-34B Examples of the programs deduplicateVertices and processDuplicate are illustrated.

[0056] Figure 35 The illustration shows an example of a process for regenerating a non-manifold surface by removing duplicate vertices.

[0057] Figure 36 The illustration shows the process in an example embodiment, where holes in the mesh surface are filled with pseudo vertices and pseudo triangles.

[0058] Figure 37 The illustration shows an example of a C++ program that fills all the holes in a grid described as a corner table (O, V, OT, OTC).

[0059] Figures 38A-38C The illustration shows an example of a C++ program that fills a single hole in a grid described as a corner table (O, V, OT, OTC).

[0060] Figures 39A-39B The illustration shows how a program using a master index table predicts attributes.

[0061] Figure 40 An example of the predicate isCornerVertexDummy is illustrated.

[0062] Figure 41 The diagram illustrates the decoding peer program decodeAttributes.

[0063] Figure 42 illustrates an example of the program posEncodeWithPrediction.

[0064] Figure 43A The illustration shows a method for angle according to some embodiments. c Strategies for multi-parallelogram prediction and pseudo-point filtering at location.

[0065] Figure 43B The illustration shows an angle according to some embodiments. c The strategy of minimum stretching prediction and pseudopoint filtering for UV coordinates.

[0066] Figures 44A-44B The illustration shows an example of the program posDecodeWithPrediction.

[0067] Figures 45A-45BThe illustration shows an example of the program uvEncodeWithPrediction.

[0068] Figures 46A-46B The diagram illustrates the statement predictUV. dvec2 and dvec3 are examples of double-precision vectors.

[0069] Figure 47A The illustration shows how to handle UV seams using only the master index table.

[0070] Figure 47B The diagram illustrates the use of a separate index table and for angles The selection strategy for handling UV, the angle Used to utilize angles c A separate index is used to predict UV coordinates.

[0071] Figures 48A-48B The illustration shows an example of the program encodeSeparateIndexAttributes.

[0072] Figures 49A-49B The illustration shows an example of the program decodeSeparateIndexAttributes.

[0073] Figure 50 The illustration shows an example of the program's save function.

[0074] Figure 51 The illustration shows an example of pseudocode controlling the Dirac encoder used for the CLERS table.

[0075] Figure 52 Illustrations of the reproduction portion of the encoding principle for motion vectors in some embodiments are provided.

[0076] Figure 53 The illustration shows an example offset / shift used for ExpGolomb encoding.

[0077] Figure 54 The illustration shows an example of code using an arithmetic encoding context for some embodiments.

[0078] Figure 55 The compression performance of the encoding method described in this article is illustrated.

[0079] Figure 56 It is a block diagram of an example system that implements various aspects and embodiments.

[0080] Figure 57 The illustration shows an example implementation of one embodiment of pseudo-index removal.

[0081] Figure 58An example implementation of another, more efficient embodiment of pseudo-index removal is illustrated.

[0082] Figures 59A-59B The example program encodePerFaceAttributes is illustrated.

[0083] Figure 60 The illustration shows an example of DiracAC entropy coding used to encode the material ID for each face.

[0084] Figures 61A-61C The diagram illustrates an example of the search order for corner[0] = c (this operation is repeated for corner[1] = cn, and then for corner[2] = cp). Figure 61A The diagram illustrates the face where Id will be encoded and the adjacent triangles L, R, and F. (The three adjacent triangles always exist because pseudopoints are used to fill holes). Figure 61B The diagram illustrates the search in the neighborhood loop along the first direction on R, R1, R2, etc. Figure 61C The diagram illustrates the subsequent search in another direction.

[0085] Figure 62 The illustration shows an example mesh during the encoding of the face identifier for the current face C.

[0086] Figure 63 This is a flowchart illustrating a face identifier encoding method according to some embodiments.

[0087] Figure 64 The illustration shows another example mesh during the encoding of the face identifier for the current face C.

[0088] Figures 65A-65B The illustration shows example code for one embodiment of the face identifier encoding method.

[0089] Figures 66A-66B The illustration shows sample code for one embodiment of the face identifier decoding method.

[0090] Figures 67A-67B The diagram shows... Figures 65A-65B The encoding performance of the embodiments. Detailed Implementation

[0091] Overview of the example implementation.

[0092] Edge breakers (EB) are a technique for encoding and decoding (collectively referred to as “encoding”) the topology (connectivity and handles) of the grid that is the core of the algorithm, and propose using a predictor of vertex positions to generate some entropy-encoded effective data.

[0093] Some embodiments of this disclosure provide a complete end-to-end extended version of EB. Some embodiments include both low-level and higher-level syntaxes for bitstreams.

[0094] The example implementation provides support for topological encoding (connectivity and handles) and for geometry with incremental encoding.

[0095] Some embodiments provide mesh cleaning (preprocessing on CT) for non-manifold removal.

[0096] Some implementations provide support for holes and boundaries through "virtual" pseudopoints.

[0097] Some implementations include a lossless mode that reconstructs a mesh with poor "connectivity" during decoding, if needed.

[0098] Some implementations provide support for multiple connected components (CCs).

[0099] Some implementations include support for texture coordinate encoding using a unique index table or a separate index table.

[0100] Some embodiments include multi-parallelogram and stretch prediction. Some such embodiments further provide support for pseudopoints and separate index tables when needed.

[0101] Some embodiments include Dirac and / or RANS arithmetic encoders (AC). Some such embodiments use specific binaryization schemes and arithmetic encoding contexts as described herein for use with Dirac encoding.

[0102] In addition to input grid quantization, some embodiments also include support for pre-quantized input grids.

[0103] Some implementations include support for per-face identifiers or colors.

[0104] Some implementations provide optimizations for predicting and encoding attributes for each facet.

[0105] Figure 3 The illustration shows an example of an edge-breaker mesh codec according to some embodiments. The top row is the encoding row, and the bottom row is the decoding row. Figure 3The illustrated example embodiments include some or all of the following. During encoding, preprocessing 302 can be used to remove potential connectivity problems (non-manifold edges and vertices) that may exist on the input mesh. This cleanup is performed because the edge-breaking algorithm itself does not work on meshes with such connectivity problems. In some embodiments, removing non-manifold edges and vertices involves duplicating multiple points. Some embodiments track those duplicate vertices to merge them during decoding. This allows for a reduction in the number of points in the decoded mesh, but requires sending some additional information in the bitstream. In some embodiments, this preprocessing 302 further includes adding some pseudo-points to fill potential holes on the surface, since the edge-breaking algorithm cannot handle holes alone. Example embodiment operations are used to fill holes before encoding and reconstruct holes after decoding. Example embodiments use “virtual” pseudo-points and generate and encode pseudo-triangles attached to these pseudo-points, but the 3D positions of those points are not encoded or decoded. In some embodiments, vertex attributes are quantized if needed. Those attributes can be provided to the already quantized encoder.

[0106] The example implementation uses a modified version of the edge-breaking algorithm at 304 to encode mesh connectivity, generating a CLERS table (a table consisting of symbols 'C', 'L', 'E', 'R', and 'S'). This stage also generates some tables in memory for the attribute prediction stage. Then at 306, vertex attributes are predicted, starting with position attributes. Other attributes are then predicted, ultimately depending on the position predictions, which is the case for texture UV coordinates. Configuration and metadata are also provided in the bitstream; the CLERS table, some other connectivity data, and all attribute prediction residuals are entropy-encoded and added to the bitstream at 310.

[0107] In the example decoding method, at 312, entropy decoding is performed on all entropy-encoded sub-bitstreams. At 314, we reconstruct mesh connectivity using the CLERS table and an edge-breaking algorithm. We also add some additional information to manage handles describing the topology. At 316, we predict all other per-vertex positions using mesh connectivity and a minimum set of vertex positions represented in 3D coordinates. We then apply attribute residuals to correct the predictions and obtain the reconstructed vertex positions. Other attributes are also decoded at 316, which potentially depend on the decoded position in terms of UV coordinates. The connectivity of attributes using a separate index table is reconstructed using entropy-encoded per-edge binary seam information.

[0108] In the post-processing stage at 320, pseudo-triangles are removed. Optionally, if the encoder is configured to perform lossless encoding, the non-manifold problem is recreated. Optionally, if the model is quantized by the encoder, vertex attributes are dequantized.

[0109] Figure 4 This is a flowchart of the encoding process according to some embodiments.

[0110] Figure 5 This is a flowchart of the decoding process according to some embodiments.

[0111] An overview of the angle table.

[0112] In J. Rossignac, “3D Compression Made Simple: An Edge Destroyer with ZipandWrap on a Corner Table” In shape Proceedings of the International Conference on Modeling and Applications In Genoa, Italy, 2001, a corner table data structure for representing grids was described; and it was further described in J. Rossigniac, “On Triangular Grids and Corner Tables”, 2006.

[0113] Figure 6 The diagram illustrates a portion of a triangular mesh, showing the information that can be stored in a corner table (also known as an OV table). For each corner index c in the corner table, the notation cv=3 identifies the index of the vertex containing that corner. The index ct=0 is the index of the triangle containing corner c. Within this triangle, the index cn=0 identifies the next corner (counter-clockwise), and cp=1 identifies the previous corner. The index co identifies the corner opposite corner c. For example, in... Figure 6 In this context, angle co=5 is opposite to angle c=2 (and vice versa). The index cl identifies the angle to the left of angle c, while the index cr identifies the angle to the right of angle c. For example... Figure 6 The connectivity shown can be recorded in a corner table, which has entries including the following: Angular index Vertex Index Diagonal index 0 1 7 1 2 8 2 3 5 3 2 9 4 1 6 5 4 2

[0114] The "corner index" column does not need to be stored in the table, as it corresponds to the position of each row in the table. The triangle index for each corner can be calculated as follows: .

[0115] Therefore, angles 0, 1, and 2 are all in the triangle with index 0; angles 3, 4, and 5 are all in the triangle with index 1; and so on. The additional relationships between entries in the angle table can be represented as follows:

[0116] In some embodiments, an additional table may be used to store the position coordinates of each vertex.

[0117] Figure 7The illustration shows an example of an extended corner table that supports UV coordinate and normal vector attributes, each indexed using separate tables TC / OTC and N / ON. Texture coordinates and normal vectors are stored in two additional separate tables.

[0118] like Figure 7 The illustrated example embodiment extends the corner table data structure to support additional attributes with or without secondary attribute indexes. Where the mesh does not have a separate index to dereference the UV coordinate attribute, the example embodiment includes a table of UV coordinates alongside the position table. The position is then dereferenced using V to the UV coordinate table. Alternatively, some embodiments also add two tables, TC and OTC, to encode (for dereferencing) the connectivity of the UV coordinates. TC is used to store the UV coordinate indexes, and OTC is used to store the diagonals for UV connectivity. The same principle can be applied to adding support for per-vertex normals (N / ON / normal_vectors) or per-vertex colors (C / OC / colors).

[0119] Figure 8 The diagram illustrates the extended corner table data structure used in the memory for the algorithm. For greater flexibility, a separate table is used for each row of the table depicted in Figure 17.

[0120] Figure 8 This summarizes the data structures we use to store all the information in our extended corner table. This approach can be extended to any per-vertex attribute type, with or without a dedicated index table modeled using this pair (index table / relative table). In this implementation, each face ID is included in the table.

[0121] An overview of the coding program.

[0122] In this section, we will present some advanced procedures to better understand the structure and flow of the example coding process.

[0123] Figure 9 The example encoding entry point procedure is described. It consists of three steps, which respectively perform preprocessing of the input grid, its edge destroyer, encoding, and finally entropy encoding and storage into the bitstream.

[0124] Figure 10 The diagram illustrates a sample program, preProcess, used to perform input model transformation, cleanup, padding, and quantization. The features of this program will be provided in further detail below. It is introduced here for a comprehensive understanding before discussing edge-breaker coding below, which will also be described in further detail below. Figure 25 The save procedure described in the text.

[0125] Figure 11 The diagram illustrates the program encoding, including edge-breaker topological encoding and attribute prediction. Features described in particular detail here are shown in bold. The program first initializes some data structures, primarily allocating tables for labeling attributes or triangles and a table G_est for storing (predicted) estimates of positional attributes. Then, it runs the edge-breaker algorithm on each connected component (CC) of the mesh. For this, we add a while loop to the program and manage some starting indices for the handles we update for each new component. After encoding a CC, we run the program findRestartCorner to check if there is an unlabeled corner (i.e., not yet encoded) in the MC table, which we can use as the entry corner for encoding a new CC.

[0126] Some example implementations support meshes with multiple connected components. In one example implementation, a method includes encoding a first connected component of the mesh using edge-breaking encoding; identifying unencoded corners in the mesh after encoding the first connected component; and using the identified unencoded corners as entry corners to encode a second connected component of the mesh.

[0127] Figure 12 The example program `startCompression` is illustrated. Features described in particular detail here are shown in bold. This program is the starting point for the actual edge-destroyer algorithm that encodes the CCs. It encodes the first triangle and then begins recursive encoding of the CCs. This method involves recording the processed corners into a table called `processedCorners`. This table is later used to process attributes with separate index tables. We also added a specific program `encodeSeparateIndexAttributes` at the end of the process to encode / predict attributes with separate index tables. Finally, this program uses the `processedCorners` table to perform its processing.

[0128] The `encodeAttributes`, `encodeSeparateIndexAttributes`, and `encodePerFaceAttributes` procedures are described in further detail below. They essentially perform attribute predictions and store the results in tables that will later be entropy-encoded. Note that for a given angle, the `encodeAttributes` procedure uses the master index table to compute the prediction for the attribute.

[0129] Figure 13 illustrates the program compressRec. The table oClers is the output table of the CLERS symbols. Features described in particular here are shown in bold. This program is the core edge destroyer algorithm used to encode CCs. Processed corners are added to a table called processedCorners.

[0130] Figure 14 The diagram illustrates the checkHandle procedure.

[0131] Given the preceding description of how to construct the CLERS and Handles tables during the encoding phase, the following description describes an example implementation for reconstructing the grid topology from those tables to recreate the corner tables during decoding.

[0132] Overview of the decoding program.

[0133] Figure 15 The example decoding entry point procedure is illustrated. Features described in particular here are highlighted in bold. This procedure comprises several steps that respectively perform syntax parsing and arithmetic decoding of the input bitstream, edge-decompression using a corner table, and finally some post-processing on the corner table to produce the final mesh in the indexed face set data structure. In this section, we will only design the edge-decompression procedure (initDecompression and startDecompression) and the subroutines related to topology decoding. Parsing and entropy decoding will be described in further detail below.

[0134] Figure 16 illustrates the program `initDecompression`, which allocates memory to store the decompression output and initializes other tag tables. Features described in particular here are shown in bold. In the `initDecompression` program, "start" is a point for which no prediction exists, so its attributes are stored in a separate table containing global values ​​(`sVertices`, `sUVCoords`). Correspondingly, predicted attributes are stored in the other input tables `iVertices` and `iUVCoords`. Those tables will be described further below.

[0135] This section describes example tables (V, O, TC, OTC, D, M, U, MTC, and duplicatedIndexRemapping) used for topology decoding. The values ​​used to initialize O, TC, OTC, and D are recorded because those conditions are used to allow for the correct execution of the subsequent algorithm. Example embodiments include tables for handling texture coordinate attributes (in some embodiments, these are expanded in the same way for normals and per-vertex colors), attributes with separate index tables (see the hasSeparateUvIndex statement), and a final deduplication remapping table. We also add handling for pseudopoints.

[0136] Figure 17 illustrates the example program startDecompression. Features described in particular here are shown in bold. The program startDecompression, which begins decoding, is called after the initDecompression initialization phase.

[0137] The example embodiment provides processing of the vertex coordinates (CCs) using offsets. Then, for each CC, after the connectivityDecompression and attributesDecompression stages, the vertex index and UV coordinate index are shifted back to make them valid in the global index space. In some embodiments, this process can also be extended to any other attribute type. The example embodiment further includes deduplication post-processing, which will be described in further detail below.

[0138] Decode connectivity recursively.

[0139] Figure 18 The diagram illustrates the statement `connectivityCompression`. Features described in particular here are highlighted in bold. Figure 18 The `connectivityCompression` statement presented in Figure 17 can be inserted in the appropriate place within the pseudocode, thus accessing the set variables. This statement is executed for each `CC`. Within this logic block, the algorithm uses, for example, the work of H. Lopes, G. Tavares, J. Rossignac, A. Szymczak, and A. Safonova, in their paper, "Edge Destroyer: Simple Compression of Surfaces with Handles." At the ACM Solid Modeling and Applications Conference The techniques described in Saarbrücken, 2002, are used to initialize the diagonal of the CC handle. An example embodiment further adds the first corner (index 0) to the processedCorners table. We finally reconstruct the connectivity of the first triangle and begin the connectivity decompression recursion, as described with reference to Figure 19.

[0140] Figure 19 illustrates the example program decompressConnectivity. Features described in particular here are shown in bold. In the example embodiment, the decompressConnectivity program supports managing the shift of the CC, and the program includes a history of the processed corner. The program further utilizes, for example, the techniques described in H. Lopes, G. Tavares, J. Rossignac, A. Szymczak, and A. Safonova, “Edge Destroyer: Simple Compression of Handled Surfaces,” In ACM Solid Modeling and Applications Annual Conference The technique described in Saarbrücken, 2002, provides support for diagonal support handles.

[0141] Figure 20 The diagram illustrates an example of a CheckHandle procedure that supports shifting. The Zip procedure utilizes shifted tables O and G (code not shown here).

[0142] At the end of the connectivityDecompression statement (see Figure 17), connectivity is reconstructed and can be used together with the predicted attribute residuals previously decoded by entropy to reconstruct / estimate attributes. This next step is described in the next section.

[0143] Decode attributes recursively.

[0144] Figure 21 The diagram illustrates the `attributesCompression` statement. The `attributesCompression` statement can be inserted in the appropriate place within the pseudocode in Figure 17, thus accessing and setting variables. This statement is executed for each CC. Within this logic block, we first reconstruct the attributes of the first triangle using `decodeAttributes`, and then recursively reconstruct the attributes of the other triangles by calling `decompressVertices`. The first step only works for attributes that use the main index table.

[0145] In the second recursion, we optionally refactor the properties dereferenced via the secondary index table. These are implemented after the first recursion has terminated, before they are processed, because they depend on the output data of the first recursion. The presented code illustrates the second step for UV coordinates, namely, calling the `decompressUvWithSeparateIndex` procedure. In some embodiments, expansion of other types of per-vertex properties, such as normals or per-vertex colors, is also performed. The lower-level prediction scheme is adjusted accordingly.

[0146] Some embodiments further include a third recursion in which the properties of each face are reconstructed, as described in further detail below.

[0147] Figure 22 illustrates an example of the program DecompressVertices. This program uses a shifted table to process CCs. It recursively traverses a triangular tree and reconstructs attributes when necessary by calling the decodeAttributes program.

[0148] Figure 23 The illustration shows an example of the program `decompressUvWithSeparateIndex`. It differs from `decompressVertices` in that it uses secondary index tables `TC` and `OTC` to handle texture seams.

[0149] The program is broken down into three consecutive statements: Figure 24 Statement A is shown below; Figure 25 Statement B shown Figure 26 Statement C is shown. Each of these loops over processedCorners. In some embodiments, such as in the decompressVertices program, the order of the corners is implicitly determined, in which case the processedCorners table may not be necessary. However, for ease of coding and interpretation, the table is shown in this example.

[0150] refer to Figure 24 Using the iSeams table (which comes from the bitstream), the recursion of statement A first assigns a code in [0, -1, -2] to each corner code of the OTC table to identify whether they are on a seam or whether the UV coordinates are the same on each side of the edge. In the first case, different UV indices are used for each side of the edge. Note that the example embodiment also skips the final pseudopoint inside this loop. There is no need to reconstruct a completely opposite table OTC (in the sense of connectivity as for table O), which can be used only to store the code of statement B.

[0151] refer to Figure 25 In the second pass, the recursion of statement B utilizes the code from pass A to assign UV coordinate indices to those angles by oscillating around them. This pass populates table TC with UV indices. During the loop, angles that have already been visited or are associated with pseudopoints are skipped.

[0152] refer to Figure 26In the final iteration, the recursion from statement C uses the TC and MTC tables to calculate the final UV coordinates, marking the UV coordinates that have been processed. If the bitstream is encoded without prediction (cfg.uvPred=NONE), the values ​​of table iUVcoords are copied as is into the UV table using a CC shift. Otherwise, the UV coordinates are predicted using the uvSepDecodeWithPredictionExt procedure as described below.

[0153] Decode the post-processing.

[0154] like Figure 15 As described, connectivity and properties are decoded at the end of the startDecompression procedure. In some embodiments, additional post-processing steps are performed to complete the mesh. Figure 27 The postProcess procedure is described below. The different parts of this procedure are described symmetrically with the preProcess procedure (see [link]). Figure 28 ).

[0155] Figure 27 The illustration shows an example of the postProcess program, which removes pseudopoints while converting the reconstructed CT mesh into a set of indexed faces, and optionally recreates the nonmanifold if lossless encoding is used.

[0156] The example preprocessing and postprocessing steps are shown in more detail in the next section.

[0157] Preprocessing and postprocessing.

[0158] In some embodiments, preprocessing is performed to convert some standard indexed face set meshes into a corner table representation for efficient use of edge-breaking algorithms optimized to run on corner tables. Indexed face set meshes are also known as face-vertex meshes. These are traditionally stored in common file formats such as ".obj", ".ply", or others that store triangle meshes. Face-vertex representations are also a representation ingested by graphics hardware for rendering. The conversion to corner tables can be performed using known techniques. However, during the conversion to a CT representation, the example embodiment also performs filtering of non-manifold vertices and edges, as described below. The example embodiment also introduces dummy vertices and dummy faces to fill the final holes in the input mesh, as described below. Symmetrically, during decoding, the final dummy vertices are removed, and in lossless mode, non-manifold connectivity is recreated. Figure 28 An overview of example preprocessing and postprocessing is presented side-by-side. The quantization and dequantization processes can be performed using a standard unified quantization mechanism. In some embodiments, quantization and dequantization are not performed, such as in embodiments where a prequantized mesh (e.g., a mesh with all integer properties) is encoded.

[0159] Figure 28 The preProcess and postProcess programs are shown side by side. Figure 10 and Figure 27 The comments and headings provide additional details about preprocessing and postprocessing, respectively. In some embodiments, optional actions for deduplication are also performed during preprocessing within the fixNonManifold procedure.

[0160] Non-manifold filtering.

[0161] For example, some meshes derived from 3D reconstructions using a scanner may have some "incorrect" connectivity because they do not possess a manifold topology that can be handled using standard edge-breaking coding. For instance, a surface described by triangles may be non-manifold at some vertices or edges, and therefore experience conditions such as... Figure 9 and Figure 10 The processing is illustrated. The purpose of filtering is to fix these problems to allow edge destroyer encoding. In some embodiments, this is done by copying selected vertices, so that triangles sharing non-manifold edges or vertices no longer share the same edges or vertices.

[0162] Figure 29A and 29B The diagram illustrates a mesh with non-manifold vertices. Figure 29C The illustration shows an example technique for fixing a problem by splitting vertices.

[0163] exist Figure 29A In the example, a vertex (for example, an index in the vertex table) A vertex is shared by two triangles, but those triangles do not share any edges (therefore, the vertex is non-manifold). The example implementation addresses this non-manifold problem by copying the common vertex and creating a new vertex with the same 3D location and properties. This new vertex is added to the vertex table and indexed within it. In this case, a face description reference And the second face description references After processing, the faces are no longer connected, so there will be no non-manifold problem. In this example, it will produce two connected components (CCs), each consisting of only one triangle (a "connected component" is a set of triangles for which there is always a path to other triangles in terms of connectivity). By performing this replication, we see that we can generate multiple connected components.

[0164] When methods used to repair non-manifold vertices are applied to non-manifold edges, some surface continuity issues arise. (Reference) Figure 30A single non-manifold edge extending between vertices i1 and i2 is shared by three triangles T1, T2, and T3. If the vertices of the non-manifold edge are copied, the face will no longer be connected. If faces T1 and T2 are part of a larger connected component, this will introduce "cracks" into the surface of the mesh. Furthermore, copying all those vertices introduces more vertex data to be encoded. Figure 30 As illustrated, two of the three surfaces generated by replicating non-manifold vertices are repaired by re-stitching.

[0165] Figures 31A-31D The illustration depicts filtering on a non-manifold surface according to some embodiments. One example technique could be referred to as cutting and re-stitching. Figure 31A As shown, the triangle connectivity on non-manifold edge 3102 is cut off by resetting the diagonal to -2 (or to another appropriate predetermined value). Figure 31B As shown, vertices are copied if necessary. (For clarity, duplicated vertices are shown here at a slightly offset position, but in the example embodiment, the positions of duplicated vertices are the same.) Figure 31C As shown, the process starts from the visited angle. Swing left and right. (Example) Figure 31D As shown, when the left vertex index equal to the index of the right vertex and At that time, the diagonals were reassembled.

[0166] Some example implementations perform a vertex copy operation to remove one or more non-manifold edges. A preprocessing step is then performed, which, where possible, repairs newly introduced holes through a re-stitching process. This reduces or eliminates the need to handle specific cases during the remainder of the process, simplifying the implementation of the edge destroyer and reducing the number of pseudopoints, UV seams (since geometric seams inevitably introduce texture seams), and the impact on the edge destroyer.

[0167] In some embodiments, such a method may be performed as follows: Identify at least one non-manifold edge in the mesh; repeat vertices along the non-manifold edge to separate the non-manifold edge into at least two manifold edges; stitch two of the at least two manifold edges together; and after stitching the two of the at least two manifold edges together, encode the mesh using edge-breaking encoding.

[0168] In some embodiments, the non-manifold filtering stage (by...) Figures 31A-31D(Illustrated) The following occurs during preprocessing. Mesh filtering is performed on the non-manifold surface. Triangle connectivity of the non-manifold surface is cut by resetting the O-table for some corners and setting the O-value to -2 at the appropriate corners. Vertices can be repeated if necessary. Triangle connectivity is re-stitched by modifying the O-table if appropriate. Filtering of non-manifold surfaces can be performed using known techniques such as those used in the Google Draco system. In the example embodiment, a "re-stitching" phase is performed to reconnect some triangles. This also allows the non-manifold surface to be recreated without lossy encoding. The example embodiment further includes a phase for repeating vertices. Figure 32 The “repeating vertices” stage is described in bold. Features described in particular detail here are shown in bold. These bolded features include those for handling deduplication for the lossless mode and for re-stitching. In summary, the example embodiment tracks the index of added vertices (for the lossless case) and stores a table of paired angles to... Figure 31C and Figure 33 The final iteration, as shown, involves "re-splicing" the paired angles at the end of the process. Figure 33 The illustration shows an example preprocessing operation that reassembles a table of matched opposites.

[0169] Non-manifold filtering, lossless case.

[0170] In some embodiments, lossless encoding of the input mesh is performed to accurately reproduce connectivity, including non-manifold problems. As shown in the previous section, the example embodiment tracks the inserted (copied) vertices and the original vertices (here referred to as the parent vertex of the inserted vertex) in a table during preprocessing. Some data representing those copies is provided in the bitstream, and said data is then used during decoding (in several stages) to reconstruct accurate connectivity when needed.

[0171] The availability of lossless modes for connectivity, as described in this paper, offers at least two benefits. First, it allows for completely lossless encoding modes for both connectivity and attributes. Second, in some cases, lossless encoding of meshes allows for higher encoding gains, even when lossy encoding is applied to the mesh as a whole (e.g., for attributes). These gains may be a result of avoiding repeated vertices during the subdivision process of encoding and then being used for translation encoding. Lossless encoding of meshes can also enhance motion encoding.

[0172] An example encoding method includes: identifying at least one non-manifold edge in a mesh, the non-manifold edge being defined by a parent vertex; preprocessing the mesh by copying the parent vertex along the non-manifold edge to separate the non-manifold edge into at least two manifold edges, each manifold edge being defined by a child vertex, each child vertex being copied from a corresponding parent vertex; encoding the preprocessed mesh into a bitstream using edge-destroying encoding; and providing information about the parent vertex that identifies the child vertices in the bitstream.

[0173] An example decoding method includes: obtaining information from a bitstream that defines multiple connected components of an edge-destroyer encoded nonmanifold mesh; obtaining information from the bitstream that associates child vertices with parent vertices; at least partially decoding at least two connected components, each of which has child vertices associated with its respective parent vertex; and deduplicating the child vertices to reconstruct the nonmanifold mesh.

[0174] During the encoding phase, when positions are copied using non-manifold filtering (potentially recursively), the example embodiment tracks vertices with the same original parent vertex. A unique identifier (e.g., ranging from 1 to the number of vertices ultimately added) is assigned to each vertex index associated with a copied vertex. This information can be stored, for example, in a duplicates map, where each entry associates such an identifier with the duplicate vertex index. To populate the duplicates map, when a vertex is added to the map, it is determined whether the parent vertex is already in the map. In one case, the parent vertex is already in the map and associated with a unique identifier. Alternatively, both the parent vertex and the added vertex are added to the map, and those are associated with a new identifier (which could be the current number of split vertices).

[0175] The number of split vertices is the number of original position indices copied during the process. At the end of the process, the total number of entries in the duplicatesMap is (number of split vertices + number of added vertices).

[0176] When using the primary index table (see...) Figure 37During the encoding of attributes, when traversing the topology, upon encountering a split or added vertex, the registration of the processed corner index and the corresponding unique split vertex index is performed. Some embodiments use the `oDuplicateSymbolIdx` array (which stores the processed corner index) and the `oDuplicateSplitVertexIdx` array (which stores the unique split vertex index). Because the `processedCorners` array is updated per triangle (rather than for the first two vertices of any connected component), some embodiments additionally store a Boolean value indicating whether there are duplicate vertices on the first two vertices of the first triangle of any connected component. Therefore, the example embodiment additionally uses a Boolean array named `oDuplicatesOnStart` of size (2 * connected components).

[0177] The example implementation then signals some or all of the following information in the bitstream: • Size of the oDuplicateSymbolIdx array = Number of split vertices + Number of added vertices • An integer array oDuplicateSymbolIdx of size oDuplicateSymbolIdx. (Of course, this or any other software implementation feature described herein may be given a name different from that used in this disclosure. For example, the integer array oDuplicateSymbolIdx may alternatively have a name such as perDuplicateProcessedCornerIndices. Some embodiments allow up to three copies associated with the first processed corner index of any connected component (each of the three vertices of the first triangle in those copies has a corner). In some embodiments, this may be incrementally encoded and inserted as a variable unsigned integer.)

[0178] • An integer array oDuplicateSymbolIdx of size oDuplicateSymbolIdx, which provides a unique value for each set of vertices copied from a parent vertex that has been split (including the original parent vertex) and encoded as variables such as unsigned integers.

[0179] • A Boolean array of size 2 * (number of connected components) can be encoded using Dirac arithmetic coding, as follows: o An unsigned integer variable of size dup01_encoded_size, which is in bytes of dup01Buffer. This dup01Buffer contains the AC-encoded flag (2*nbCC bits before encoding) used to signal the repetition of each CC at position 0 or 1. o Contains the dup01_encoded_size bytes of the encoded buffer.

[0180] Alternatively or additionally, the example embodiments signal some or all of the following information in the bitstream: • The "encodeAttributes" location procedure call, a boolean value, indicates whether the vertex is copied.

[0181] • Then there is a Boolean value indicating that this is the first occurrence of the value.

[0182] • If it is not the first occurrence, it is the index of the parent split vertex in the table of the basic split vertices.

[0183] In some embodiments, this information is arithmetically encoded. This method reduces the amount of information encoded in the stream when there are many segments (which will have to be checked). Furthermore, the Boolean array (a) can be encoded only for CCs containing repeating vertices, adding another level of indirection, where the first bit string should define which CCs include repeating vertices, but will reduce the size of array (a), thereby removing potential ranges with constant false values.

[0184] In some embodiments, a determination is made of which encoding method produces the minimum bitstream, the selected method is used to encode the grid, and the indication of the method used is signaled in the bitstream.

[0185] In some embodiments, to prevent duplicate locations from being encoded twice or more, the process returns from `encodeAttributes` without calculating the associated residuals in response to the determination that duplicate vertices have already been processed. The corresponding function is also executed in the decoder. Such embodiments are particularly useful for improving performance when the mesh has many segments.

[0186] When using this deduplication option, the positional topology of the input mesh is reproduced without loss after encoding / decoding. In some embodiments, the same technique is used to achieve attribute deduplication.

[0187] On the decoder side, the decoder obtains data such as iDuplicatesOnStart, iDuplicateSymbolIdx, iDuplicateSplitVertexIdx, and cornerIndex (which may also be alternatively referred to as currentDuplicateIndex or any other arbitrary name).

[0188] During decoding (see Figure 17), an update is performed inside the `deduplicateVertices` procedure (see Figure 34), updating the index of the processed corner (an offset is added for each CC because `processedCorners` is cleared after each CC). The decoder can then check if the current corner is associated with a repeating vertex (including additional checks on the first two vertices of each CC, or using alternative techniques). The decoder then assigns a single index to each of the repeating vertices in the `processDuplicate` procedure. Figures 34A-34B The diagram illustrates examples of the procedures `deduplicateVertices` and `processDuplicate`. When a given split vertex index is first called, the current vertex index is associated with the split vertex index. In subsequent calls utilizing the given split vertex index, the copy index is replaced with the registration index corresponding to the first occurrence of the duplicate vertex. This data is used to regenerate the nonmanifold by deduplicating some vertices before converting the CT to a set of indexed faces. Figure 35 The diagram below illustrates an example of this process.

[0189] Virtual pseudopoints of a grid with boundaries.

[0190] Figure 36 The process in the example embodiment is illustrated, in which pseudo vertices are used. And pseudo-triangles to fill the holes 3602 in the mesh surface. Value It is the index of the pseudopoint in the vertex table.

[0191] One known method for handling bounded meshes (also known as meshes with holes) is to fill each hole with a pseudo-point and connect this new vertex to the boundary of the hole using sectors of a triangle. The mesh is then encoded / decoded as if the holes did not exist. Some data indicating which points are pseudo-points is encoded in the bitstream, so that the point and its associated pseudo-triangle (from the sector) can be removed after decoding. In such techniques, pseudo-points are typically encoded using spurious attribute values ​​(usually from interpolation).

[0192] In the exemplary embodiments of this disclosure, the process of filling holes with pseudopoints is performed after non-manifold filtering, because non-manifold filtering itself may introduce holes in the surface. Furthermore, the exemplary embodiments track the indexes of the pseudopoints and do not encode the attributes of the pseudopoints (e.g., position, UV coordinates, color, etc.). Therefore, when predicting the attributes of non-pseudopoints, the exemplary embodiments do not use the false attributes of the pseudopoints.

[0193] In the example implementation, pseudo-triangles are encoded, but the attributes of the pseudo-points (position, UV coordinates, etc.) are not encoded. Interpolation attributes are not used to compute predictions. Instead, some implementations track pseudo-point indices and skip those indices during prediction.

[0194] An example encoding method includes: preprocessing a mesh with holes by creating pseudo vertices that are connected to each vertex along the perimeter of the holes; encoding the preprocessed mesh in a bitstream using edge-destroying encoding; encoding information identifying the pseudo vertices in the bitstream; and encoding at least one attribute for each of a plurality of vertices in the preprocessed mesh, wherein for pseudo vertices, the attribute is not encoded.

[0195] An example decoding method includes: obtaining information encoding a grid from a bitstream; obtaining information identifying at least one pseudo-vertex in the grid from the bitstream; and decoding attribute information of multiple vertices in the grid from the bitstream, wherein the attribute information is not decoded for at least one pseudo-vertex.

[0196] In some such embodiments, decoding the attribute information of multiple vertices includes predicting the attribute information of multiple vertices, where no attribute information is predicted for pseudo-vertices. The decoder can remove pseudo-vertices.

[0197] The example embodiments are capable of handling meshes with and without separate UV coordinate index tables. Some encoders (such as the VDMC encoder) use a base mesh with a separate index table, and the geometry consists of a small number of closed meshes (which eventually have holes, but are closed most of the time) rather than mesh patches. Therefore, in some embodiments, the economy of not encoding the first boundary is not significant.

[0198] Regarding the handling of "virtual" pseudopoints, Figure 35 and Figure 36 Example procedures for processing pseudopoints according to some embodiments are described.

[0199] In embodiments where the attribute uses a master index table, the preprocessing includes filling holes by adding new corners and triangles to the corner table and establishing connectivity. An index table of pseudo-vertexes, along with some additional positions and other optional attributes in the attribute table (this attribute data is only used to fill gaps; the example embodiment uses zeros), is stored in memory. During connectivity encoding / decoding using an edge disruptor, connectivity is used as is, including pseudo-triangles. To better predict other vertices and conserve data in the bitstream, this table is used to skip pseudo-vertex attributes during attribute prediction during encoding and decoding.

[0200] In embodiments where attributes use separate index tables, different processing is performed on the corner tables. Such embodiments do not recreate connectivity, but simply use... To initialize the new TC element, and use To initialize new OTC elements, each added corner has an attribute table TC and OTC marked as a special element, which can be treated like a seam. (Figure 47 illustrates an example of a texture seam).

[0201] Figure 37 The illustration shows an example of a C++ program that fills all the holes in a grid described as a corner table (O, V, OT, OTC).

[0202] Figures 38A-38C The illustration shows an example of a C++ program that fills a single hole in a grid described as a corner table (O, V, OT, OTC).

[0203] In the example embodiment, the pseudopoint index table is encoded in the bitstream. See, for example, the syntax element DATA_DUMMY_POINT_COUNT in Table 4 below and DATA_DUMMY_POINTS_TABLE in Table 5 below. However, the attributes associated with the pseudopoints are not encoded.

[0204] During post-processing, after decoding the mesh, the example embodiment uses pseudo-point indexing to remove pseudo-points and attached pseudo-triangles. Therefore, the output of this process matches the original mesh in terms of boundaries. This process can be performed during transcoding to the final indexed facet representation.

[0205] Update the vertex index, thereby removing references to pseudo vertices and shifting subsequent indices accordingly.

[0206] exist Figure 57 The diagram illustrates an example implementation of this technique. The complexity of this implementation is `dummy_count * numOfTriangles`. This processing can be expensive when the model has a large number of triangles and a large number of pseudo-vertices. In such cases, it might be preferable to first define the mapping function using a list of pseudo-position indices, and then apply this remapping while recording which triangles should not be included in the decoded mesh. (For example, a boolean false value could be assigned to triangles that include at least one pseudo-vertex, and then those triangles could be discarded.) Encoding and decoding of per-vertex attributes.

[0207] To compute predictions, example embodiments use multi-parallelogram predictions for geometry, as in D. Cohen-Or, R. Cohen, and R. Irony, “Multi-mode Geometry Coding,” School of Computer Science, Tel Aviv University, Tel Aviv, 2002; and M. Isenburg and P. Alliez, “Predicting Compressed Polygon Mesh Geometry with Parallelograms.” IEEE Visualization Described in 2002, doi: 10.1109 / VISUAL.2002.1183768, pages 141-146. Example embodiments use minimum stretch prediction for UV coordinates, as described in IM and SJ, “Compressing Texture Coordinates Using Selective Linear Prediction.” International Conference on Computer Graphics Described in Tokyo, Japan, in 2003.

[0208] The example embodiments further provide procedures for processing pseudopoints to fill holes and for processing an optional separate index table for UV coordinates. The described techniques can be further used to support predictions of other properties, such as per-vertex normals, per-vertex color, or any other per-vertex attribute.

[0209] Some embodiments provide prediction methods for handling pseudopoints and separate index tables (and therefore UV seams).

[0210] In some embodiments, predictions using the attributes of the primary index table are made through methods such as... Figures 39A-39B The `encodeAttributes` function, as presented in the code, is used to implement this. This function is called several times during edge-destroyer encoding. Figure 41 Its decoding peer, decodeAttributes, is described. Similarly, this procedure is invoked several times during edge-breaker decoding.

[0211] Figure 40 The diagram illustrates an example of the assertion isCornerVertexDummy. During encoding, all pseudo-vertexes are at the end of the vertex table, but this is not the case during decoding.

[0212] Location residual encoding.

[0213] Figure 42 illustrates an example of the program posEncodeWithPrediction.

[0214] The example implementation stores the global coordinates of the starting point location and the residuals of other points in a separate table to obtain better entropy encoding.

[0215] An example mesh encoding method includes: encoding the connectivity of the mesh; entropy encoding the first starting point position table of the vertices in the mesh; and entropy encoding the second point residual table of the vertices in the mesh separately.

[0216] An example mesh decoding method includes: decoding information indicating the connectivity of the mesh; performing entropy decoding on a first starting point position table of vertices in the mesh; and performing entropy decoding separately on a second point residual table of vertices in the mesh.

[0217] Some example implementations extend the multi-parallelogram method to handle pseudo-point cases, thereby preventing incorrect predictions of parallelograms involving pseudo-points.

[0218] Some example implementations extend predictive decoding to support multiple connected components by using table shifting.

[0219] An example mesh encoding method includes: obtaining information defining a mesh with multiple connected components (CCs), each vertex in a CC having a unique global range index; for each CC, shifting the index of the vertices in the CC from the global range index to the CC range index; and encoding each CC in the CC using the CC range index.

[0220] An example mesh decoding method includes: obtaining information encoding multiple connected components (CCs), each vertex in a CC having its own CC range index; decoding each CC in the CCs; and for each vertex, shifting the vertex's index from the CC range index to a global range index.

[0221] During the coding phase, example methods include, for example, using... Figure 40 The illustrated method is used to calculate the diagonal in the encoding chain. and its attached vertex index Position prediction. During the prediction of the angle, we are confident that its associated triangular sector is always complete and that each of its angles has a valid opposite angle, because the example embodiment uses pseudo-points to fill the holes (in terms of connectivity, a single triangle will actually become a pyramid shape composed of 4 triangles).

[0222] Figure 43A The illustration shows a method for angle according to some embodiments. Strategies for multi-parallelogram prediction and pseudo-point filtering at location.

[0223] Figure 43B The illustration shows a method for angle according to some embodiments. The strategy of minimum stretching prediction and pseudopoint filtering for UV coordinates.

[0224] In the first step, the process checks the angles to be encoded. Is it attached to a pseudo-vertex (if so, skip the corner encoding) or do we predict the first vertex of the chain? (Then we use global coordinates instead of prediction to...) The position is encoded. In the latter case, the process stores that position in a specific table (table sVertices) dedicated to entropy encoding of the starting vertex. Storing those positions in a specific table different from the prediction table (table oVertices) allows for better entropy encoding of those tables.

[0225] Otherwise, in the second step, we test whether the vertex is the second or third vertex. or In this case, instead of performing a prediction, we use incremental encoding on the vertices of the previous corner and append the result to the predicted vertex table; .

[0226] Otherwise, for a given angle The processing of multiple parallelograms involves performing a search around their vertices in the first loop to compute each parallelogram prediction using the diagonals and summing them (see...). Figure 41 Only when , and When a vertex has already been processed by connectivity recursion (its call prediction), from a sibling angle Prediction Angle Only parallelograms are valid for prediction. To test this, we use a vertex label table. If a vertex has already been visited cyclically using connectivity encoding, then the vertex label table for that vertex... The element is set to true. Then, the test during prediction is... and and .

[0227] We'll extend this to test. , and Is the corner not attached to the pseudopoint (using...) (Assertion). In conclusion, we only consider angles when data is available. Used for parallelogram prediction (parallelogram vertices are not pseudo-parallelograms and have been visited, so they are available during decoding). At the end of the loop, we predict and divide by the number of valid parallelograms found, round the result, and finally use the result to calculate the residual (predicted position), which is appended to the end of the output vertex table; .

[0228] If no valid parallelogram is found, we fall back to incremental encoding. If the preceding corner is a pseudopoint, then use As a prediction, otherwise use As a prediction.

[0229] At the end of the edge destroyer coding program, two tables and It will then be entropy encoded and stored in a bitstream.

[0230] During decoding, Figures 42A-42B The diagram illustrates an example of reconstructing the diagonal vertex positions. This process is identical to that used for encoding and follows the same order of vertex and sector exploration. Therefore, the obtained prediction is equal to the encoded prediction. Note that for decoding, we use a table... This table is used to quickly determine whether a vertex is a false vertex. By program To initialize (see Figure 16). Also note that in the predictive decoder, we use table shifting to handle CC (this is not the case in the predictive encoder).

[0231] Figures 44A-44B The diagram illustrates an example of the program posDecodeWithPrediction. Table D indicates whether each vertex is a pseudo-vertex.

[0232] Use the master index table to perform residual encoding on the UV coordinates.

[0233] The predictive encoding using UV coordinates from the master index table is extended in the same way as for location. Some embodiments differ in that they use minimum stretching instead of multiple parallelograms for prediction, and instead of summing the predictions (which is not multiple), we stop at the first valid (in the sense of prediction) neighbor in the triangular sector and compute minimum stretching, as shown in example. Figure 41 As shown in Figure 43, an example uvEncodeWithPrediction program is illustrated. Figures 44A-44B Example prediction statements are depicted in the text.

[0234] Figures 45A-45B The illustration shows an example of the program uvEncodeWithPrediction.

[0235] Figures 46A-46B The diagram illustrates an example of the statement `predictUV`. `dvec2` and `dvec3` are double-precision vectors.

[0236] exist Figures 44A-44BAs seen in the `predictUV` procedure, we have one branch using the prediction and two other paths using alternatives. This method is based on an initial selection using the geometry, followed by a minimum stretch UV prediction, or a fallback to the increment if there are spurious objects in the vertex chain, otherwise averaging the UVs of the previous and next corners. Note that in the case of the minimum stretch selection, the example embodiment stores the prediction residuals (in the table `oUVCoords`) and the orientation bits used during decoding (in the table `orientations`). Correspondingly, the two other paths do not store orientation information.

[0237] Regarding position, decoding is symmetrical. The example implementation uses table shifting to process CC, and we use the same logic as for position. Input Extracted as: ; It includes CC offset Separate table The initial value and the case of pseudopoints in the middle This extracted This can be an increment (in the case of v=1 or v=2) or otherwise a residual. The example embodiment then performs the same prediction or backtracking as in UV encoding and computes the final UV back to the location: ,in It is the predicted UV or regression.

[0238] Residual encoding of UV coordinates using different index tables.

[0239] When the model utilizes a separate index table for UV coordinates, the example embodiment handles potential UV seams during prediction (in addition to separate tables for the initial UV, multiple CCs, and pseudopoints). Without a separate index table, the positions of vertices on UV patch boundaries are repeated, and the mesh contains at least as many CCs as the UV patch. This is why, in the previous sections, we treated UVs as locations, which have the same structure. Correspondingly, in the example embodiment using a separate index table for UV coordinates, it is possible to have a more “compact” geometry without UV-specific CCs, and to use a separate UV index table to handle UV patch boundaries. Edge chains on meshes with different UV coordinates on each side can be called UV seams.

[0240] Figure 47A The illustration shows how to handle UV seams using only the master index table. Duplicate vertices (shown inside the dashed ellipse) can have different UV coordinates. Figure 47B The diagram illustrates the use of a separate index table and for angles. The selection strategy for handling UV, the angle Used to utilize angles A separate index is used to predict UV coordinates.

[0241] Some example implementations extend the UV predictor search strategy to support UV seams. In some such implementations, this is done by storing specific codes in the TC and OTC tables to guide the algorithm.

[0242] Example implementation example execution as follows Figures 45A-45B The search strategy for effectively predicting angles is described in the diagram. In this method, pseudopoints are implicitly handled; only whether the UV coordinates of sibling angles have been reconstructed is checked. Finding the angle... Effective UV predictor The strategy is to engage with the angle The search term searches for the first triangle in the sector portion on the same side of the seam, for which the maximum value of the UV coordinates has already been predicted. The example embodiment selects the first corner where two UVs have been predicted, or the first corner where one UV has been predicted if none are found, otherwise no prediction is made. For the search, we can turn left first, then right, or vice versa; it doesn't matter, but the same order is used during decoding. Figure 46 illustrates an example of the detailed procedure for performing this task: `encodeSeparateIndexAttributes`.

[0243] In some embodiments, such as Figures 47A-47B As shown, decoding performs the same processing (using a shifted table) to recover the predicted values, and then recovers the final UV coordinates. Note that this stage does not specifically specify whether the isSeam table is used, as this table is used during edge-breaker decoding to create some valid TC and OTC tables, which handle separate indexes. In this stage, the TC table is used to find the UV index for each corner, and the OTC table is used to detect UV seams. The example embodiment uses -4 from the OTC during encoding and -1 from the OTC during decoding. This is because values ​​between 0 and -4 are used for other purposes.

[0244] Figures 48A-48B The illustration shows an example of the program encodeSeparateIndexAttributes.

[0245] Figures 49A-49B The illustration shows an example of the program decodeSeparateIndexAttributes.

[0246] Prediction of attributes for each facet.

[0247] Some example embodiments encode and decode the color or ID of each face. In some such embodiments, the attributes of each face are encoded according to the order of the faces in the CLERS table. Each symbol in the table corresponds to a triangle. Whenever we encode / decode a new triangle (performing T=0 or T++), the example embodiments operate to encode connectivity (see...). Figure 12 and 13) and connectivity decoding (see Figure 18 During steps 1 and 19), the attributes of each face are directly encoded. Then, example embodiments include adding the encoding of the triangle attributes to a table at these steps. Some embodiments add the values ​​(color, ID, ...) directly to a dedicated table, for example, by performing incremental encoding with previous triangles in the table. Some embodiments use a separate table to process the starting triangle, similar to the technique described herein for encoding the attributes of each vertex for the starting vertex. Such embodiments can have more efficient entropy encoding.

[0248] The example implementation uses a sequence of triangles, ordered according to the CLERS table, to encode incremental values ​​for each triangle's color (e.g., 8-bit RGB) or integer (e.g., group identifier, subdivision depth). Depending on the type of attribute, the same strategy can be used to envision some more complex predictions.

[0249] Examples of mesh encoding methods include: obtaining information describing a mesh with multiple triangles, each triangle having attributes; encoding the mesh as an ordered sequence of symbols in edge-destroying encoding, where each triangle corresponds to an associated symbol; and encoding the attributes of the triangles, where the attribute of the current triangle is encoded using predictions based solely on the attributes of at least one triangle preceding the current triangle in the ordered sequence of symbols. For example, the attribute of each triangle could be encoded as an incremental value relative to the previous triangle in the sequence (the attribute value of the previous triangle acts as a prediction).

[0250] A mesh decoding method according to some embodiments includes: obtaining an ordered sequence of symbols representing an edge-destroyer code of a mesh having multiple triangles, each triangle having an attribute; decoding the mesh; and decoding the attributes of the triangles, using predictions of the attributes of the current triangle based only on the attributes of at least one triangle preceding the current triangle in the ordered sequence of symbols.

[0251] Predicting per-vertex attributes can be particularly useful for mesh coding systems that handle specific adaptive subdivisions for each triangle group. For example, each triangle of the base mesh might receive an integer specifying the number of subdivisions it should receive to reconstruct the complete mesh.

[0252] Some embodiments implement a technique for encoding the ID (e.g., material ID) of each facet (referred to here as variant A). Figures 59A-59B An example of code for implementing variant A is provided. In such an embodiment, for each angle processed during the traversal of defining the new triangle, the following actions can be performed: • Determine whether the current corner defines a real face or a pseudo face (if one of the corners of a face is associated with a pseudo vertex, then the face is pseudo).

[0253] • Determine whether the current Id is equal to the previously encoded Id, and store the comparison result in a Boolean vector `faceIdEqualToPrevious`, the final size of which is the number of triangles in the input mesh (before adding pseudo-vertex). If the current Id is equal to the previously encoded Id, no further encoding of the current Id is required. However, if the current Id is not equal to the previous Id, the following steps are performed for encoding the current Id: • Determine whether any face opposite each of the current face angles has been encoded. The current triangle is defined by the following three angles: currentCorner, ov.n (currentCorner), and ov.p (currentCorner). The "facing triangle" is defined as the triangle containing ov.O (currentCorner). The "right triangle" is the triangle containing ov.O [ov.n (currentCorner)]. The "left triangle" is the triangle containing ov.O [ov.p (currentCorner)].

[0254] • For each of those triangles (the face opposite each angle of the current triangle, defined by the angle index, such as...), Figures 61A-61C As shown), if it has not yet been encoded, we first perform a loop through the face containing currentCorner=ov.O[ov.n(currentCorner)], stopping when a face that has already been encoded is found, until the face under consideration is not the current face whose Id value we are encoding. If no face to be decoded is found, we start again and loop in the other direction, i.e. through the face containing currentCorner=ov.O[ov.p(currentCorner)].

[0255] • For each corner corresponding to a real face, this produces three boolean values ​​(decodedRight, decodedLeft, decodedFacing), and for those true values, we know the corresponding face ID value (faceIdRight, faceIdLeft, faceIdFacing) that has been encoded. When the boolean value is false, the corresponding faceIdRight / Left / Facing value may be set to an invalid value (e.g., -1 if we only consider id values ​​>= 0).

[0256] • Then perform the following procedure: • Then, the face can be marked as encoded.

[0257] • This process produces four Boolean vectors (faceIdEqualToPrevious, faceIdIsRight, faceIdIsLeft, faceIdIsFacing) and a vector containing the value that was not predicted (notPredictedFaceId).

[0258] Figures 61A-61C The diagram illustrates an example of the search order for corner[0] = c (this operation is repeated for corner[1] = cn, and then for corner[2] = cp). Figure 61A The diagram illustrates the face to be encoded for ID and the adjacent triangles L, R, and F. (These three adjacent triangles always exist because pseudo-points are used to fill holes.) Figure 61B The diagram illustrates the search in the neighborhood loop along the first direction on R, R1, R2, etc. Figure 61C The diagram illustrates the subsequent search in another direction.

[0259] Can about Figure 62 The example mesh is used to further illustrate the method described above for encoding parameters of faces in a mesh, such as the face ID of a triangle in the mesh. Figure 62 In the example, the parameters of the current face C (e.g., face ID) are being encoded. At least one edge-adjacent face is identified, and each edge-adjacent face shares one edge and two vertices with the current face. In this example, faces labeled R, L, and F are identified as edge-adjacent faces.

[0260] For at least the first edge-adjacent face in the set of edge-adjacent faces, such as face R, a first coded face associated with the first edge-adjacent face is identified, wherein the first coded face is identified from a first set of faces. The first set of faces includes multiple faces that share at least one vertex with both the current face C and the first edge-adjacent face R, excluding any edge-adjacent faces that are not the first edge-adjacent face. Figure 62 In the example, faces included in the first set are marked with S1. A first coded face can be identified by traversing the faces in the first set according to a predetermined order and selecting the earliest coded face encountered in that predetermined order as the first coded face. In different embodiments, the predetermined order may differ, but preferably, both the encoder and decoder are aware of the predetermined order. As described above, this order can begin from the edge-adjacent face R itself, marked here with S1a. If the parameters of this face (e.g., face Id) have not yet been encoded, the order can be performed by pivoting counterclockwise around the first shared vertex 622 through faces S1b, S1c, and S1d until a coded face is found. If a coded face has not yet been found, the order can be performed by pivoting clockwise around the second shared vertex 624 through faces S1e, S1f, S1g, and S1h until a coded face is found.

[0261] If no coded face is found, no value needs to be pushed onto the vector faceIdIsRight, because the decoder performing the same traversal can infer that the faces in set S1 will not be used to predict the current face's parameters. However, if a coded face is found, an indication of whether the parameter associated with the first coded face is equal to the current face's parameter can be encoded.

[0262] A similar process can be performed on other edge-adjacent surfaces L and F. For example, it can be performed from surfaces traversed in a predetermined order. Figure 62 A second coded face is selected from the faces in the second set indicated by S2, and is associated with the edge-adjacent face L. An indication indicating whether the second coded face has an associated parameter equal to the current parameter can be encoded. In some embodiments, such an indication can be encoded only if no coded face is found associated with the first edge-adjacent face R, or if such a face is found but does not have an associated parameter equal to the current parameter. Furthermore, if no second coded face is found, there is no need to signal such an indication, because the decoder performing the same traversal can infer that the faces in set S2 will not be used to predict the current parameter.

[0263] Similarly, it is possible to traverse in a predetermined order. Figure 62A third coded face is selected from the faces in the third set indicated by S3, and is associated with the face L adjacent to the third edge. An indication indicating whether the third coded face has an associated parameter equal to the current parameter can be encoded. In some embodiments, such an indication can be encoded only if no coded face is found associated with the face adjacent to the second edge, or if such a face is found but does not have an associated parameter equal to the current parameter. If no third coded face is found, there is no need to signal such an indication, because the decoder performing the same traversal can infer that the faces in set S3 will not be used to predict the current parameter.

[0264] The sets S1, S2, and S3 illustrated are provided as examples only and may differ in different embodiments, for example by including more or fewer faces than those illustrated herein.

[0265] If no encoding face is found (e.g., the current face is the first encoding face in the mesh), or if none of the encoding faces has the same parameter as the current face, then information that explicitly indicates the current face parameter can be encoded.

[0266] In some embodiments, the aforementioned traversal of different faces to identify coded faces with the same parameters (e.g., the same face ID) is performed only after it has been determined that a face with the most recently encoded parameter (here referred to as the "most recently encoded face" or "previous face") has a parameter value different from the previously defined parameter value. Information indicating whether the most recently encoded face has the same parameter value as the current face can be encoded. If they do indeed have the same value, both the encoder and decoder can avoid checking the encoding states and parameter values ​​of other neighboring triangles.

[0267] As mentioned above, some signaling can be avoided if the decoder can infer that a particular face was not used to predict the parameter values ​​of the preceding face (e.g., because the face was encoded after the current face).

[0268] In some embodiments, when performing a traversal of adjacent faces, additional signaling is avoided by treating the most recently encoded face as an invalid face. This can be done because if the most recently encoded face had the same parameter values ​​as the current face, the traversal would not be performed at all. The very fact that a traversal is being performed indicates that the most recently encoded face has different parameter values ​​than the current face; therefore, if a traversal of adjacent faces is being performed, unwanted signaling can be avoided by disallowing the selection of the most recently encoded face as the predictor at that stage.

[0269] Some such embodiments have been found to provide approximately 0.2% compression gain in base mesh intra-coding on certain sequences of VDMC v4.0 CTC. The example embodiments further reduce processing costs by exploring fewer possible paths "deeply".

[0270] As an overview, the example encoding process for face IDs described above can be summarized in three steps. First, in step A, we check if the corresponding (right, left, and facing) face is encoded. Then, in step B, we iterate through the triangles (defined by angles), oscillating around the first angle of the initially considered face, which shares a first vertex on the edge between the triangle to be encoded and the initially considered face. Finally, in step C, we iterate through the triangles oscillating around the second face and the initially considered face. Figure 63 The example encoding algorithm is described in the text.

[0271] In order to reduce signaling (and thus improve compression) based on the inference that "recently encoded facets" or "previous facets" will not be used as predictors, one or more of the following modifications can be made to the embodiments described above.

[0272] In some embodiments, the prior art is modified such that: - If, after step A, the corresponding face is evaluated as encoded but equal to the previously encoded face, the evaluation is invalid, and the algorithm proceeds to step B instead of stopping.

[0273] - If, after step C, the corresponding face is evaluated as encoded but equal to the previously encoded face, the evaluation is invalid, and the algorithm proceeds to the next R, L, F evaluation.

[0274] In some embodiments, the following further changes were implemented: - In steps B and C, when an encoding surface that is a previous decoding surface is found during the swing, we do not stop traversing. In this case, the search continues, so the search on the first decoding surface is never stopped, but the search on the first decoding surface that is not equal to the previous encoding surface is never stopped.

[0275] In some additional embodiments, the set of faces being searched is expanded by oscillating around the third corner of the initially considered face (we have implemented oscillation from two of the three corners of the considered face, but this potential alternative has not yet been tested). For example, the set of faces searched in association with face R may further include... Figure 64 The faces marked S1' (excluding those marked S1a to S1h). A similar addition can be made to the set of faces searched in association with other edge-adjacent faces.

[0276] Preventing recently encoded faces from being identified as valid predictors during this search phase has very low computational cost and allows for a reduction in the size of the vector storing the comparison results, thus saving bits in the final bitstream and also reducing the processing time used for arithmetic encoding vectors.

[0277] exist Figures 65A-65B The diagram illustrates code for an example encoding method according to some such embodiments. Features particularly relevant to this variant are shown in bold.

[0278] exist Figures 66A-66B The diagram illustrates code for an example decoding method according to some such embodiments. Features particularly relevant to this variant are shown in bold.

[0279] In some embodiments as described herein, the first set of faces, the second set of faces, and the third set of faces being searched exclude the most recently encoded faces. For example, in Figure 64 In the mesh shown, a face marked with P is the most recently encoded (or "previous") face, which is the face whose parameters (e.g., face Id) were last encoded before the parameters of the current face c were encoded. According to some of the previous embodiments described above, face P will fall into both the first set S1 and the second set S2. However, according to some embodiments, face P can be excluded from those sets.

[0280] In some embodiments, the search within the set stops if the most recently encoded face P is reached. For example, when face P is reached, the search or traversal through the first set S1 may stop because P is an encoded face, but since it is known that P does not have the same parameters as the current face (otherwise the search would not have occurred), the selection of P can be considered invalid, and a face cannot be identified from set S1. In other embodiments, the search skips the most recently encoded face P, but continues with any other face in that set. For example, regarding Figure 64 The search can proceed directly from S1f to S1h using the search order of the first set S1. In such an embodiment, the search may include traversing the faces in each set according to a predetermined order and selecting the earliest coded face encountered according to the predetermined order as the coded face for prediction, instead of selecting the most recently coded face P.

[0281] Figures 67A-67B The diagram illustrates the relationship with... Figures 59A-59B Compared to the embodiments shown, such as Figure 65A-6 The embodiment shown in 5b demonstrates the compression performance of encoding the base grid in V-DMC. The results for each CTC test sequence are averaged over 32 frames.

[0282] Some embodiments implement an alternative technique (referred to here as variant B) for encoding the ID of each face. Such a technique can be implemented as follows: • Store information indicating whether the current id is equal to the previous id in the first boolean vector.

[0283] • If they are not equal, store the absolute value of the current ID or the difference between it and the previous ID in the second integer value vector.

[0284] Some embodiments implement an alternative technique (referred to here as variant C) for encoding the ID of each face. Such a technique can be implemented as follows: • Store information indicating whether the current id is equal to the previous id in the first boolean vector.

[0285] • If they are not equal, information indicating whether the current id is equal to the most recently encoded id that is different from the previous id is stored in the second Boolean vector.

[0286] • If they are not equal, store the absolute value of the current ID or the difference between it and the previous ID in the third integer value vector.

[0287] In some embodiments, this can be performed using a large number of recently used values ​​and encoded indexes pointing to those values ​​instead of absolute values, but this is unlikely to result in increased efficiency.

[0288] For at least some sample sets of meshes processed in the VDMC context, the alternative methods (B and C) are less efficient than A, but are simpler to implement and faster to execute.

[0289] Figures 59A-59B The diagram illustrates a code example using alternative scheme A to perform coding. Similar to... Figures 59A-59B The encoding method shown is used to perform decoding using alternative scheme A (e.g., using the program decodePerFaceAttributes).

[0290] In some embodiments, a mesh encoding method includes: obtaining information describing a mesh having a plurality of triangles, each triangle having an attribute (such as an ID); encoding the mesh as an ordered sequence of symbols in edge-destroyer encoding, each of the triangles corresponding to an associated symbol; and encoding the attributes of the triangles, the attributes of the current triangle being encoded using predictions based on the attributes of at least one triangle in the mesh adjacent to the current triangle (such as a left-hand, right-hand, facing, and / or front triangle).

[0291] In some such embodiments, encoding the properties of a triangle includes encoding multiple Boolean vectors (such as faceIdEqualToPrevious, faceIdIsRight, faceIdIsLeft, and / or faceIdIsFacing vectors), which together indicate the corresponding triangle from which the respective properties are predicted for at least a plurality of said triangles.

[0292] As described in more detail below, arithmetic encoding of multiple Boolean vectors can also be performed.

[0293] In some embodiments, a mesh decoding method includes: obtaining an ordered sequence of symbols representing an edge-destroyer encoding of a mesh having a plurality of triangles, each triangle having an attribute; decoding the mesh; and decoding the attribute of a triangle, wherein the attribute of the current triangle is decoded using a prediction based on the attribute of at least one triangle in the mesh adjacent to the current triangle.

[0294] In some such embodiments, decoding the properties of a triangle includes encoding multiple Boolean vectors (such as faceIdEqualToPrevious, faceIdIsRight, faceIdIsLeft, and / or faceIdIsFacing vectors), which, for at least a plurality of said triangles, collectively indicate the corresponding triangle from which the corresponding properties are predicted.

[0295] As described in more detail below, arithmetic decoding of multiple Boolean vectors can also be performed.

[0296] Entropy coding.

[0297] Figure 50 The diagram illustrates an example of a program save, which involves entropy encoding and syntax writing. During the creation of the bitstream (see...),... Figures 48A-48B The example implementation first writes some metadata in the header, then saves the topology payload, and finally saves the attribute (location, UV coordinates) payload. For both the topology and attributes, some tables are entropy-encoded before saving. This section describes an example of entropy encoding.

[0298] The example implementations support two or more different arithmetic encoders, such as the Dirac or RANS codes described in J. Duda, “Asymmetric Digital Systems: Entropy Coding Combining the Speed ​​of Huffman Coding and the Compression Ratio of Arithmetic Coding,” 2014. For some data, one or more of these codecs may provide better compression. We have also found that for some other tables, one table or another is better at compression, depending on the model being compressed. The example implementations provide more than one arithmetic codec implementation scheme guided by several options. Table 6 below summarizes which arithmetic encoders are available for some implementations for each type of data. The following sections further detail the configuration / binaryization of some data tables depending on the type of arithmetic coding used.

[0299] Arithmetic encoding of the CLERS table.

[0300] When encoding a non-binary sequence of CLERS symbols (which represents topology code used to reconstruct the topology of a mesh traversed using an edge-breaker algorithm), one or more of the following methods can be used: The choice of preferred binaryization process and the choice of probabilistic model for the relevant binary symbols can depend on the specific properties of the symbol sequence to be encoded, which are influenced by the number of symbols (related to the number of faces in the grid) and the topology of the grid (e.g., the regularity of the grid structure under consideration, which potentially affects global symbol statistics, but also potentially affects the interrelationships between consecutive symbols).

[0301] Some implementations can specify variable-length codes for the symbol set (e.g., 5 symbols 'C', 'L', 'E', 'R', 'S' for a basic edge breaker), depending on the expected statistical distribution of those symbol sets. One known choice is to specify {'C', 0, 1 bits}, {'S', 1, 3 bits}, {'L', 3, 3 bits}, {'R', 5, 3 bits}, and {'E', 7, 3 bits}.

[0302] In some embodiments, when encoding is performed using RANS, the CLERS table, which consists of these codes, is provided to the encoder as is.

[0303] In some embodiments, when using Dirac encoding, it is possible to use several contexts (ctx) for encoding. Some such embodiments use ctx0 to encode b0, ctx1 to encode b1, and ctx2 to encode b2. When b0=0, it is not necessary to encode the two subsequent bits.

[0304] In some embodiments, the context for each binary symbol is selected based on the value of the previous binary symbol of the current symbol, but also on the value of the preceding symbol. This is useful for CLERS sequences because there is a strong correlation between consecutive symbols.

[0305] The example implementation using a global 5-bit (32 possible values) state is defined using two prior symbolic values. Alternative implementations use simplified or extended state definitions.

[0306] In some embodiments, one of the 32 bit_0 contexts is selected to encode the first bit defining whether the symbol is 'C'. If the symbol is not 'C', the second bit is encoded using one of the 32 context modeling values ​​for bit_1. Then, based on the value of bit_1, two sets of 32 contexts are used to encode bit_2. Finally, the latest encoded symbol is considered to update the global state. In our current implementation, the state has 3 bits of the latest value plus bits 0 and 3 from the previous value, i.e., 5 bits of 32 states. In practice, not all of those states are necessarily used: using a simple mapping, we will only instantiate 20 contexts, as 5 values ​​of the current symbol × 4 possible states retained from the previous symbol, i.e., 20 possible states. Then in this example, the total number of contexts used will be 20 × 4 = 80 (4 for bit_0, bit_1, bit_2IFbit_1is0, bit_2IFbit_1is1). When the number of symbols is small, using many contexts can prove inefficient. Therefore, based on the number of symbols to be encoded, the example implementation operates to adjust the amount of global state to be used. For example, when only capturing the value of the latest symbol, the example implementation may limit the global state to 3 or 5 bits instead of using 32 bits of global state (where 5 × 4 = 20 useful states).

[0307] In a variant, the example embodiment operates to test multiple combinations to encode using the selected combination, and to encode information indicating the selected combination in the bitstream.

[0308] Some implementations operate to define a scheme that progressively uses more states (bootstrapping) so that when the model is transformed based on, for example, the number of encoded symbols or other factors such as specific triggers of state values, statistics about input values ​​(e.g., the variance of probabilistic encoded bits), appropriate state values ​​are copied to uninitialized states.

[0309] Figure 51 An example of pseudocode for controlling the Dirac encoder used for the CLERS table is given in the document.

[0310] AC encoding of attribute residuals.

[0311] When encoding vertex attributes such as position or texture coordinates, the example implementation operates to predict those values, and then only the residuals are encoded. Absolute reference values ​​can be encoded separately to avoid degrading the performance of the arithmetic encoder by disrupting statistics.

[0312] When using RANS for encoding, the example implementation provides the encoder with a table consisting of these residuals as is.

[0313] In some embodiments, when encoding using Dirac, some control over the context can be performed. An example embodiment uses a Dirac arithmetic encoder to apply an encoding scheme for the arithmetic encoding of motion vectors. Figure 52 The code shown in the figure provides an illustrative copy of the encoding principles used for motion vectors in some embodiments.

[0314] Using this method, to encode signed integer values ​​of triples (one for each coordinate of a 3D position), the example embodiment uses 51 contexts. For each value, we first use a first context to encode the value 0 as one bit. If the value is not empty, we use a second context to encode the sign as one bit. Then, if the absolute value of the value to be encoded is 1, we use a third context to encode it as one bit. If the absolute value of the value to be encoded is greater than 1, the absolute value of the value to be encoded minus 1 is expGolomb encoded using a 2x7 context, with the exponent (prefix) part being 7 and the suffix part being 7. This is just an example, and different configurations can be used in other embodiments. In some embodiments, offset or shifted values ​​are used in conjunction with expGolomb encoding. Such an encoding scheme allows for better compression of distributions with high probability of values ​​-1 0 +1, and adjusts to distributions that do not conform to the ideal distributions ideally handled by expGolomb encoding. Figure 53 The example code shown for ExpGolomb encoding provides more details about the example offsets / shifts.

[0315] This modeling may not be optimal for the distribution of location or other attribute residuals. Therefore, some implementations use more refined modeling to achieve better results.

[0316] Some example implementations are as follows (the given size values ​​are merely examples). In some embodiments, the threshold before falling back to expGolomb encoding has been expanded (this is set via a bias parameter). In example implementations: 1. Encode 1 bit to signal whether the value is 0.

[0317] 2. Then, if it is not 0, the symbol is encoded as 1 bit. We only keep the newvalue = abs (initialvalue) encoding of -1.

[0318] 3. Then, the code for the maximum length bias (e.g., the simple code) is used to encode newvalue < bias, repeatedly repeating 0 and 1 when the bit count equals the value to be encoded and stopping after the bias value.

[0319] 4. Then, if the last bit transmitted is 0, the value is >= bias, and we use the biased exp - golomb coding to encode ( newvalue-bias )

[0320] The context in step 3 may be affected by the fact that the previously encoded value has an absolute value less than the bias. Their number can be restricted such that it can be any value from 1 to the bias. Figure 54 Schematic examples of the code for some embodiments are depicted. In this embodiment, the performance is affected by the loop order, per component / per residual. Depending on the predictor used and the type of data, the optimal order can be selected (it is best to loop through the values assigned to another component before using our parallelogram predictor for another component of the position), and for texture coordinates and stretch minimization prediction, it is best to loop through the components first. If the state per component is repetitive, there is no such ambiguity, but the performance / complexity may be affected.

[0321] Entropy coding of per - face material properties or other properties.

[0322] In some embodiments, when encoding the materialID property or the specified faceID value using an encoding scheme such as that detailed above so that a large span of consecutive triangles share a common value, the array of values defined by the encoding process can be arithmetically encoded using the following scheme. The encoding / prediction process results in: • Four boolean vectors: faceIdEqualToPrevious, faceIdIsRight, faceIdIsLeft, faceIdIsFacing.

[0323] • A vector notPredictedFaceId containing non - predicted values.

[0324] The four boolean vectors are arithmetically encoded using four independent contexts.

[0325] Vectors containing unsigned faceId values ​​are encoded using exponential Golomb coding and multiple contexts for encoding the suffix and prefix parts. These numbers can be adjusted to balance complexity / performance tradeoffs, taking into account the range of faceId values. For example, both prefix and suffix coding can use as many contexts as are used to represent the complete set of Id values. For values ​​ranging from 0 to 255, we can decide to use 8 contexts for both.

[0326] In some embodiments, exponential Golomb encoding may use optimized “shift” parameters, as in the previous example.

[0327] In some embodiments, when the input surface ID or material ID value is not unsigned, additional parameters can be added to transform the range of values ​​so that the transformed values ​​are all positive. Alternatively, some embodiments use the following or any similar bijective transformation that converts the ID range to positive values ​​to transform the values ​​to a positive range: .

[0328] In some embodiments, the five vectors can be encoded individually, resulting in five encoded byte arrays.

[0329] In some embodiments, the number of elements (original vector size) encoded into each of those vectors can be signaled. The size of the encoded byte arrays allows for decoding of each of those byte arrays in parallel.

[0330] In some alternative embodiments, multiple contexts are used to encode all information into a single byte array and decode progressively, thereby appropriately selecting the context by performing context selection during the mirror selection phase of the decoding process during the encoding phase.

[0331] Figure 60 The diagram illustrates an example of Dirac AC entropy coding used to encode the material ID for each face.

[0332] Example of low-level syntax.

[0333] This section describes the syntax used in some example implementations.

[0334] The syntax of an example bitstream structure is shown in Table 1. Table 1.

[0335] Table 2 shows example attribute bitstreams (DATA_ATTRIBUTES) according to some embodiments. Location UV coordinates [optional] Normal vector [optional] Color [optional] Table 2.

[0336] Table 3 shows an example configuration information bitstream (CFG_INFO) according to some embodiments. noun value size CFG_CODEC_TYPE In [Forward] 2b CFG_ENCODING_TYPE In [Ascii, binary] 1b CFG_POS_PRED Location prediction mode in [none, para, mpara] 2b CFG_UV_PRED UV coordinate prediction mode in [none, para, stretch] 2b CFG_PRED_CODER The arithmetic encoder used to encode the prediction in [dirac, dirac_alt, rans]. 2b CFG_TOPO_CODER The arithmetic encoder used to encode the CLERS table in [dirac, rans]. 2b CFG_INT_ATTR Use internal quantization (false) or do not use internal quantization (true). 1b CFG_QP Position quantization in the range [7,16] 8b CFG_QT UV coordinate quantization in the range [7,16] 8b CFG_QN Normal vector quantization in the range [7,16] 8b CFG_QC Color quantization in the range [7,8] 1b CFG_SEPARATE_UV_INDEX This is true if a separate index table is used for the YV coordinates. 1b For each vertex, NORMALS, then COLORS, and so on. CFG_DEDUPLICATE_POS True if the information is added to enable vertex position deduplication. 1b Table 3.

[0337] Table 4 shows an example data header information bitstream (DATA_HEADER) according to some embodiments. Table 4.

[0338] Table 5 provides example data topology bitstreams (DATA _TOPOLOGY) based on some embodiments. Table 5.

[0339] Table 6 illustrates examples of data location attribute bitstreams according to some embodiments. Table 6.

[0340] Table 7 illustrates example UV coordinate attribute bitstreams according to some embodiments. Table 7.

[0341] performance.

[0342] The performance of an example embodiment of overall compression as described in the context of V-DMC is compared with comparable compression using GoogleDraco. See the figure for the results, which illustrates the compression gain for the underlying trellis coding. Figure 55 The diagram illustrates the compression performance of the encoding method described in this paper, compared to Google Draco, for the base grid in V-DMC. Results for each CTC test sequence are individually averaged over 300 frames. PSNR is not presented because it is unaffected. The results show an overall average gain of 5.4% compared to the Draco rate.

[0343] Example system hardware.

[0344] Example embodiments of configuring encoders and / or decoders (collectively, encoders) to implement the embodiments described herein may use, for example, Figure 56 The system is implemented through the system. Figure 56This is a block diagram illustrating examples of systems implementing various aspects and embodiments. System 1000 may be embodied as a device including the various components described below and configured to perform one or more of the aspects described in this document. Examples of such devices include, but are not limited to, various electronic devices such as personal computers, laptop computers, smartphones, tablet computers, digital multimedia set-top boxes, digital television receivers, personal video recording systems, connected home appliances, and servers. Elements of system 1000 may be embodied individually or in combination in a single integrated circuit (IC), multiple ICs, and / or discrete components. For example, in at least one embodiment, the processing and encoder / decoder elements of system 1000 are distributed across multiple ICs and / or discrete components. In various embodiments, system 1000 is communicatively coupled to one or more other systems or other electronic devices via, for example, a communication bus or through dedicated input and / or output ports. In various embodiments, system 1000 is configured to implement one or more of the aspects described in this document.

[0345] System 1000 includes at least one processor 1010 configured to execute instructions loaded thereon for implementing, for example, the various aspects described herein. Processor 1010 may include embedded memory, input / output interfaces, and various other circuitry as known in the art. System 1000 includes at least one memory 1020 (e.g., a volatile memory device and / or a non-volatile memory device). System 1000 includes a storage device 1040, which may include non-volatile memory and / or volatile memory, including but not limited to electrically erasable programmable read-only memory (EEPROM), read-only memory (ROM), programmable read-only memory (PROM), random access memory (RAM), dynamic random access memory (DRAM), static random access memory (SRAM), flash memory, disk drives, and / or optical disk drives. As a non-limiting example, storage device 1040 may include internal storage devices, additional storage devices (including removable and non-removable storage devices), and / or network-accessible storage devices.

[0346] System 1000 includes an encoder / decoder module 1030 configured to, for example, process data to provide encoded or decoded video, and the encoder / decoder module 1030 may include its own processor and memory. The encoder / decoder module 1030 represents one or more modules that can be included in a device to perform encoding and / or decoding functions. As is known, a device may include one or both encoding and decoding modules. Furthermore, the encoder / decoder module 1030 may be implemented as a separate element of system 1000, or it may be incorporated within processor 1010 as a combination of hardware and software as known to those skilled in the art.

[0347] Program code loaded onto processor 1010 or encoder / decoder 1030 to execute the various aspects described in this document may be stored in storage device 1040 and subsequently loaded onto memory 1020 for execution by processor 1010. According to various embodiments, one or more of processor 1010, memory 1020, storage device 1040, and encoder / decoder module 1030 may store one or more of various entries during the execution of the processes described in this document. Such stored entries may include, but are not limited to, input video, decoded video or portions of decoded video, bitstreams, matrices, variables, and intermediate or final results from the processing of equations, formulas, operations, and operational logic.

[0348] In some embodiments, the memory within the processor 1010 and / or encoder / decoder module 1030 is used to store instructions and provide working memory for processing required during encoding or decoding. However, in other embodiments, external memory (e.g., the processing device may be the processor 1010 or the encoder / decoder module 1030) is used for one or more of these functions. The external memory may be memory 1020 and / or storage device 1040, such as volatile memory and / or non-volatile flash memory. In several embodiments, external non-volatile flash memory is used to store, for example, the operating system of a television. In at least one embodiment, a fast external dynamic volatile memory, such as RAM, is used as working memory for video encoding and decoding operations, such as working memory for MPEG-2 (MPEG stands for Moving Picture Experts Group; MPEG-2 is also known as ISO / IEC 13818, and 13818-1 is also known as H.222, and 13818-2 is also known as H.262), HEVC (HEVC stands for High Efficiency Video Coding, also known as H.265 and MPEG-H Part 2), or VVC (Multi-Functional Video Coding, a new standard developed by JVET (Joint Video Experts Group)).

[0349] As indicated in block 1130, inputs can be provided to the components of system 1000 through various input devices. Such input devices include, but are not limited to, (i) an RF section that receives radio frequency (RF) signals transmitted over the air, for example by a broadcaster, (ii) a component (COMP) input terminal (or a collection of COMP input terminals), (iii) a universal serial bus (USB) input terminal, and / or (iv) a high-definition multimedia interface (HDMI) input terminal. Figure 1 Other examples not shown in C include synthetic videos.

[0350] In various embodiments, the input device of block 1130 has associated respective input processing elements as known in the art. For example, the RF section may be associated with elements suitable for: (i) selecting a desired frequency (also known as selecting a signal, or limiting the signal band to a band), (ii) down-converting the selected signal, (iii) further band-limiting to a narrower band to select, for example, a signal band that may be referred to as a channel in some embodiments, (iv) demodulating the down-converted and band-limited signal, (v) performing error correction, and / or (vi) demultiplexing to select a desired data packet stream. The RF section in various embodiments includes one or more elements performing these functions, such as frequency selectors, signal selectors, band limiters, channel selectors, filters, downconverters, demodulators, error correctors, and demultiplexers. The RF section may include a tuner performing various functions among these functions, including, for example, down-converting a received signal to a lower frequency (e.g., intermediate frequency or near-baseband frequency) or baseband. In one set-top box embodiment, the RF section and its associated input processing elements receive RF signals transmitted via a wired (e.g., cable) medium and perform frequency selection by filtering, down-converting, and re-filtering to a desired frequency band. Various embodiments rearrange the order of the aforementioned (and other) elements, remove some of these elements, and / or add other elements that perform similar or different functions. Adding elements may include inserting elements between existing elements, such as, for example, inserting amplifiers and analog-to-digital converters. In various examples, the RF section includes an antenna.

[0351] Furthermore, the USB and / or HDMI terminals may include their respective interface processors for connecting the system 1000 to other electronic devices across USB and / or HDMI connections. It should be understood that various aspects of input processing (e.g., Reed Solomon error correction) can be implemented as needed, for example, within a separate input processing IC or within the processor 1010. Similarly, aspects of USB or HDMI interface processing can be implemented as needed, either within a separate interface IC or within the processor 1010. Demodulated, error-corrected, and demultiplexed streams are provided to various processing elements, including, for example, the processor 1010 and the encoder / decoder 1030, to operate in conjunction with memory and storage elements to process the data streams as needed for presentation on the output device.

[0352] Various components of system 1000 can be housed within an integrated housing. Within the integrated housing, various components can be interconnected and transmit data between them using a suitable connection arrangement 1140 (e.g., internal buses as known in the art, including inter-IC (I2C) buses, wiring, and printed circuit boards).

[0353] System 1000 includes a communication interface 1050 that enables communication with other devices via a communication channel 1060. The communication interface 1050 may include, but is not limited to, a transceiver configured to transmit and receive data via the communication channel 1060. The communication interface 1050 may include, but is not limited to, a modem or network interface card (NIC), and the communication channel 1060 may be implemented, for example, in a wired and / or wireless medium.

[0354] In various embodiments, a wireless network, such as a Wi-Fi network (e.g., IEEE 802.11, where IEEE refers to the Institute of Electrical and Electronics Engineers), is used to stream or otherwise provide data to system 1000. In these embodiments, the Wi-Fi signal is received via a communication channel 1060 and a communication interface 1050 suitable for Wi-Fi communication. The communication channel 1060 in these embodiments is typically connected to an access point or router that provides access to external networks, including the Internet, to allow streaming applications and other over-the-top communications. Other embodiments use a set-top box to provide streaming data to system 1000, delivering data via an HDMI connection of input block 1130. Still other embodiments use an RF connection of input block 1130 to provide streaming data to system 1000. As indicated above, various embodiments provide data in a non-streaming manner. Furthermore, various embodiments use wireless networks other than Wi-Fi, such as cellular networks or Bluetooth networks.

[0355] System 1000 can provide output signals to various output devices, including display 1100, speaker 1110, and other peripheral devices 1120. Display 1100 in various embodiments includes one or more of, for example, a touchscreen display, an organic light-emitting diode (OLED) display, a curved display, and / or a foldable display. Display 1100 can be used in televisions, tablets, laptops, cellular phones (mobile phones), or other devices. Display 1100 can also be integrated with other components (e.g., integrated into a smartphone) or separate (e.g., an external monitor for a laptop). In various examples of embodiments, other peripheral devices 1120 include one or more of a standalone digital video disc (or digital multifunction disc) (for both terms, DVR), disc player, stereo system, and / or lighting system. Various embodiments utilize one or more peripheral devices 1120 that provide functionality based on the output of system 1000. For example, a disc player performs the function of playing the output of system 1000.

[0356] In various embodiments, signaling, such as AV.Link, Consumer Electronics Control (CEC), or other communication protocols that enable device-to-device control with or without user intervention, is used to communicate control signals between system 1000 and display 1100, speaker 1110, or other peripheral devices 1120. Output devices can be communicatively coupled to system 1000 via dedicated connections through their respective interfaces 1070, 1080, and 1090. Alternatively, output devices can be connected to system 1000 via communication interface 1050 using communication channel 1060. Display 1100 and speaker 1110 can be integrated into a single unit with other components of system 1000 in electronic devices such as, for example, televisions. In various embodiments, display interface 1070 includes a display driver, such as, for example, a timing controller (TCon) chip.

[0357] Display 1100 and speaker 1110 may alternatively be separate from one or more other components, for example, if the radio frequency portion of input 1130 is part of a separate set-top box. In various embodiments where display 1100 and speaker 1110 are external components, the output signal may be provided via a dedicated output connection, including, for example, an HDMI port, a USB port, or a COMP output.

[0358] The embodiments can be executed by processor 1010 or by computer software implemented by hardware or a combination of hardware and software. As a non-limiting example, the embodiments can be implemented by one or more integrated circuits. Memory 1020 can be of any type suitable for the technical environment and can be implemented using any suitable data storage technology, such as optical storage devices, magnetic storage devices, semiconductor-based storage devices, fixed-state memory, and removable memory, as non-limiting examples. As a non-limiting example, processor 1010 can be of any type suitable for the technical environment and can encompass one or more of microprocessors, general-purpose computers, special-purpose computers, and processors based on multi-core architectures.

[0359] Additional examples.

[0360] A mesh encoding method according to some embodiments includes: for a current face in the mesh having associated current face parameters (such as a face identifier), identifying at least one edge-adjacent face, each edge-adjacent face sharing one edge and two vertices with the current face; for at least a first edge-adjacent face among the edge-adjacent faces, identifying a first coded face associated with the first edge-adjacent face, wherein the first coded face is identified from a first face set, the first face set including a plurality of faces sharing at least one vertex with both the current face and the first edge-adjacent face, excluding any edge-adjacent face that is not the first edge-adjacent face; and encoding a first indication of whether the first adjacency face parameter associated with the first coded face is equal to the current face parameter. In some embodiments, a corresponding mesh decoding method is performed.

[0361] In some embodiments, the first indication is an indication that a first adjacent face parameter associated with the first coded face is not equal to the current face parameter. The method further includes: for a second edge-adjacent face in the edge-adjacent faces, identifying a second coded face associated with the second edge-adjacent face, wherein the second coded face is identified from a second face set, the second face set including a plurality of faces that share at least one vertex with both the current face and the first edge-adjacent face, excluding any edge-adjacent face that is not the second edge-adjacent face; and encoding a second indication of whether the second adjacent face parameter associated with the second coded face is equal to the current face parameter.

[0362] In some embodiments, the second indication is an indication that a second adjacent face parameter associated with the second coded face is not equal to the current face parameter. The method further includes: for a third edge adjacent face in the edge adjacent faces, identifying a third coded face associated with the second edge adjacent face, wherein the third coded face is identified from a third face set, the third face set including a plurality of faces that share at least one vertex with both the current face and the third edge adjacent face, excluding any edge adjacent face that is not the third edge adjacent face; and encoding a third indication of whether the adjacent face parameter associated with the third coded face is equal to the current face parameter.

[0363] In some embodiments, the third indication is an indication that a third adjacent surface parameter associated with the third coded surface is not equal to the current surface parameter, and the method further includes encoding the value of the current surface parameter.

[0364] Some embodiments further include identifying the most recently encoded face in the mesh; and encoding a fourth indication of whether a fourth parameter associated with the most recently encoded face is equal to the current face parameter.

[0365] In some embodiments, the first instruction is executed only in response to determining that the fourth parameter is not equal to the current face parameter.

[0366] In some embodiments, identifying a first coded face associated with the first edge adjacent face includes: traversing faces in the first set according to a predetermined order; and selecting the earliest coded face encountered according to the predetermined order as the first coded face.

[0367] In some embodiments, traversing faces in the first set according to a predetermined order includes: traversing the first edge-adjacent faces; in response to determining that the first edge-adjacent face is not encoded, traversing at least one face that shares a first vertex with both the current face and the first edge-adjacent face; and in response to determining that there are no encoded faces in the first set that have not yet been traversed, traversing at least one face that shares a second vertex with both the current face and the first edge-adjacent face. A similar search order can be used for other sets.

[0368] In some embodiments, the current face parameter is a face identifier.

[0369] In some embodiments, one or more of the first face set, the second face set, and the third face set exclude the most recently encoded face.

[0370] In some embodiments, identifying the first coded face associated with the first edge's adjacent face includes: traversing faces in the first set according to a predetermined order; and selecting the earliest encountered coded face in the predetermined order as the first coded face, rather than selecting the most recently coded face. Similar search techniques can be used for the second set and the third set.

[0371] In some embodiments, the first indication is encoded only in response to determining that the first encoded surface is not the most recently encoded surface. Similar conditions may be applied to the encoding of the second and third indications.

[0372] A mesh encoding method according to some embodiments includes encoding parameters of corresponding faces in a mesh using a set of vectors, the set of vectors including: a first vector (faceIdEqualToPrevious), which includes entries for each of a plurality of faces in the mesh, each entry in the first vector indicating whether the parameter of the corresponding face is equal to the parameter of the corresponding most recently encoded face; a second vector (faceIdIsRight), which includes entries for each face in the mesh, each face (1) not indicated by the first vector to have a parameter equal to the parameter of the corresponding most recently encoded face, and (2) having a valid first encoded face in a first set of faces associated with the corresponding face, each entry in the second vector indicating whether the parameter of the corresponding face is equal to the parameter of the corresponding first encoded face; and a third vector (faceIdIsLeft), which includes entries for each face in the mesh, each face (1) not indicated by the second vector to have a parameter equal to the parameter of the corresponding most recently encoded face. The third vector (faceIdIsForward) includes entries for each face in the grid, where each face (1) is not indicated by the third vector to have parameters equal to the parameters of the corresponding second coded face, and (2) has a valid second coded face in the set of second faces associated with the corresponding face, each entry in the third vector indicating whether the parameters of the corresponding face are equal to the parameters of the corresponding second coded face; and a fifth vector (notPredictedFaceId) includes entries for each face in the grid that is not indicated by the fourth vector to have parameters equal to the parameters of the corresponding third coded face, each entry in the fourth vector identifying the parameters of the corresponding face. In some embodiments, a corresponding grid decoding method is performed.

[0373] In some such embodiments, in response to determining that the coded face is the same as the most recently coded face, it is determined that the coded face in the first face set, the second face set, or the third face set is not a valid first coded face.

[0374] The example embodiments further include the following: a corresponding decoding technique; means including one or more processors configured to perform the methods described herein; means including at least one processor and a computer-readable medium storing instructions for performing the methods described herein; a computer-readable medium storing a grid encoded according to the methods described herein; and a signal conveying the grid encoded according to the methods described herein.

[0375] Note that the various hardware elements in one or more of the described embodiments are referred to as “modules” that perform (i.e., implement, execute, etc.) the various functions described herein in connection with the respective modules. As used herein, a module includes hardware (e.g., one or more processors, one or more microprocessors, one or more microcontrollers, one or more microchips, one or more application-specific integrated circuits (ASICs), one or more field-programmable gate arrays (FPGAs), one or more memory devices) that a person skilled in the art would consider suitable for a given implementation. Each described module may also include executable instructions for performing one or more functions described as being performed by the respective module, and note that such instructions may take the form of hardware (i.e., hardwired) instructions, firmware instructions, software instructions, and / or etc., or may include hardware (i.e., hardwired) instructions, firmware instructions, software instructions, and / or etc., and may be stored in one or more suitable non-transitory computer-readable media, such as commonly referred to as RAM, ROM, etc.

[0376] Although the features and elements have been described above in specific combinations, those skilled in the art will understand that each feature or element can be used alone or in any combination with other features and elements. Furthermore, the methods described herein can be implemented in a computer program, software, or firmware incorporated in a computer-readable medium for execution by a computer or processor. Examples of computer-readable storage media include, but are not limited to, read-only memory (ROM), random access memory (RAM), registers, cache memory, semiconductor memory devices, magnetic media (such as internal hard disks and removable disks), magneto-optical media, and optical media (such as CD-ROMs and digital multifunction discs (DVDs)). The processor associated with the software can be used to implement a radio frequency transceiver used in a WTRU, UE, terminal, base station, RNC, or any host computer.

Claims

1. A grid coding method, the grid coding method comprising: For a current face in the mesh that has associated current face parameters, identify at least one edge-adjacent face, each edge-adjacent face sharing one edge and two vertices with the current face; For at least a first edge-adjacent face among the edge-adjacent faces, a first coded face associated with the first edge-adjacent face is identified, wherein the first coded face is identified from a first face set, the first face set including a plurality of faces that share at least one vertex with both the current face and the first edge-adjacent face, excluding any edge-adjacent face that is not the first edge-adjacent face; and A first indication is encoded to determine whether the first adjacent surface parameter associated with the first coded surface is equal to the current surface parameter.

2. A mesh coding apparatus, the mesh coding apparatus comprising one or more processors configured to perform: For a current face in the mesh that has associated current face parameters, identify at least one edge-adjacent face, each edge-adjacent face sharing one edge and two vertices with the current face; For at least a first edge-adjacent face in the said edge-adjacent faces, a first coded face associated with the first edge-adjacent face is identified, wherein the first coded face is identified from a first face set, the first face set including a plurality of faces that share at least one vertex with both the current face and the first edge-adjacent face, excluding any edge-adjacent face that is not the first edge-adjacent face; and A first indication is encoded to determine whether the first adjacent surface parameter associated with the first coded surface is equal to the current surface parameter.

3. The method according to claim 1 or the apparatus according to claim 2, wherein, The first indication is an indication that the first adjacent surface parameter associated with the first coded surface is not equal to the current surface parameter, and the method further includes: For the second edge-adjacent face in the edge-adjacent faces, a second coded face associated with the second edge-adjacent face is identified, wherein the second coded face is identified from a second face set, the second face set including multiple faces that share at least one vertex with both the current face and the first edge-adjacent face, excluding any edge-adjacent faces that are not the second edge-adjacent face; and A second indication is encoded to determine whether the second adjacent surface parameter associated with the second encoded surface is equal to the current surface parameter.

4. The method according to claim 3, which is dependent on claim 1, or the apparatus according to claim 3, which is dependent on claim 2, wherein, The second indication is an indication that the second adjacent surface parameter associated with the second coding surface is not equal to the current surface parameter, and the method further includes: For the third edge-adjacent face in the edge-adjacent face, identify the third coded face associated with the second edge-adjacent face, wherein the third coded face is identified from a set of third faces, the set of third faces including multiple faces that share at least one vertex with both the current face and the third edge-adjacent face, excluding any edge-adjacent face that is not the third edge-adjacent face; and A third indication is encoded to determine whether the adjacent surface parameter associated with the third coded surface is equal to the current surface parameter.

5. The method according to claim 4, which is dependent on claim 1, or the apparatus according to claim 4, which is dependent on claim 2, wherein, The third indication is an indication that the third adjacent surface parameter associated with the third coded surface is not equal to the current surface parameter, and the method further includes encoding the value of the current surface parameter.

6. The method according to claim 1 or claims 3-5 which are dependent on claim 1, or the apparatus according to claim 2 or claims 3-5 which are dependent on claim 2, further comprising: Identify the most recently coded face in the mesh; as well as A fourth indication is encoded to determine whether the fourth parameter associated with the most recently encoded face is equal to the current face parameter.

7. The method according to claim 1 or the apparatus according to claim 2, wherein, The first coded surface associated with the first edge adjacent surface includes: Traverse the faces in the first set according to a predetermined order; and The earliest coded face encountered according to the predetermined order is selected as the first coded face.

8. A network decoding method, the network decoding method comprising: For a current face in the mesh that has associated current face parameters, identify at least one edge-adjacent face, each edge-adjacent face sharing one edge and two vertices with the current face; For at least a first edge-adjacent surface in the said edge-adjacent surfaces, identify a first decoded surface associated with the first edge-adjacent surface, wherein the first decoded surface is identified from a first set of surfaces, the first set of surfaces including a plurality of surfaces that share at least one vertex with both the current surface and the first edge-adjacent surface, excluding any edge-adjacent surface that is not the first edge-adjacent surface; and Decode a first indication of whether the first adjacent surface parameter associated with the first decoding surface is equal to the current surface parameter.

9. A network decoding apparatus, the network decoding apparatus comprising one or more processors configured to perform at least: For a current face in the mesh that has associated current face parameters, identify at least one edge-adjacent face, each edge-adjacent face sharing one edge and two vertices with the current face; For at least a first edge-adjacent surface among the said edge-adjacent surfaces, a first decoding surface associated with the first edge-adjacent surface is identified, wherein... The first decoded face is identified from a first set of faces, which includes multiple faces that share at least one vertex with both the current face and the first edge-adjacent face, excluding any edge-adjacent faces that are not the first edge-adjacent face; and Decode a first indication of whether the first adjacent surface parameter associated with the first decoding surface is equal to the current surface parameter.

10. The method according to claim 8 or the apparatus according to claim 9, wherein, The first indication is an indication that the parameter of the first adjacent surface associated with the first decoding surface is not equal to the parameter of the current surface, and the method further includes: For the second edge-adjacent surface in the edge-adjacent surfaces, a second decoded surface associated with the second edge-adjacent surface is identified, wherein the second decoded surface is identified from a second set of surfaces, the second set of surfaces including multiple surfaces that share at least one vertex with both the current surface and the first edge-adjacent surface, excluding any edge-adjacent surfaces that are not the second edge-adjacent surface; and Decode a second indication of whether the second adjacent surface parameter associated with the second decoding surface is equal to the current surface parameter.

11. The method according to claim 10, which is dependent on claim 8, or the apparatus according to claim 10, which is dependent on claim 9, wherein, The second indication is an indication that the second adjacent surface parameter associated with the second decoding surface is not equal to the current surface parameter, and the method further includes: For the third edge-adjacent surface in the edge-adjacent surface, identify the third decoded surface associated with the second edge-adjacent surface, wherein the third decoded surface is identified from a set of third surfaces, the set of third surfaces including multiple surfaces that share at least one vertex with both the current surface and the third edge-adjacent surface, excluding any edge-adjacent surface that is not the third edge-adjacent surface; and Decode a third indication of whether the adjacent surface parameter associated with the third decoding surface is equal to the current surface parameter.

12. The method according to claim 11, which is dependent on claim 8, or the apparatus according to claim 11, which is dependent on claim 9, wherein, The third indication is an indication that the third adjacent surface parameter associated with the third decoding surface is not equal to the current surface parameter, and the method further includes decoding the value of the current surface parameter.

13. The method according to claim 8 or claims 9-12 which are dependent on claim 8, or the apparatus according to claim 8 or claims 9-12 which are dependent on claim 8, further comprising: Identify the most recently decoded face in the mesh; as well as A fourth indication is decoded to determine whether the fourth parameter associated with the most recently decoded face is equal to the current face parameter.

14. The method according to claim 8 or the apparatus according to claim 9, wherein, The first decoding surface associated with the first edge adjacent surface includes: Traverse the faces in the first set according to a predetermined order; and The earliest decoder encountered according to the predetermined order is selected as the first decoder.

15. The method according to claim 14, which is dependent on claim 8, or the apparatus according to claim 14, which is dependent on claim 9, wherein, Traversing the faces in the first set according to the predetermined order includes: Traverse the adjacent surfaces of the first edge; In response to determining that the first edge-adjacent face has not been decoded, traverse at least one face that shares a first vertex with both the current face and the first edge-adjacent face; and In response to determining that there is no decoded face in the first set that has not yet been traversed, at least one face that shares a second vertex with both the current face and the first edge-adjacent face is traversed.

Images