Edgebreaker with face identifier compression

Abstract

Encoding and decoding of face parameters in a mesh. A mesh encoding method includes: for a current face in a mesh having an associated current-face parameter, identifying the edge-adjacent faces, each edge-adjacent face sharing an edge and two vertices with the current face; for at least a first edge-adjacent face, identifying a first encoded face associated with the first edge-adjacent face, wherein the first encoded face is identified from among a first set of faces, the first set of faces including the 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 encoding a first indication of whether a first adjacent-face parameter associated with the first encoded face is equal to the current-face parameter. In some embodiments, a most-recently-coded face may be excluded from the first set.

Description

EDGEBREAKER WITH FACE IDENTIFIER COMPRESSIONCROSS-REFERENCE

[0001] This application claims the priority of European Patent Application No. 23306292.6, filed 26 July 2023, entitled "Edgebreaker with Face Identifier Compression,” which is incorporated herein by reference in its entirety.BACKGROUND

[0002] The present disclosure relates to systems and methods for encoding and decoding a mesh based on edgebreaker technology. Edgebreaker is a technology that is capable of efficiently coding the connectivity of a triangular mesh. In its most straightforward implementation, a mesh encoded using edgebreaker is represented by an ordered series made up of the symbols, C, L, E, R, and S, called the "CLERS” sequence. Generally speaking, starting with an initial triangle, these symbols describe different ways to attach a new triangle, providing information on whether or how different edges of the new triangle are connected to one or more of the existing triangles. Edgebreaker technology is described in greater detail, for example in the following sources:• J. Rossignac, "3D compression made simple: Edgebreaker with ZipandWrap on a corner-table," in Proceedings International Conference on Shape Modeling and Applications, Genova, Italy, 2001 . Desribes decoding in a forward direction with the use of a corner table (CT) representation of the mesh, which leads to a very compact algorithm.• H. Lopes, G. Tavares, J. Rossignac, A. Szymczak and A. Safonova, "Edgebreaker: a simple compression for surfaces with handles.," in ACM Symposium on Solid Modeling and Applications,, Saarbrucken, 2002.• J. Rossignac, "Edgebreaker: Connectivity compression for triangle meshes," GVU center, Georgia Institute of Technology, 1999. Describes decoding in a forward direction using a half-edge representation.• J. Rossigniac, "Course on triangle meshes and corner table," 2006.• M. Isenburg and J. Snoeyink, "Spirale Reversi: Reverse decoding of the Edgebreaker encoding," Computational Geometry, vol. 20, pp. 39-52, 2001. Describes the "spiral reversi” technique, which uses a half edge representation, but performing the decoding in a reverse manner, which leads to faster decoding of O(n).

[0003] Following the MPEG V-Mesh (now renamed V-DMC) call for proposals the solution proposed by Apple was selected to become the foundation of the MPEG V-Mesh Test Model (TM). The proposal is described in K. Mammou, J. Kim, A. Tourapis and D. Podborski, "m59281 - [V-CG] Apple's Dynamic Mesh Coding CfP Response," Apple Inc, 2022. Summary figures from the proposal are provided in FIG. 1 and FIG. 2 of the present disclosure.

[0004] The test model, for some frames, uses a static mesh coder for the encoding of a base mesh that is then subdivided to obtain an approximation of the original mesh. Currently, the V-Mesh test model encodes a base mesh using the Google Draco implementation of an edgebreaker-based mesh encoder. Specifically, the implementation uses the "spirale reversi” version of edgebreaker as described in M. Isenburg and J. Snoeyink, "Spirale Reversi: Reverse decoding of the edgebreaker encoding," Computational Geometry, vol. 20, pp. 39-52, 2001.

[0005] While edgebreaker coding provides an efficient way to code the connectivity of a base mesh, it has certain limitations. For example, edgebreaker coding on its own is effective only for manifold surfaces whithout "holes” or "handles.” Additional processing is required to bring such non-manifold surfaces into a format that is capable of being coded using edgebreker technology. Moreover, edgebreaker coding on its own only codes for the connectivity of a mesh. The CLERS sequence itslef does not code additional properties of a mesh, such as the locations of the vertices and any other attributes of the vertices (such as color, normal direction, UV coordinates, and the like).SUMMARY

[0006] A mesh encoding method according to some embodiments comprises: for a current face in a mesh having an associated current-face parameter, identifying at least one edge-adjacent face, each edge- adjacent face sharing an edge and two vertices with the current face; for at least a first one of the edge- adjacent faces, identifying a first encoded face associated with the first edge-adjacent face, wherein the first encoded face is identified from among a first set of faces, the first set of faces 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 faces that are not the first edge-adjacent face; and encoding a first indication of whether a first adjacent-face parameter associated with the first encoded face is equal to the current-face parameter.

[0007] In some embodiments, the first indication is an indication that the first adjacent-face parameter associated with the first encoded face is not equal to the current-face parameter, the method further comprising: for a second one of the edge-adjacent faces, identifying a second encoded face associated with the second edge-adjacent face, wherein the second encoded face is identified from among a second set of faces, the second set of faces 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 faces that are not the second edge- adjacent face; and encoding a second indication of whether a second adjacent-face parameter associated with the second encoded face is equal to the current-face parameter.

[0008] In some embodiments, the second indication is an indication that the second adjacent-face parameter associated with the second encoded face is not equal to the current-face parameter, the method further comprising: for a third one of the edge-adjacent faces, identifying a third encoded face associatedwith the second edge-adjacent face, wherein the third encoded face is identified from among a third set of faces, the third set of faces 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 faces that are not the third edge-adjacent face; and encoding a third indication of whether an adjacent-face parameter associated with the third encoded face is equal to the current-face parameter.

[0009] In some embodiments, the third indication is an indication that the third adjacent-face parameter associated with the third encoded face is not equal to the current-face parameter, the method further comprising encoding a value of the current-face parameter.

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

[0011] In some embodiments, the first indication is performed only in response to a determination that the fourth parameter is not equal to the current-face parameter.

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

[0013] In some embodiments, traversing the faces in the first set according to the predetermined order comprises: traversing the first edge-adjacent face; in response to a determination 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 a determination that no encoded face has yet been traversed in the first set, traversing at least one face that shares a second vertex with both the current face and the first edge-adjacent face. Analogous search orders may be used for other sets.

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

[0015] In some embodiments, one or more of the first, second, and third sets of faces excludes the most- recently-coded face.

[0016] In some embodiments, identifying the first encoded face associated with the first edge-adjacent face comprises: traversing the faces in the first set according to a predetermined order; and selecting the earliest-encountered encoded face in the predetermined order, other than a most-recently-coded face, as the first encoded face. Analogous search techniques may be used for the second and third sets.

[0017] In some embodiments, the first indication is encoded only in response to a determination that the first encoded face is not a most-recently-coded face. Analogous conditions may be applied to encoding of the second and third indications.

[0018] A mesh encoding method according to some embodiments comprises encoding parameters of corresponding faces in a mesh using a set of vectors including: a first vector (faceldEqualToPrevious) including an entry for each of a plurality ef faces in the mesh, each entry in the first vector indicating whether the parameter of the respective face is equal to the parameter of a corresponding most-recently-coded face; a second vector (faceldlsRight) including an entry for each face in the mesh that (1) was not indicated by the first vector to have a parameter equal to the parameter of the corresponding most-recently-coded face, and (2) has a valid first encoded face in a first set of faces associated with the respective face, each entry in the second vector indicating whether the parameter of the respective face is equal to the parameter of the corresponding first encoded face; a third vector (faceldlsLeft) including an entry for each face in the mesh that (1) was not indicated by the second vector to have a parameter equal to the parameter of the corresponding first encoded face, and (2) has a valid second encoded face in a second set of faces associated with the respective face, each entry in the third vector indicating whether the parameter of the respective face is equal to the parameter of the corresponding second encoded face; a fourth vector (faceldlsForward) including an entry for each face in the mesh that (1) was not indicated by the third vector to have a parameter equal to the parameter of the corresponding second encoded face, and (2) has a valid third encoded face in a third set of faces associated with the respective face, each entry in the fourth vector indicating whether the parameter of the respective face is equal to the parameter of the corresponding third encoded face; and a fifth vector (notPredictedFaceld) including an entry for each face in the mesh that was not indicated by the fourth vector to have a parameter equal to the parameter of the corresponding third encoded face, each entry in the fourth vector identifying the parameter of the respective face.

[0019] In some such embodiments, an encoded face in the first, second, or third set of faces is determined not to be a valid first encoded face in response to a determination that the encoded face is the same as the most-recently-coded face.

[0020] Example embodiments further include the following: corresponding decoding techniques, apparatus comprising one or more processors configured to perform the methods herein, apparatus comprising at least one processor and a computer-readable medium storing instructions for performing the methods described herein, a computer-readable medium storing a mesh encoded according to the methods herein, and a signal conveying a mesh encoded according to the methods herein.BRIEF DESCRIPTION OF THE DRAWINGS

[0021] FIG. 1 is a functional block diagram of an example mesh encoding system.

[0022] FIG. 2 is a functional block diagram of an example mesh decoding system.

[0023] FIG. 3 illustrates an example of an edgebreaker mesh codec according to some embodiments.

[0024] FIG. 4 is a flow chart of an encoding process according to some embodiments.

[0025] FIG. 5 is a flow chart of a decoding process according to some embodiments.

[0026] FIG. 6 illustrates an example of a portion of a mesh illustrating information that may be stored in a corner table data structure.

[0027] FIG. 7 illustrates an example of an extended corner table to support UV coordinates attribute and normal vector attributes.

[0028] FIG. 8 illustrates an extended Corner Table data structure used in memory for the algorithmics.

[0029] FIG. 9 illustrates an example encoding entry point procedure.

[0030] FIG. 10 illustrates an example procedure preProcess for performing input model conversion, cleanup, filling, and quantization.

[0031] FIG. 11 illustrates the procedure encode, including edgebreaker topology coding and attribute predictions.

[0032] FIG. 12 illustrates an example procedure startcompression.

[0033] FIG. 13 illustrates the procedure compressRec.

[0034] FIG. 14 illustrates the procedure checkHandle.

[0035] FIG. 15 illustrates an example decoding entry point procedure.

[0036] FIG. 16 illustrates the procedure initDecompression, which allocates memory to store decompression outputs and initializes other marking tables.

[0037] FIG. 17 illustrates an example procedure startDecompression.

[0038] FIG. 18 illustrates the statement connectivitycompression.

[0039] FIG. 19 illustrates the example procedure decompressConnectivity.

[0040] FIG. 20 illustrates an example of the CheckHandle procedure to support shifts.

[0041] FIG. 21 illustrates the statement attributesDecompression.

[0042] FIG. 22 illustrates an example of the procedure DecompressVertices.

[0043] FIGs. 23-26 illustrates an example of the procedure decompressUvWithSeparatelndex., including statement A (FIG. 24), statement B (FIG. 25), and statement C (FIG. 26).

[0044] FIG. 27 illustrates an example of the procedure postProcess, which converts the reconstructed CT mesh into an indexed face set while removing the dummy points, and optionally recreates non-manifolds if lossless coding is used.

[0045] FIG. 28 illustrates side by side preProcess and postProcess procedures.

[0046] FIGs. 29A and 29B illustrate meshes with non-manifold vertices. FIG. 29C illustrates an example technique for fixing the issue by splitting the vertices.

[0047] FIG. 30 illustrates how two of the three surfaces that would result from duplicating the non-manifold vertices are fixed by re-stitching.

[0048] FIGs. 31A-31 D illustrate filtering of a non-manifold surface according to some embodiments. An example technique may be referred to as cutting and re-stitching.

[0049] FIG. 32 illustrates an example vertex duplication stage.

[0050] FIG. 33 illustrates an example pre-processing operation of re-stitching using the table of matched opposites.

[0051] FIGs. 34A-34B illustrate examples of the procedures deduplicateVertices and processDu plicate.

[0052] FIG. 35 illustrates an example of a process for regenerating a non-manifold surface by deduplicating some vertices.

[0053] FIG. 36 illustrates a process in an example embodiment in which a hole in the surface of a mesh is filled with a dummy vertex and dummy triangles.

[0054] FIG. 37 illustrates an example of a C++ procedure to fill all the holes of a mesh described as a corner table (O, V, OT, OTC).

[0055] FIGs. 38A-38C illustrate an example of a C++ procedure to fill a single hole of a mesh described as a corner table (O, V, OT, OTC).

[0056] FIGs. 39A-39B illustrate the prediction of attributes using main index table using a procedure such as encodeAtt ributes.

[0057] FIG. 40 illustrates an example of the predicate isCornerVertexDummy.

[0058] FIG. 41 illustrates a decoding counterpart procedure decodeAtt ributes.

[0059] FIG. 42 illustrates an example of the procedure posEncodeWithPrediction .

[0060] FIG. 43A illustrates a strategy for multi parallelogram prediction of corner c positions and dummy points filtering according to some embodiments.

[0061] FIG. 43B illustrates a strategy for min stretch prediction of corner c UV coordinates and dummy points filtering according to some embodients.

[0062] FIGs. 44A-44B illustrate an example of the procedure posDecodeWithPrediction.

[0063] FIGs. 45A-45B illustrate an example of the procedure uvEncodeWithPrediction .

[0064] FIGs. 46A-46B illustrates an example of the statement p red ictUV. dvec2 and dvec3 are double precision vectors.

[0065] FIG. 47A illustrates handling UV seams using only a main index table.

[0066] FIG. 47B illustrates handling of UVs with separate index table and selection strategy for the corner cpused for the prediction of UV coordinates with separate index for corner c.

[0067] FIGs. 48A-48B illustrate an example of the procedure encodeSepa ratelndexAtt ributes .

[0068] FIGs. 49A-49B illustrate examples of the procedure decodeSepa ratelndexAtt ributes.

[0069] FIG. 50 illustrates an example of the procedure save.

[0070] FIG. 51 illustrates an example of pseudo code to control the Dirac encoder for the CLERS table.

[0071] FIG. 52 provides an illustration reproducing part of the coding principle used for motion vectors in some embodiments.

[0072] FIG. 53 illustrates an example offset / shift for ExpGolomb coding.

[0073] FIG. 54 illustrates an example of code using arithmetic coding contexts for some embodiments.

[0074] FIG. 55 illustrates compression performance of an encoding method as described herein.

[0075] FIG. 56 is a block diagram of an example of a system in which various aspects and embodiments are implemented.

[0076] FIG. 57 illustrates an example implementation of one embodiment of dummy index removal.

[0077] FIG. 58 illustrates an example implementation of another more efficient embodiment of dummy index removal.

[0078] FIGs. 59A-59B illustrate an example procedure encodePerFaceAttributes.

[0079] FIG. 60 illustrates an example of Dirac AC entropy coding for coding of per-face material IDs.

[0080] FIGs. 61A-61C illustrate an example of search order for corner[0] = c (the operation is repeated for corner[1] = c.n then for corner[2] = c.p). FIG. 61 A illustrates a face for which an Id is to be coded and L,R,F adjacent triangles. (The three adjacent always exist since dummy points are used to fill holes.) FIG. 61 B illustrates lookup in neighborhood looping in a first direction over R, R1 , R2, etc. FIG. 61 C illustrates a subsequent lookup in the other direction.

[0081] FIG. 62 illustrates an example mesh during coding of a face identifier of a current face C.

[0082] FIG. 63 is a flow chart illustrating a face identifier encoding method according to some embodiments.

[0083] FIG. 64 illustrates another example mesh during coding of a face identifier of a current face C.

[0084] FIG. 65A-65B illustrates example code for one embodiment of a face identifier encoding method.

[0085] FIG. 66A-66B illustrates example code for one embodiment of a face identifier decoding method.

[0086] FIGs. 67A-67B illustrate encoding performance of the embodiment of FIGs. 65A-65B.DETAILED DESCRIPTIONOverview of example embodiments.

[0087] Edgebreaker (EB) is a technology for encoding and decoding (collectively "coding”) the topology (connectivity and handles) of the mesh, which is the core of the algorithm, and proposes the use of predictors for the positions of the vertices to generate some entropy coding efficient data.

[0088] Some embodiments of the present disclosure provide a full end-to-end extended version of the EB. Some embodiments include a complete syntax low-level for the bitstream and a more advanced syntax.

[0089] Example embodiments provide support of topology coding (connectivity and handles) and support of geometry with delta coding.

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

[0091] Some embodiments provide support for holes and boundaries, through "virtual” dummy points.

[0092] Some embodiments include a lossless mode that reconstructs meshes with bad "connectivity” at decoding if needed.

[0093] Some embodiments provide support for multiple connected components (CCs).

[0094] Some embodiments include support for texture coordinates encoding using a unique index table or separate index tables.

[0095] Some embodiments include multi-parallelogram and stretch predictions. Some such embodiments further provide support for dummy points and separate index tables when needed.

[0096] Some embodiments include Dirac and / or RANS arithmetic coders (ACs). Some such embodiments use a specific binarization scheme and arithmetic coding contexts as described herein for use with Dirac coding.

[0097] Some embodiments include support of pre-quantized input meshes in addition to input mesh quantization.

[0098] Some embodiments include support for per face identifiers or colors.

[0099] Some embodiments provide for optimization of per face attribute prediction and encoding.

[0100] FIG. 3 illustrates an example of an edgebreaker mesh codec according to some embodiments. The top row is the encoding line, and the bottom row is the decoding line. As illustrated in FIG. 3, example embodiments include some or all of the following. During encoding, pre-processing 302 may be used to clean potential connectivity issues (non-manifolds edges and vertices) that can exist on the input mesh. This cleanup is performed because the edgebreaker algorithm by itself does not work on meshes having such connectivity issues. In some embodiments, cleaning non manifold edges and vertices involves duplicating anumber of points. Some embodiments keep track of those duplicated vertices to merge those when decoding. This enables to reduce the number of points in the decoded mesh but calls for sending some additional information in the bitstream. In some embodiments, this pre-processing 302 further includes adding some dummy points to fill potential holes on the surface because the edgebreaker algorithm alone does not handle holes. Example embodiments operate to fill the holes before encoding and recreate the holes after decoding. Example embodiments use "virtual” dummy points and generate and encode dummy triangles attached to these dummy points, but the 3D positions of those points are not encoded or decoded. In some embodiments, the vertex attributes are quantized if needed. Those attributes can be provided to the coder already quantized.

[0101] Example embodiments encode the connectivity of the mesh at 304 using a modified version of the edgebreaker algorithm which generates a CLERS table (a table made of ‘C, ‘L’, ‘E’, ‘R’, and ‘S' symbols). This stage also generates some tables in memory that are used for the attribute prediction stage. The vertex attributes are then predicted at 306, starting by the position ones. Then, other attributes are predicted, eventually relying on the position predictions, which it is the case for the texture UV coordinates. Configuration and metadata are also provided in the bitstream, the CLERS table, some other connectivity and all the attribute prediction residuals are entropy coded at 310 and added to the bitstream.

[0102] In an example decoding method, all of the entropy coded sub-bitstreams are entropy decoded at 312. We reconstruct the mesh connectivity at 314 using the CLERS table and the edgebreaker algorithm. We also add some extra information to manage the handles, which describe the topology. We use the mesh connectivity as well as a minimal set of vertex positions expressed in 3D coordinates to predict all the other per-vertex positions at 316. We then apply the attribute residuals to correct the predictions and obtain the reconstructed vertex positions. The other attributes are also decoded at 316, potentially relying on decoded positions, as for UV coordinates. The connectivity of attributes using separate index tables is reconstructed using per a per edge binary seam information that is entropy coded.

[0103] In a post-processing stage at 320, the dummy triangles are removed. Optionally, the non-manifold issues are re-created in case the coder is configured to perform lossless coding. Optionally, the vertex attributes are dequantized if the model was quantized by encoder.

[0104] FIG. 4 is a flow chart of an encoding process according to some embodiments.

[0105] FIG. 5 is a flow chart of a decoding process according to some embodiments.Overview of corner tables.

[0106] A corner table data structure to represent a mesh is described in J. Rossignac, "3D compression made simple: Edgebreaker with ZipandWrap on a corner-table," in Proceedings International Conference onShape Modeling and Applications, Genova, Italy, 2001 ; and further described in J. Rossigniac, "Course on triangle meshes and corner table," 2006.

[0107] FIG. 6 illustrates a portion of a triangular mesh illustrating information that may be stored in a corner table (also referred to as an OV table). For each corner index c of a corner in the corner table, the notation c.v=3 identifies the index of the vertex at which that corner is located. The index c.t=0 is the index of the triangle that includes corner c. Within that triangle, the index c.n=0 identifies the next corner (in a counterclockwise direction), and c.p=1 identifies the previous corner. The index c.o identifies the corner that is opposite to the corner c. For example, in FIG. 6, corner c.o=5 is opposite corner c=2 (and vice versa). The index c.l identifies the corner to the left of corner c, and the index c.r identifies the corner to the right of corner c. The connectivity as shown in FIG. 6 may be recorded in a corner table with entries that include the following:

[0108] The "corner index” column does not need to be stored in the table because it corresponds to the position of each row within the table. The triangle index for each corner can be calculated as c.t = INT(c / 3)

[0109] Thus, corners 0, 1 , and 2 are all in the triangle with index 0; corners 3, 4, and 5 are all in the triangle with index 1 ; and so on. Additional relationships among entries in the corner table may be expressed as follows: c.n = 3c.t + (c+1) MOD 3 c.p = c.n.n c.l = c.p.o c.r = c.n.o

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

[0111] FIG. 7 illustrates an example of an extended corner table to support UV coordinates attribute and normal vector attributes, both using separate indexing tables, resp. TC / OTC and N / ON. Texture coorinates and normal vectors are stored in two other separate tables.

[0112] Example embodiments extend the corner table data structure to support other attributes with or without secondary attribute indices, as illustrated in FIG. 7. In case the mesh does not have separate indicesto dereference the UV coordinates attributes, example embodiments include a table of UV coordinates alongside the position table. The UV coordinates table is then dereferenced using V as for the position. Otherwise, some embodiments also add two tables TC and OTC to code the connectivity of (to dereference) the UV coordinates. TC is used to store UV coordinates indices and OTC to store the opposite corners for the UV connectivity. The same principle may be applied to add support for per vertex normal (N / ON / normal_vectors) or per vertex colors ( C / OC / colors ).

[0113] FIG. 8 illustrates an extended Corner Table data structure used in memory for the algorithmics. Using separate tables for each row of table depicted in FIG. 17 for more flexibility.

[0114] FIG. 8 summarizes the data structures we use to store all the information of our extended corner table. This approach can be extended for any per vertex attribute type, to use or not dedicated index tables modeled using the pair (index table / opposite table). Per face IDs are included in the table in this implementation.Overview of encoding procedures.

[0115] In this section we give some high-level procedures to better understand the structure and flow of an example encoding process.

[0116] An example encoding entry point procedure is depicted in FIG. 9. It includes three steps that perform respectively the pre-processing of the input mesh, its edgebreaker, encoding and finally the entropy coding and storage into the bitstream.

[0117] FIG. 10 illustrates an example procedure preProcess for performing input model conversion, cleanup, filling, and quantization. The features of this procedure will be provided in further detail below. It is introduced here for global understanding before introducing the edgebreaker encoding hereafter. The save procedure, depicted in FIG. 25, will also be described in further detail below.

[0118] FIG. 11 illustrates the procedure encode, including edgebreaker topology coding and attribute predictions. Features described in particular detail herein are shown in bold lettering. This procedure first initializes some data structures, it mainly allocates some tables for marking attributes or triangles and a table G_est to store the estimations (predicted) of the position attributes. It then run the edgebreaker algorithm on each connected component (CC) of the mesh. To do so we add the while loop in the procedure and manage some start indices for the handles that we update for each new component. After coding of one CC we run the procedure f indRestartCorner to check if there exists a non-marked corner in the NIC table (i.e. not coded yet) that we can use as the entry corner for the coding of a new CC.

[0119] Some example embodiments support meshes with multiple connected components. In one example embodiment, a method includes encoding a first connected component of a mesh with edgebreaker coding; after encoding the first connected component of the mesh, identifying an uncoded corner in the mesh;and encoding a second connected component of the mesh using the identified uncoded corner as an entry corner.

[0120] FIG. 12 illustrates an example procedure startcompression. Features described in particular detail herein are shown in bold lettering. This procedure is the actual edgebreaker algorithm starting point to encode a CC. It encodes the first triangle then starts the recursive encoding of the CC. The method includes the recording of processed corners into the table named processedCorners. This table is used later to handle attributes with separate index table. We also add a specific procedure, encodeSeparatelndexAttributes, at the end of the process to encode / predict the attributes that have separate index tables. This last procedure exploits the processedCorners table to perform its processing .

[0121] The encodeAttributes, and the encodeSeparatelndexAttributes, and the encodePerFaceAttributes procedures are described in further detail below. They basically perform attribute predictions and store the results on some tables that will be entropy encoded afterward. Note for now that the encodeAttributes procedure computes the predictions, for the attributes using the primary index table, for the given corner.

[0122] FIG. 13 illustrates the procedure compressRec. The table oClers is the output table of CLERS symbols. Features described in particular detail herein are shown in bold lettering. This procedure is the core edgebreaker algorithm to encode a CC. Processed corners are added into the table named processedCorners.

[0123] FIG. 14 illustrates the procedure checkHandle.

[0124] Given the foregoing description of how to construct the CLERS and Handles table at the encoding stage, the following description describes example embodiments for reconstructing, at decoding, the mesh topology from those tables to recreate the corner table.Overview of decoding procedures.

[0125] FIG. 15 illustrates an example decoding entry point procedure. Features described in particular detail herein are shown in bold lettering. The procedure includes several steps that perform respectively the syntax parsing and arithmetic decoding of the input bitstream, its edgebreaker decoding using a corner table and finally some post-processing one the corner table to produce the final mesh in an indexed face set data structure. In this section we will only devise the edgebreaker decoding procedures (initDecompression and startDecompression ) and the sub-procedures related to topology decoding. Parsing and entropy decoding will be described in further detail below.

[0126] FIG. 16 illustrates the procedure initDecompression, which allocates memory to store decompression outputs and initializes other marking tables. Features described in particular detail herein areshown in bold lettering. In the initDecompression procedure, a "start” is a point for which there is no prediction, hence its attributes are stored in a separate table containing global values (sVertices, sUVCoords). In counterpart, attributes that are predicted are stored in other input tables iVertices and iUVCoords. Those tables will be described further below.

[0127] The present section describes example tables that are used for the topology decoding (V, 0, TC, OTC, D, M, U, MTC and duplicatedlndexRemapping) . The values that are used to initialize 0, TC, OTC and D are recorded since those conditions are used to permit the proper execution of the algorithm later on. Example embodiments include tables to handle the texture coordinate attributes (which are extended the same way in some embodiments for normal and colors per vertex), the attributes with separate index tables (see hasSeparateUvIndex statement) and finally the deduplication remapping table. We also added the handling of dummy point.

[0128] FIG. 17 illustrates an example procedure startDecompression. Features described in particular detail herein are shown in bold lettering. The procedure startDecompression, which starts the decoding, is invoked following initDecompression initialization stage.

[0129] Example embodiments provide for the handling of CCs using offsets. Then, for each CC, after the connectivityDecompression and the attributesDecompression stages, the vertex indices and UV coordinates indices are shifted back to make them valid in the global index space. This process may also be extended in some embodiments to any other attribute types. Example embodiments further include a deduplication post processing which will be described in further detail below.Decoding connectivity recursion.

[0130] FIG. 18 illustrates the statement connectivitycompression. Features described in particular detail herein are shown in bold lettering. The connectivityDecompression statement presented in FIG. 18 may be inserted in place in the pseudocode of FIG. 17 so it accesses the setup variables. The statement is executed for each CC. In this logical block, the algorithm initializes the opposite corners of the CC handles using techniques such as those described in H. Lopes, G. Tavares, J. Rossignac, A. Szymczak and A. Safonova, "Edgebreaker: a simple compression for surfaces with handles.," in ACM Symposium on Solid Modeling and Applications, Saarbrucken, 2002. Example embodiments further add the first corner (of index 0) in the table of processedCorners. We finally reconstruct the connectivity of the first triangle and start the connectivity decompression recursion, described with reference to FIG. 19.

[0131] FIG. 19 illustrates the example procedure decompressConnectivity. Features described in particular detail herein are shown in bold lettering. In example embodiments, the decompressConnectivity procedure supports shifts to manage CCs, and the procedure includes the history recording for the processed corners. The procedure further provides support for opposite corners tosupport handles using, for example, techniques described in H. Lopes, G. Tavares, J. Rossignac, A. Szymczak and A. Safonova, "Edgebreaker: a simple compression for surfaces with handles," in ACM Symposium on Solid Modeling and Applications,, Saarbrucken, 2002.

[0132] FIG. 20 illustrates an example of the CheckHandle procedure to support shifts. The Zip procedure makes use of the shifted tables 0 and G (the code is not presented here).

[0133] At the end of the connectivityDecompression statement (see FIG. 17), the connectivity is reconstructed and can be used together with the predicted attributes residuals that were previously entropy decoded to reconstruct / estimate the attributes. This next step is described in the following section.Decoding attributes recursion.

[0134] FIG. 21 illustrates the statement att ributesCompression. The att ributesDecompression statement may be inserted in place in the pseudocode of FIG. 17 so it accesses the setup variables. The statement is executed for each CC. In this logical block, we first reconstruct the attributes of the first triangle using decodeAtt ributes and recursively reconstruct the attributes of the other triangles by calling decompressVertices. This first step only works on attributes using the main index table.

[0135] In a second recursion we optionally reconstruct the attributes dereferenced by secondary index tables. Those are implemented after the first recursion has terminated before being processed because they rely on its output data. The presented code illustrates the second step for UV coordinates, invoking the decompressUvWithSepa ratelndex procedure. Extension to other types of per-vertex attributes such as normal vectors or color per vertex is also performed in some embodiments. The prediction scheme at lower level is adjusted accordingly.

[0136] Some embodiments further include a third recursion in which the per face attributes are reconstructed, as described in further detail below.

[0137] FIG. 22 illustrates an example of the procedure DecompressVertices. The procedure uses shifted tables to handle CCs. The recursion goes through the triangle tree and reconstruct the attributes when needed by invoking the decodeAtt ributes procedure.

[0138] FIG. 23 illustrates an example of the procedure decompressUvWithSeparatelndex . It behaves differently from decompressVertices by handling the texture seams using the secondary index tables, TC and OTC.

[0139] The procedure is decomposed in three successive statements; statement A, shown in FIG. 24; statement B, shown in FIG. 25, and statement C, shown in FIG. 26. Each one of these performs a loop on the processedCorners . In some embodiments, the order of corners is implicitly found as in thedecompressVertices procedure, in which case the processedCorners table may not be necessary. However, the table is shown in this example for ease of coding and explanation.

[0140] With reference to FIG. 24, using the iSeams table (that comes from the bitstream), the recursion of statement A first assigns a code in [0, -1 , -2] to each corner of the OTC table to identify if they are on a seam or if UV coordinates will be identical 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 eventual dummy points inside this loop. It is not necessary to reconstruct a full opposite table OTC (in the sense of connectivity as for table 0), the table may be used only to store the codes for statement B.

[0141] With reference to FIG. 25, in a second pass, the recursion of statement B exploits the codes from pass A to assign the UV coordinate indices to the corners by swinging around those. This pass populates the table TC with the UV indices. During the loop, corners already visited or associated with dummy points are skipped.

[0142] In a final pass, with reference to FIG. 26, the recursion from statement C computes the final UV coordinates using the TC table and the MTC table to mark the UV coordinates already processed. If the bitstream was coded without predictions (cfg . uvPred=NONE), the value of the table iUVcoords is copied as is into the UV table using the CC shift. Otherwise, the UV coordinates are predicted using the uvSepDecodeWithPredictionExt procedure as described below.Decoding post-processing.

[0143] At the end of the startDecompression procedure, as described in FIG. 15, the connectivity and the attributes are decoded. In some embodiments, additional post processing steps are performed to finalize the mesh. The postProcess procedure is depicted in FIG. 27. The different parts of this procedure are described below symmetrically to the preProcess procedure (see FIG. 28).

[0144] FIG. 27 illustrates an example of the procedure postProcess, which converts the reconstructed CT mesh into an indexed face set while removing the dummy points, and optionally recreates non-manifolds if lossless coding is used.

[0145] Example pre-processing and post processing steps are shown in more detail in the following section.Pre-processing and post-processing.

[0146] In some embodiments, pre-processing is performed to convert some standard indexed face set mesh into a corner table representation for efficient use by the edgebreaker algorithm optimized to run on corner table. An indexed face set mesh is also known as face-vertex mesh. Those are traditionally stored into “.obj”, ".ply” or other common file formats that store triangle meshes. The face-vertex representation is also the one that is ingested by graphics hardware for rendering. Converting to a corner table may beperformed using known techniques. However, while converting to the CT representation, example embodiments also perform the filtering of non-manifold vertices and edges, as described below. Example embodiments also introduce virtual dummy points and dummy faces to fill eventual holes of the input mesh, as described below. Symmetrically, at the decoding, the eventual dummy points are removed, and the nonmanifold connectivity is re-created in case of lossless mode. FIG. 28 presents an overview of example pre and post processes side by side. Quantizing and dequantizing processes may be performed using standard uniform quantization mechanisms. In some embodiments, quantizing and dequantizing are not performed, for example in embodiments that code pre-quantized meshes (e.g. meshes with all integer attributes).

[0147] FIG. 28 illustrates side by side preProcess and postProcess procedures. The comments and captions of FIGs. 10 and 27 provide additional details respectively on pre- and post-processing. In some embodiments, optional actions for deduplicates are also performed during the pre-processing within the fixNonManifold procedure.Non-manifold filtering.

[0148] Some meshes, coming from 3D reconstruction from scanners for instance, may have some "incorrect” connectivity in the sense that it does not have a manifold topology that can be processed using standard edgebreaker coding. For example, the surface described by the triangles may be non-manifold at some vertices or edges and thus subject to processing as shown in FIGs. 9 and 10. The purpose of the filtering is to fix those issues to allow for edgebreaker coding. In some embodiments, this is performed by duplicating selected vertices so the triangles sharing a non-manifold edge or vertex do not share the same edge or vertex anymore.

[0149] FIGs. 29A and 29B illustrate meshes with non-manifold vertices. FIG. 29C illustrates an example technique for fixing the issue by splitting the vertices.

[0150] In the example of FIG. 29A, one vertex (say, of index in the vertex table) is shared by the two triangles but those triangles do not share any edge (hence, the vertex is non-manifold). Example embodiments fix this non-manifold issue by duplicating the common vertex, creating a new vertex with the same 3D position and same attributes, this new vertex will be added to the vertex table and be of index inin this table. In this case, one face description refers to and the second to in. After processing, the faces are not connected any more so, there will not be a non-manifold issue. In the present example it will result into two connected components (CC), each one made of only one triangle (a "connected component” is a set of triangles for which there always exists a path on connectivity to reach other triangles of the component). By doing this duplication, we see that we may generate multiple connected components,.

[0151] When the approach for fixing non-manifold vertices is applied to non-manifold edges, some surface continuity issues can arise. With reference to FIG. 30, a single non-manifold edge, extending betweenvertices i1 and i2, is shared by three triangles T1 , T2, and T3. If the vertices of the non-manifold edge were to be duplicated, the faces will not be connected anymore. If the face T1 and T2 were part of a larger connected component, this would introduce a "crack” in the surface of the mesh. In addition, duplicating all those vertices introduces more vertex data to encode. As illustrated in FIG. 30, two of the three surfaces that would result from duplicating the non-manifold vertices are fixed by re-stitching.

[0152] FIGs. 31A-31 D illustrate filtering of a non-manifold surface according to some embodiments. An example technique may be referred to as cutting and re-stitching. As shown in FIG. 31 A, triangle connectivity on a non-manifold edge 3102 is cut by resetting opposite corners to -2 (or to another predetermined value as appropriate). As shown in FIG. 31 B, vertices are duplicated if needed. (For the sake of clarity, duplicated vertices are shown here in a slightly offset position, but in an example embodiment, the positions of the duplicated vertices are the same.) As shown in FIG. 31 C, the process swings right and left from the visited corner c. As shown in FIG. 31 D, opposite corners are re-stitched when left vertex index Iv equals right vertex index rv and ol = o2 = — 2 .

[0153] Some example embodiments perform a vertex duplication operation to remove one or more non- manifold edges. Subsequently, a pre-processing step is performed that fixes the newly introduced holes when possible through a re-stitching process. This reduces or eliminates the need to handle specific cases during the rest of the process, which simplifies the implementation of edgebreaker and reduces the number of dummy points, the number of UV seams (since a geometry seam necessarily introduces a texture seam) and impact on the edgebreaker.

[0154] In some embodiments, such a method may be performed as follows, identifying at least one non- manifold edge in a mesh; duplicating vertices along the non-manifold edge to separate the non-manifold edge into at least two manifold edges; stitching together two of the at least two manifold edges; and after stitching together two of the at least two manifold edges, encoding the mesh using edgebreaker coding.

[0155] In some embodiments, the non-manifold filtering stage (illustrated by FIGs. 31 A-31 D) occurs during the pre-processing as follows. The mesh is filtered for non-manifold surfaces. The triangle connectivity of non-manifold surfaces is cut by re-setting the O table for some corners, setting the O value to -2 at appropriate corners. Vertices are duplicated if needed. Triangle connectivity is re-stitched if appropriate by amending the O table. The filtering of non-manifold surfaces may be performed using known techniques, such as in the Google Draco system. In example embodiments, a "re-stitch” stage is performed to reconnect some triangles. This also allows for re-creating a non-manifold surface in case of lossless coding. Example embodiments further include a stage of duplicating vertices. The "duplicate vertices” stage is depicted in FIG. 32. Features described in particular detail herein are shown in bold lettering. The bolded features include features for handling de-duplicates for lossless mode and for re-stitching. To summarize, example embodiments keep track of the index of added vertices (for the lossless case) and store a table of pairs ofcorners to "re-stitch” those at the end of the process in a last pass as shown in FIG. 31 C and FIG. 33. FIG. 33 illustrates an example pre-processing operation of re-stitching using the table of matched opposites.Non-manifold filtering, lossless case.

[0156] In some embodiments, lossless coding of the input mesh is performed to reproduce exactly the connectivity, including the non-manifold issues. As shown in the previous section, example embodiments keep track of inserted (duplicated) vertices and the original vertices (referred to here as parents of the inserted vertices) in a table during the pre-processing. Some data representing those duplicates is provided in the bitstream and then used during the decoding (at several stages) to reconstruct the exact connectivity if needed.

[0157] The availability of a lossless mode for connectivity as described herein provides at least two benefits. First, it allows for a fully lossless coding mode for both connectivity and attributes. Second, in some cases, lossless coding of the mesh allows for higher coding gains even when lossy coding is used for the mesh as a whole (e.g. for the attributes). These gains may be the result of avoiding replicated vertices during the subdivision process of the coding and then for the displacements coding. The lossless coding of the mesh may also enhance the motion coding.

[0158] An example encoding method includes: identifying at least one non-manifold edge in a mesh, the non-manifold edge being defined by parent vertices; preprocessing the mesh by duplicating parent vertices along the non-manifold edge to separate the non-manifold edge into at least two manifold edges, each manifold edge being defined by child vertices, each child vertex being duplicated from a respective parent vertex; encoding the preprocessed mesh into a bitstream using edgebreaker coding; and providing in the bitstream information identifying, the parent vertex of the child vertices.

[0159] An example decoding method includes: obtaining from a bitstream information defining a plurality of connected components of an edgebreaker-coded non-manifold mesh; obtaining from the bitstream information associating child vertices with parent vertices; at least partially decoding at least two of the connected components, each of the connected components having child vertices associated with respective parent vertices; and deduplicating the child vertices to reconstruct the non-manifold mesh.

[0160] At the encoding stage, when positions are duplicated (potentially recursively) by the non-manifold filtering, example embodiments keep track of vertices having the same original parent. A unique identifier (e.g. ranging from 1 to the number of vertices ultimately added) is assigned to each vertex index that is associated with a vertex that has been duplicated. This information may be stored for instance in a map of duplicates (duplicatesMap) with each entry associating such an identifier with a duplicated vertex index. To populate the map of duplicates, when a vertex is added to the map, it is determined whether the parent is already in the map. In one case, the parent was already in the map, associated with a unique identifier. Inan alternative case, both the parent and the added vertex are added to the map, associating those with a new identifier (which may be the current number of split vertices).

[0161] The number of split vertices is the number of original position indices that are duplicated in the process. The total number of entries in the duplicatesMap map at the end of the process is (num split vertices + num added vertices).

[0162] When the topology is traversed during encoding of the attributes using main index table (see FIG. 37), when split or added vertices are encountered, registration is performed of the processed corner index and the corresponding unique split vertex index. Some embodiments us an oDuplicateSymbolIdx array, which stores the processed corner index, and an oDuplicateSplitVertexIdx array which stores the unique split vertex index. As the processedCorners array is updated per triangle (and not for the two first vertices of any connected component), some embodiments additionally store Boolean values indicating if there is a duplicated vertex on the first two vertices of the first triangle of any connected component. Example embodiments thus additionally use an array of Booleans of size (2* connected components) named oDuplicatesOnSta rt.

[0163] Example embodiments then signal some or all of the following information in a bitstream:• The size of the oDuplicateSymbolIdx array = num split vertices + num added vertices• The integer array oDuplicateSymbolIdx of size oDuplicateSymbolIdx. (Of course, this or any other software-implemented feature described herein may be given a name other than the name used in this disclosure. For example, the integer array oDuplicateSymbolIdx may alternatively have a name such as perDuplicateProcessedCornerlndices). Some embodiments allow for up to three duplicates associated with the first processed corner index of any connected component (one corner for each of the three vertices of the first triangle of those). In some embodiments, this may be delta coded and inserted as a variable unsigned integer.• The integer array oDuplicateSymbolIdx of size oDuplicateSymbolIdx, which provides a unique value for each group of vertices duplicated from a parent vertex that has been split (including the original parent) encoded as variable such as an unsigned integer.• A Boolean array of size 2*(number of connected components), which may be coded using Dirac arithmetic coding coded as follows: o variable unsigned int for dup01_encoded_size the size in bytes of the d upOlBuffer containing AC encoded flags to signal duplication at positions 0 or 1 in each CC (2*nbCC bits before encoding) o dup01_encoded_size bytes containing the encoded buffer.

[0164] Alternatively or additionally, example embodiments signal some or all of the following information in a bitstream:• A Boolean indicating if the vertex is duplicated, per the "encodeAttributes” position procedure call.• Then a Boolean to indicate this is the first occurrence.• If not first occurrence, the index of parent split vertex in a table of base split vertices.

[0165] In some embodiments, that information is arithmetically encoded. The amount of information encoded in the stream may be reduced using this approach when there is many split (this would have to be checked). In addition, the Boolean array (a) could be encoded only for CCs containing duplicated vertices, adding another level of indirection where a first string of bits should define which CCs includes duplicated vertices, but would reduce the size of the (a) array removing potentially ranges with constant false value.

[0166] In some embodiments, a determination is made of which encoding method results in the smallest bitstream, the mesh is encoded using that selected method, and an indication of the method used is signaled in the bitstream.

[0167] In some embodiments, to prevent encoding duplicated positions two or more times, the process returns from encodeAttributes without computing related residuals in response to a determination that a duplicated vertex has already been processed. The corresponding function is also performed in the decoder. Such embodiments are particularly useful for improving performance in the case of meshes with many splits.

[0168] The position topology of the input mesh is losslessly reproduced after encoding / decoding when using this deduplicate option. In some embodiments, the same technique is used to enable deduplication of attributes.

[0169] At the decoder side, the decoder obtains data such as iDuplicatesOnStart, iDuplicateSymbolIdx, iDuplicateSplitVertexIdx, and cornerindex (which may alternatively be called currentDuplicatelndex or any other arbitrary name).

[0170] During decoding (see FIG. 17) an update is performed inside the deduplicateVertices procedure (see FIG. 34), and the index of the processed corner (adding offsets per CC as processedCorners is emptied after each CC). The decoder may then check whether the current corner is associated with a duplicate vertex (including the additional checks for the two first vertices of each CC, or using alternative techniques). The decoder then assigns a single index to each of the duplicated vertices in the processDuplicate procedure. FIGs. 34A-34B illustrate examples of the procedures deduplicateVertices and processDuplicate. When first called with a given split vertex index, the current vertex index is associated to the split vertex index. On subsequent calls with a given split vertex index, the registered index corresponding to the first occurrence of the duplicated vertex is used to replace the duplicated index. Before the conversion of the CT to an indexed face set, this data is used to regenerate the non-manifolds by de-duplicating some vertices. An example of this process is illustrated in FIG. 35.Virtual dummy points for meshes with boundaries.

[0171] FIG. 36 illustrates a process in an example embodiment in which a hole 3602 in the surface of a mesh is filled with a dummy vertex inand dummy triangles. The value inis the index of the dummy point in the vertex table.

[0172] One known method of handling meshes with boundaries (also named meshes with holes) is to fill each hole with a dummy point and connect this new vertex to the border of the hole using a fan of triangles. The mesh is then encoded / decoded as if no hole was present. Some data to express which points are dummy is encoded in the bitstream so the point and its associated dummy triangles (from the fan) can be removed after the decoding. In such techniques, the dummy points are generally encoded using fake attribute values (usually from interpolation).

[0173] In example embodiments of the present disclosure, a process of filling holes with dummy points is performed after non-manifold filtering because the non-manifold filtering may itself introduce holes in the surface. Furthermore, example embodiments track the indices of dummy points and do not encode attributes (e.g. position, UV coordinates, color, etc.) of the dummy points. Example embodiments thus do not use fake attributes of the dummy points when predicting the attributes of non-dummy points.

[0174] In an example embodiments, dummy triangles are encoded but not the attributes (position, UV cords, etc.) of the dummy point. Interpolated attributes are not used to compute the predictions. Rather, some embodiments keep track of dummy points indices and skip those during predictions.

[0175] An example encoding method comprises: preprocessing a mesh having a hole by creating a dummy vertex, the dummy vertex being connected to each vertex along a perimeter of the hole; encoding the preprocessed mesh in a bitstream with edgebreaker coding; encoding in the bitstream information identifying the dummy vertex; and encoding at least one attribute for each of a plurality of vertices in the preprocessed mesh, wherein the attribute is not encoded for the dummy vertex.

[0176] An example decoding method comprises: obtaining from a bitstream information encoding a mesh; obtaining from the bitstream information identifying at least one dummy vertex in the mesh; and decoding from the bitstream attribute information for a plurality of vertices in the mesh, wherein attribute information is not decoded for the at least one dummy vertex.

[0177] In some such embodiments, decoding attribute information for a plurality of vertices comprises predicting attribute information for a plurality of the vertices, wherein no attribute information is predicted for the dummy points. The decoder may remove the dummy points.

[0178] Example embodiments are capable of handling meshes with and without separate UV coordinates index tables. Some encoders, such as the VDMC encoder, use base meshes with separate index tables and the geometry is made up of small number of closed meshes (eventually with holes but most of time closed),not of mesh patches. Hence, the economy of not encoding the first boundary is not significant in some embodiments.

[0179] As for the handling of "virtual” dummy points, an example procedure to handle the dummy points according to some embodiments is depicted by FIGs. 35 and 36.

[0180] In an embodiment where the attributes use the primary index table, the pre-processing procedure includes filling the holes by adding new corners and triangles in the corner table and setting up the connectivity. A table of indices of dummy vertices is stored in memory as well as some additional positions, and other optional attributes in the attribute tables (this attribute data is just used to fill the gaps, example embodiments use zeros). During the connectivity coding / decoding using edgebreaker, the connectivity is used as is, including the dummy triangles. For better prediction of other vertices and economy of data in bitstream, this table is used to skip the dummy point attributes during the attribute predictions at encoding and decoding.

[0181] In an embodiment where attributes use a separate index table, different treatments are performed on the corner table. Such embodiments do not recreate a connectivity but rather just initialize the new TC elements with —1 and the new OTC with — index of boundary + 4) so that each added corner has attributes table TC and OTC marked as special elements, which may be handled like seams. (FIG. 47 illustrates an example of a texture seam).

[0182] FIG. 37 illustrates an example of a C++ procedure to fill all the holes of a mesh described as a corner table (O, V, OT, OTC).

[0183] FIGs. 38A-38C illustrate an example of a C++ procedure to fill a single hole of a mesh described as a corner table (O, V, OT, OTC).

[0184] In example embodiments, a table of dummy point indices is encoded in the bitstream. See, for example, the syntax elements DATA_DUMMY_POINT_COUNT in Table 4, below, and DATA_DUMMY_POINTS_TABLE in Table 5, below. However, attributes associated with the dummy points are not encoded.

[0185] During post-processing, after the decoding of the mesh is finished, example embodiments use dummy point indices to remove the dummy points and the attached dummy triangles. The output of the process thus matches the original mesh in terms of boundaries. This processing may be performed during the transcoding to the final indexed face set representation.

[0186] Vertex indices are updated, removing references to dummy vertices and shifting subsequent indices accordingly.

[0187] One example implementation of such a technique is illustrated in FIG. 57. The complexity of this implementation is dummy_count * numOfTriangles. When the model has a large number of triangles and ofdummy points, the processing may be costly. In such cases it may be preferable to first define the mapping function using the list of dummy positions indices, and then to apply this remapping while recording which triangles should not be included in the decode mesh. (For example, a Boolean value false may be assigned to triangles including at least one dummy vertex, which are then discarded.)Encoding and decoding of per-vertex attributes.

[0188] In order to compute the predictions, example embodiments use multi-parallelogram prediction for the geometry, as described in D. Cohen-Or, R. Cohen and R. Irony., "Multi-way geometry encoding,” The School of Computer Science, Tel-Aviv University, Tel-Aviv, 2002; and M. Isenburg and P. Alliez, "Compressing polygon mesh geometry with parallelogram prediction," IEEE Visualization, no. doi: 10.1109 / VISUAL.2002.1183768, pp. 141-146, 2002. Example embodiments use min stretch prediction for the UV coordinates, as described in I. M. and S. J., "Compressing Texture Coordinates with Selective Linear Predictions," in Computer Graphics International, Tokyo, Japan, 2003.

[0189] Example embedments further provide processes for handling dummy points to fill holes and optional separate index tables for UV coordinates. The described techniques may further be used to support prediction of other attributes, such as normal per vertex, color per vertex or any other attribute per vertex.

[0190] Some embodiments provide prediction methods for the handling dummy points and separate index tables (hence UV seams).

[0191] In some embodiments, the prediction of attributes using main index table is implemented by a procedure such as encodeAttributes presented in FIGs. 39A-39B. This procedure is invoked several times during the edgebreaker encoding. Its decoding counterpart procedure decodeAttributes is depicted by FIG. 41 . Similarly, this procedure is invoked several times during the edgebreaker decoding.

[0192] FIG. 40 illustrates an example of the predicate isCornerVertexDummy. At encoding, the dummy points are all at the end of the vertex table, which is not the case at decoding.Residual coding of positions.

[0193] FIG. 42 illustrates an example of the procedure posEncodeWithPrediction .

[0194] Example embodiments store the starting point positions global coordinates and other point residuals in separate tables to get better entropy coding.

[0195] An example mesh encoding method comprises: encoding a connectivity of a mesh; entropy encoding a first table of starting point positions of vertices in the mesh; and separately entropy encoding a second table of point residuals of vertices in the mesh.

[0196] An example mesh decoding method includes: decoding information indicating connectivity of a mesh; entropy decoding a first table of starting point positions of vertices in the mesh; and separately entropy decoding a second table of point residuals of vertices in the mesh.

[0197] Some example embodiments extend the multi-parallelogram method to handle the dummy point cases so as to prevent erroneous predictions for parallelograms where dummy points are involved.

[0198] Some example embodiments extend prediction decoding to support multiple connected components by using tables shifting.

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

[0200] An example mesh decoding method includes: obtaining information encoding a plurality of connected components (CCs), each vertex in a CC having a respective CC-scope index; decoding each of the CCs; and for each of the vertices, shifting the index of the vertex from the CC-scope index to a global- scope index.

[0201] At the encoding stage, an example method includes computing the position prediction for a corner c and its attached vertex index v in the coding chain, for example using a method as illustrated in FIG. 40. During the prediction of a corner, we are sure that its associated triangle fan is always complete, and that each of its corners have a valid opposite, since example embodiments use dummy points to fill the holes (even a single triangle would become a pyramid made of 4 triangles in terms of connectivity).

[0202] FIG. 43A illustrates a strategy for multi parallelogram prediction of corner c positions and dummy points filtering according to some embodiments.

[0203] FIG. 43B illustrates a strategy for min stretch prediction of corner c UV coordinates and dummy points filtering according to some embodients.

[0204] In a first step, a process checks if the corner c to be coded is attached to a dummy vertex (if so, then skip the coding of the corner) or if we predict for the first vertex of the chain v = 0 (then we encode the position of v using global coordinates and no prediction. In this later case the process stores the position in a specific table dedicated to entropy encode the starting vertices (table sVertices). Storing those in a specific table, different from the predictions one (table oVert ices) allows for better entropy coding of these tables.

[0205] Otherwise, in a second step we test if the vertex is the second of the third (v = 1 or v = 2). In this case we do not perform predictions but rather use delta coding with vertex of previous corner and append the result in the table of predicted vertices;□Vertices . push_back (G [V[ c ] ] - G [V[OV. p ( c ) ] ] ) .

[0206] Otherwise, the processing of the multi-parallelogram for a given corner c performs, in a first loop, a lookup all around its vertex to compute and sum each parallelogram prediction using opposite corners (seeFIG. 41). A parallelogram to predict corner c from a sibling corner altC is valid for prediction only if the vertices of altC. o, altC. n, and altC. p were already processed by the connectivity recursion (which invokes the prediction). To test this, we use the vertex marking table M, which elements are set to true for vertex if already visited by the connectivity encoding loop. Then, the test during prediction is ( (M[V[0[ altC] ] ] > 0) and (M[V[0V. p( altC) ] ] > 0) and (M[V[0V. n ( altC) ] ] > 0) ) ) .

[0207] We extend this to test if altC. o, altC. n, and altC. p corners are not attached to dummy points (using the isCornerVertexDummy predicate). To summarize we use the corner altC for parallelogram prediction only if data is available (parallelogram vertices are not dummies and are already visited, hence available during decoding). At the end of the loop, we divide the prediction sum by the number of valid parallelograms that were found, we round the result and finally use the result to compute the residual (position- predicted) that is appended at the end of the output vertices table; oVe rt ices . pus h_ba c k ( G [ V [ c ] ]- predPos ) .

[0208] If no valid parallelogram was found, we fall back on delta coding using G [V[OV. n ( c ) ] ] as prediction if previous corner of c is a dummy point and G [V[OV. p ( c ) ] ] otherwise.

[0209] At the end of the edgebreaker encoding procedure, the two tables sVertices and oVertices will then be entropy coded and stored into the bitstream.

[0210] At decoding, an example of the reconstruction of a corner's vertex position is depicted in FIGs. 42A-42B. The process is the same as for encoding and follows the same order for vertices and fan exploration. The obtained predictions are thus equal to the ones of the encoding. Note that for the decoding we use a table D to quickly find if a vertex is a dummy point. The table D is initialized by the procedure initDecompression (see FIG. 16). Also note that in the prediction decoding procedure we use tables shifting to handle CCs (which is not the case in the prediction encoding procedure).

[0211] FIGs. 44A-44B illustrate an example of the procedure posDecodeWithPrediction. Table D indicates for each vertex if it is a dummy or not.Residual coding of UV coordinates using main index table.

[0212] The prediction encoding of UV coordinates using main index tables is extended the same way as for positions. The difference for some embodiments is the use of min stretch instead of multi-parallelogram for the prediction and that we do not sum up predictions (it is not multi-) but stop on the first valid (in the sense of prediction) neighbor in the triangle fan and compute the min stretch, as shown for example in FIG. 41. An example uvEncodeWithPrediction procedure shown in FIG. 43. An example prediction statement is depicted in FIGs. 44A-44B.

[0213] FIGs. 45A-45B illustrate an example of the procedure uvEncodeWithPrediction .

[0214] FIGs. 46A-46B illustrates an example of the statement p red ictUV . dvec2 and dvec3 are double precision vectors.

[0215] One can see in the predictUV procedure of FIGs. 44A-44B that we have one branch that uses prediction and two other paths that use fall back. The approach is based on using the geometry to make a first choice then performing the UV min stretch prediction or fall back to delta in case of dummies on the vertex chain or performs an average of previous and next corner UVs otherwise. Note that in the case of min stretch choice, example embodiments store the prediction residual (in table oUVCoords) and an orientation bit (in table orientations) that is used at decoding. In counterpart the two other paths do not store the orientation information.

[0216] As for the positions, the decoding is symmetrical. Example embodiments use tables shift for the handling of CCs and we use the same logical cases as for the positions. The input iUV is extracted as iUV = iUVCoords f sta rtvertex + V[ c ] - uvSvalueldx - uvSkipNum ] ; which includes CC offset sta rtvertex, start values in separate table uvSvalueldx and uvSkips in case of dummy points. This extracted iUV can be a delta (case v=1 or v=2) or a residual otherwise. Example embodiments then perform the same prediction or fall backs as in UV encoding and compute back the final UV as for positions: UV[ v ] = predUV + iUV with predUV the predicted UV or the fall back.Residual coding of UV coordinates using a different index table.

[0217] When the model makes use of separate index tables for the UV coordinates, example embodiments handle the potential UV seams during the predictions (in addition to separate table for start UVs, multiple CCs and dummy points). When not using a separate index table the positions of the vertices located on the boundaries of UV patches are duplicated, and the mesh contains at least as many CCs as UV patches. This is why in previous sections we handle the UV as the positions, they have the same structure. In counterpart, in example embodiments that use a separate index table for the UV coordinates, it is possible to have a more "compact” geometry without CCs specific to UVs and handle the UV patch boundaries using the separate UV index table. The edge chains on the mesh where the UV coordinates are different on each side may be referred to as UV seams.

[0218] FIG. 47A illustrates handling UV seams using only a main index table. Duplicated vertices (shown inside the dashed ovals) may have different UV coordinates. FIG. 47B illustrates handling of UVs with separate index table and selection strategy for the corner cpused for the prediction of UV coordinates with separate index for corner c.

[0219] Some example embodiments extend the UV predictor search strategy to support UV seams. This is performed in some such embodiments by storing specific codes in the TC and OTC tables to guide the algorithm.

[0220] Example embodiments perform a search strategy for a valid prediction corner as depicted in FIGs. 45A-45B. In this approach, the dummy points are handled implicitly, just checking if sibling corners already have reconstructed UV coordinates. The strategy to find a valid predictor cpfor UVs of corner c is to search for the first triangle, in the part of the fan that is on the same side of the seam than the triangle of corner c, for which a maximum of UV coordinates have already been predicted. Example embodimens select the first corner that has two UVs already predicted, if none, the first that has one UV already predicted otherwise no prediction. For the search, we can first turn left then right direction or the opposite this does not matter, but the same order is used at decoding. An example of a detailed procedure encodeSepa ratelndexAtt ributes to perform this work is illustrated in FIG. 46.

[0221] In some embodiments, the decoding, as illustrated in FIGs. 47A-47B, performs the same processing (using shifted tables) to recover the predicted values and then the final UV coordinates. Note that this stage does not make specific use if the isSeam table since this one was used during the edgebreaker decoding to create some valid TC and OTC tables that handles the separate indices. At this stage, the TC tables is used to find the UV indices per corner and the OTC table is used to detect UV seams. Example embodiments use -4 in OTC at encoding and -1 in OTC at decoding. This is because values between 0 and -4 are used for other purposes.

[0222] FIGs. 48A-48B illustrate an example of the procedure encodeSepa ratelndexAtt ributes .

[0223] FIGs. 49A-49B illustrate examples of the procedure decodeSepa ratelndexAtt ributes.Prediction of per-face attributes.

[0224] Some example embodiments encode and decode colors or Ids per face. In some such embodiments, the per face attribute is coded according to the order of faces in the CLERS table. Each symbol of the table corresponds to a triangle. Example embodiments operate to directly encode the per face attributes during the connectivity encoding (see FIGs. 12 and 13) and connectivity decoding (see FIGS. 18 and 19) whenever we code / decode a new triangle (doing T=0 or T++). Then, example embodiments include adding at these steps the encoding of the triangle attribute in a table. Some embodiments add the value (color, Id, ...) directly in a dedicated table, e.g. by performing a delta coding with previous triangle in the table. Some embodiments use separate tables to handle the start triangles, similar to the techniques described herein for start vertices when coding per vertex attributes. Such embodiments may have more efficient entropy coding.

[0225] Example embodiments use the triangle sequence in the order of the CLERS table to encode delta values for per triangle colors (e.g., 8bit rgb) or integers (e.g., group identifier, subdivision depth). Some more complex predictions could be envisioned using the same strategy, depending on the type of attribute.

[0226] An example of a mesh encoding method includes: obtaining information describing a mesh having a plurality of triangles, each triangle having an attribute; encoding the mesh as an ordered sequence of symbols in edgebreaker coding, each of the triangles corresponding to an associated one of the symbols; and encoding the attributes of the triangles, the attribute of a current triangle being encoded using a prediction based only on attributes of at least one triangle preceding the current triangle in the ordered sequence of symbols. For example, the attribute of each triangle may be encoded as a delta value relative to the preceding triangle in the sequence (the value of the attribute of the preceding triangle serving as the prediction).

[0227] A mesh decoding method according to some embodiments includes: obtaining an ordered sequence of symbols representing an edgebreaker coding of a mesh having a plurality of triangles, each triangle having an attribute; decoding the mesh; and decoding the attributes of the triangles, the attribute of a current triangle being decoded using a prediction based only on attributes of at least one triangle preceding the current triangle in the ordered sequence of symbols.

[0228] The prediction of per-vertex attributes may be particularly useful for mesh coding systems that handle per triangle groups specific adaptive subdivision. For instance, each triangle of the base mesh might receive an integer specifying the number of subdivisions it should receive to reconstruct the full mesh.

[0229] Some embodiments implement a technique (referred to here as variant A) for encoding Ids (e.g. material Ids) per face. An example of code for implementing variant A is provided in FIGs. 59A-59B. In such embodiments, for each corner processed during the traversal that defines a new triangle, the following actions may be performed:• A determination is made of whether the current corner defines an actual face or a dummy face (the face is dummy if one of its corners is associated to a dummy vertex).• A determination is made of whether the current Id is equal to the previous encoded Id, and the result of the comparison is stored in a Boolean vector faceldEqualToPrevious whose final size is the number of triangles of the input mesh (before adding dummy vertices). If the current Id is equal to the previous encoded Id, then further encoding of the current Id is not required. If, however, the current Id is not equal to the previous Id, the following steps are performed for the coding of the current Id:• A determination is made of whether any of the faces opposite to each of the current face corners has already been encoded. The current triangle is defined by the following three corners: currentcorner, ov . n ( currentCorner) , ov . p (currentCorner) . The "facing triangle” is defined as the one containing ov .O( currentCorner) , The "right triangle” is the one containing ov . Of ov . n ( currentCorner) ] , the "left” triangle is the one containing ov . Of ov . p ( cur rentcorner) ] .• For each of those triangles (faces opposite to each of the corners of the current triangle, defined by a corner index, as shown in FIGs. 61A-61C), if it has not already been encoded, a loop is performed first through faces containing cu rrentCorner=ov . O [ ov . n ( cu rrentCorner) ] stopping when finding a face that already has been encoded, until the considered face is not the current face for which we are encoding the Id value. If no decoded face has been found we restart and loop in the other direction, i.e. though faces containing cu rrentCorner=ov . O [ ov . p ( cu r rentcorner) ] .• This results in, for each corner corresponding to an actual face, three Boolean values (decodedRight, decoded Left, decoded Facing), and for those values that are true we know the corresponding face Id values which already have been encoded (faceld Right, faceldLeft, faceldFacing). When Boolean values are false, corresponding faceldRight / Left / Facing values may be set to an invalid value (e.g. -1 if we consider only id values >=0).• Then the following process is performed: if (decodedRight ) f aceldlsRight . push_back(f aceldRight == currentFaceld ) if ( ! decodedRight | | (faceldRight ! = currentFaceld ) ) { if ( (decodedLeft)&&(f aceldLeft ! = faceldRight ) ) f aceldlsLeft . push_back(f aceldLeft == currentFaceld ) if ( i decodedLeft | | (faceldLeft ! = currentFaceld) ) { if ( (decodedForward ) && (faceldForward ! = faceldRight) && (f aceldForward ! = faceldLeft) ) f aceldlsForward . push_back(face!dForward == faceldForward ) if ( ! decodedForward | | (faceldForward ! = currentFaceld ) ) notPredicted Faceld . pu sh_back( current Faceld )}}• The face may then be marked as encoded.• This process results in four Boolean vectors (faceld EqualToPrevious , faceldlsRight , faceldls Left , faceldls Facing) and a vector (notPredicted Faceld) containing values which are not predicted.

[0230] FIGs. 61A-61C illustrate an example of search order for corner[0] = c (the operation is repeated for corner[1] = c.n then for corner[2] = c.p). FIG. 61 A illustrates a face for which an Id is to be coded and L,R,F adjacent triangles. (The three adjacent always exist since dummy points are used to fill holes.) FIG. 61 B illustrates lookup in neighborhood looping in a first direction over R, R1 , R2, etc. FIG. 61 C illustrates a subsequent lookup in the other direction.

[0231] The method described above for encoding a parameter of a face in a mesh, such as a face Id of a triangle in a mesh, may be further described with respect to the example mesh of FIG. 62. In the example of FIG. 62, a parameter (e.g. face Id) of a current face C is being encoded. At least one edge-adjacent face is identified, each edge-adjacent face sharing an edge and two vertices with the current face. In this example the faces labeled R, L, and F are identified as edge-adjacent faces.

[0232] For at least a first one of the edge-adjacent faces, e.g. face R, a first encoded face associated with the first edge-adjacent face is identified, wherein the first encoded face is identified from among a first set of faces. The first set of faces includes a plurality of 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. In the example of FIG. 62, faces that are included in the first set are labeled with S1 . The first encoded face may be identified by traversing the faces in the first set according to a predetermined order and selecting the earliest-encountered encoded face in the predetermined order as the first encoded face. The predetermined order may be different in different embodiments, but it is preferably known to both the encoder and the decoder. As described above, the order may begin with the edge-adjacent face R itself, labeled here with S1 a. If the parameter (e.g. face Id) of this face has not yet been encoded, the order may proceed by pivoting counterclockwise around a first shared vertex 622 through faces S1b, S1c, S1d until an encoded face is found. If no encoded face has yet been found, the order may proceed by pivoting clockwise around a second shared vertex 624 through faces S1e, S1f, S1g, S1h until an encoded face is found.

[0233] If no encoded face is found, then there is no need to push any value onto the vector faceldlsRight because the decoder, performing the same traversal, can infer that no face in set S1 will be used to predict the parameter of the current face. However, if an encoded face is found, an indication may be encoded of whether the parameter associated with the first encoded face is equal to the current-face parameter.

[0234] An analogous process may be performed for the other edge-adjacent faces L and F. For example, a second encoded face associated with edge adjacent face L may be selected from among faces in a second set, indicated by S2 in FIG. 62, traversed according to a predetermined order, and an indication may be encoded indicating whether the second encoded face has an associated parameter equal to the parameter of the current face. In some embodiments, such an indication may be encoded only if no encoded face associated with the first edge-adjacent face R was found, or such a face is found and it does not have an associated parameter equal to the parameter of the current face. Moreover, if no second encoded face is found, there is no need to signal such an indication because the decoder, performing the same traversal, can infer that no face in set S2 will be used to predict the parameter of the current face.

[0235] Similarly, a third encoded face associated with a third edge-adjacent face F may be selected from among faces in a third set, indicated by S3 in FIG. 62, traversed according to a predetermined order, and an indication may be encoded indicating whether the third encoded face has an associated parameter equal tothe parameter of the current face. In some embodiments, such an indication may be encoded only if no encoded face associated with the second edge-adjacent face L is found, or such a face is found and it does not have an associated parameter equal to the parameter of the current face. If no third encoded face is found, there is no need to signal such an indication because the decoder, performing the same traversal, can infer that no face in set S3 will be used to predict the parameter of the current face.

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

[0237] If no encoded faces are found (e.g. the current face is the first encoded face in the mesh), or if none of the encoded faces have a parameter that is the same as the parameter of the current face, then information may be encoded that explicitly indicates the parameter of the current face.

[0238] In some embodiments, the above-described traversal through different faces to identify an encoded face with the same parameter (e.g. same face Id) is performed only after a determination has been made that the face with the most-recently coded parameter (referred to here as the "most-recently-coded face” or the "previous face”) has a parameter value that is different from the parameter value of the current face. Information may be encoded indicating whether the most-recently-coded face has the same parameter value as the current face. If they do have the same value, both the encoder and decoder may avoid checking the coding status and parameter values of other neighboring triangles.

[0239] As noted above, some signaling can be avoided where a decoder can infer that a particular face is not being used to predict the parameter value of the current face, for example because that face is encoded after the current face.

[0240] In some embodiments, additional signaling is avoided by treating the most-recently-coded face as an invalid face when a traversal is being performed through adjacent faces of the current face. This may be done because the traversal would not be performed at all if most-recently-coded face had the same parameter value as the current face. The fact that the traversal is being performed itself indicates that the most-recently-coded face has a different parameter value than that of the current face, so if a traversal of adjacent faces is being performed, unneeded signaling can be avoided by not allowing the most-recently- coded face to be selected as a predictor at that stage.

[0241] Some such embodiments have been found to provide around 0.2% compression gains of base mesh intra coding on some sequences of the VDMC v4.0 CTCs. Example embodiments further reduce the cost of processing since less possible paths are explored "in depth”.

[0242] As an overview, an example encoding process for face Id as described above may be summarized as three steps. First, in step A, we check if the corresponding (Right, Left and Facing) face is encoded. Then, in step B, we loop through triangle (defined by a corner), swinging around a first corner of this initially considered face that shares a first vertex on the edge between the triangle to encode and this initiallyconsidered face. Finally, in step C, we loop through triangles swinging around a second and the initially considered face. An example encoding algorithm is depicted in FIG. 63.

[0243] To reduce signaling (and thus improve compression) based on the inference that the "most- recently-coded face” or the "previous face” will not be used as a predictor, one or more of the following revisions may be made to an embodiment as described above.

[0244] In some embodiments, the previous technique is modified so that:If, after step A, the corresponding face is evaluated as encoded, but is equal to the previously encoded face, then the evaluation is invalidated, and the algorithm proceeds to step B instead of stopping.If, after step C, a corresponding face is evaluated as encoded, but is equal to the previously encoded face, then the evaluation is invalidated, and the algorithm proceeds to the next R,L,F evaluation

[0245] In some embodiments, the following further variations are implemented:In step B and step C, we do not stop the traversal when during swinging an encoded face is found which is the previously decoded face. In such situations the search is pursued, thus never stopping the search on the first decoded face, but on the first decoded face which is not equal to the previously encoded face.

[0246] In some additional embodiments, the sets of faces that are searched are enlarged by swinging around the third corner of the initially considered face (we have implemented swinging from two of the three corners of the considered face, but not yet tested this potential alternative). For example, the set of faces that are searched in association with face R may further include those faces labeled ST in FIG. 64 (in addition to those labeled S1a through S1h). Similar additions may be made to the sets of faces searched in association with other edge-adjacent faces.

[0247] Preventing the most-recently-coded face from being identified as a valid predictor during this search stage has a very light computational cost and enables reduction in the size of the vectors storing comparison results, thus saving bits in the final bitstream, and also reducing the processing time used to arithmetically encode the vectors.

[0248] Code for an example encoding method according to some such embodiments is illustrated in FIG. 65A-65B. Features particularly relevant to this variant are shown in bold.

[0249] Code for an example decoding method according to some such embodiments is illustrated in FIG. 66A-66B. Features particularly relevant to this variant are shown in bold.

[0250] In some embodiments as described herein, the first, second, and third sets ef faces being searched exclude the most-recently-coded face. For example in the mesh shown in FIG. 64, one of the faces is marked with a P is the most-recently-coded (or "previous”) face, being the face whose parameter (e.g. face Id) was the last to be encoded before encoding the parameter of the current face C. According to some previousembodiments described above, face P would fall within both the first set S1 and the second set S2. However, according to some embodiments, face P may be excluded from those sets.

[0251] In some embodiments the search within a set stops if the most-recently-coded face P is reached. For example, the search or traversal through the first set S1 may stop when face P is reached, since P is an encoded face, but because P is already known not to have the same parameter as the current face (otherwise no search would be taking place), the selection of P may be treated as invalid, and no face may be identified from set S1 . In other embodiments, the search skips over the most-recently-coded face P but continues with any further faces in the set. For example, with respect to FIG. 64, a search order through the first set S1 may proceed from S1f directly to S1h. In such embodiments, the search may include traversing the faces in each set according to a predetermined order and selecting the earliest-encountered encoded face in the predetermined order, other than a most-recently-coded face, P, as the encoded face to use for prediction.

[0252] FIGs. 67A-67B illustrate compression performance of embodiments as shown in FIGs. 65A-65B as compared to embodiments as shown in FIGs. 59A-59B for the encoding of a base mesh in V-DMC. Results for each CTC test sequence each averaged over 32 frames.

[0253] Some embodiments implement an alternative technique (referred to here as variant B) for encoding Ids per face. Such a technique may be implemented as follows:• Store information indicating whether the current id is equal to the previous in a first vector of Boolean values.• If it is not equal, store either the absolute value of the current Id, or a difference versus the previous one in a second vector of integer values.

[0254] Some embodiments implement an alternative technique (referred to here as variant C) for encoding Ids per face. Such a technique may be implemented as follows:• Store information indicating whether the current id is equal to the previous in a first vector of Boolean values.• If it is not equal, store information indicating whether the current id is equal to the most recently coded id that was different from the previous in a second vector of Boolean values.• If it is not equal, store either the absolute value of the current Id, or a difference versus the previous one in a third vector of integer values.

[0255] Using a larger number of most recently used values and coding indices pointing to those instead of absolute values may be performed in some embodiments, but it is not likely to lead to increased efficiency.

[0256] At least for some sample sets of meshes that are processed in the VDMC context, those alternative approaches (B and C) are less efficient than A, but still simpler to implement, and faster to execute.

[0257] An example of code for executing encoding using alternative A is illustrated in FIGs. 59A-59B. Decoding using alternative A (e.g. with a procedure decodePerFaceAttributes) is performed in a manner analogous to the encoding as illustrated in FIGs. 59A-59B.

[0258] 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 edgebreaker coding, each of the triangles corresponding to an associated one of the symbols; and encoding the attributes of the triangles, the attribute of a current triangle being encoded using a prediction based on attributes of at least one triangle adjacent to the current triangle in the mesh (such as the left, right, facing, and / or previous triangle).

[0259] In some such embodiments, the encoding of the attributes of the triangles includes encoding a plurality of Boolean vectors (such as the faceld EqualToPrevious , faceldlsRight , faceldls Left , and / or faceldls Facing vectors), the plurality of Boolean vectors collectively indicating, for at least a plurality of the triangles, a corresponding triangle from which the respective attribute is predicted.

[0260] As described in greater detail below, arithmetic encoding of the plurality of Boolean vectors may also be performed.

[0261] In some embodiments, a mesh decoding method includes: obtaining an ordered sequence of symbols representing an edgebreaker coding of a mesh having a plurality of triangles, each triangle having an attribute; decoding the mesh; and decoding the attributes of the triangles, the attribute of a current triangle being decoded using a prediction based on attributes of at least one triangle adjacent to the current triangle in the mesh.

[0262] In some such embodiments, the decoding of the attributes of the triangles includes encoding a plurality of Boolean vectors (such as the faceld EqualToPrevious , faceldlsRight , faceldls Left , and / or faceldls Facing vectors), the plurality of Boolean vectors collectively indicating, for at least a plurality of the triangles, a corresponding triangle from which the respective attribute is predicted.

[0263] As described in greater detail below, arithmetic decoding of the plurality of Boolean vectors may also be performed.Entropy coding.

[0264] FIG. 50 illustrates an example of the procedure save, which relates to entropy coding and syntax writing. During the creation of the bitstream (see FIGs. 48A-48B), example embodiments first write some meta-data in a header, then save the topology payload, and finally save the attributes (positions, UVcoordinates) payload. For both topology and attributes, some tables are entropy coded before save. Example entropy encodings are described in this section. .

[0265] Example embodiments support two or more different arithmetic encoders, such as the Dirac coding or RANS coding, described in J. Duda, "Asymmetric numeral systems: entropy coding combining speed of Huffman coding with compression rate of arithmetic coding," 2014. For some data, one or the other of these codecs may provide better compression. We also found that for some other tables, depending on the model that is being compressed, one or the other is better at compression. Example embodiments provide more than one arithmetic codec implementation guided by some options. Tables 6, below, summarizes for each type of data, which arithmetic coder is available for some embodiments. The following sections further detail the configuration / binarization used for some data tables depending on the type of arithmetic coding that is used.Arithmetic coding of the CLERS table.

[0266] When encoding a non-binary sequence of CLERS symbols, representing topological codes used to reconstruct the topology of mesh traversed using the edgebreaker algorithm, one or more of the following approaches may be used.

[0267] The selection of a preferred binarization process and the probability model selection for the related bins may depend on the specific nature of the sequence of symbols to encode, conditioned by the number of symbols (related to the number ef faces in the mesh), and the topological structure of this mesh (e.g., the regularity of the structure of the considered mesh, potentially impacting the global symbols statistics but also the interrelations between successive symbols)

[0268] Some embodiments assign a variable length code to the set of symbols (e.g., 5 symbols ‘C ‘L’ ‘E’ ‘R’ ‘S' for the basic edgebreaker), depending on the expected statistical distribution of those. One known selection is to assign {'C',0, 1 bit}, {'S',1 , 3bits}, {'L',3, 3bits}, {'R',5, 3bits}, {'E',7, 3bits}

[0269] C = 000

[0270] S = 001

[0271] L = 011

[0272] R = 101

[0273] E = 111

[0274] In some embodiments, when encoding using RANS, the CLERS table made of these codes is provided to the encoder as is.

[0275] In some embodiments, when encoding using Dirac coding, it is possible encode using several contexts (ctx). Some such embodiments encode bO using ctxO, b1 using ctx1 and b2 using ctx2, when b0=0 then the 2 subsequent bits do not need to be coded.

[0276] In some embodiments, contexts are selected for each bin depending on the values of the previous bins for the current symbol, but also depending on the values of the preceding symbols. This is useful for CLERS sequences as there are strong correlations between successive symbols.

[0277] Example embodiments which use a global 5-bits (32 possible values) state that is defined using the 2 previous symbol values. Alternative embodiments use a simplified or extended state definition.

[0278] In some embodiments, one of 32 bit_O contexts is selected for the encoding of the fist bit defining if the symbol is ‘C or not. If the symbol is not ‘C, the second bit is encoded using one of the 32 contexts modelling values for bit_1 . Then depending on the value of bit_1 , two sets of 32 contexts are used to encode bit_2. Finally, the global state is updated considering the latest encoded symbol. In our current implementation the state has 3 bits for the latest values plus bitO and bit3 from the previous, that is 5 bits of 32 states. All those states are not necessarily used in practice: using a simple mapping we would instantiate only 20 contexts as 5 values for the current symbol x 4 possible states retained from the previous which is 20 possible states. Then in this example the total number of used contexts would be 20x4=80 (4 for bit_O, bit_1 , bit_2IFbit_1 isO, bit_2IFbit_1is1)

[0279] When the number of symbols is not large, using many contexts may prove inefficient. Then, based on then number of symbols to encode, example embodiments operate to adjust the number of global states to use. For instance, instead of using a 32 bits global state (where 5x4=20 are useful states) example embodiments can limit it to 3 bits or 5 global states when capturing only the value of the latest symbol.

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

[0281] Some embodiments operate to define a scheme that progressively uses more states (bootstrapping), copying appropriate states values to uninitialized states when transitioning the model based on e.g. the number of symbols encoded or other factors such as a specific trigger based on states values, statistics on input values (e.g. variance of the probability encoded bits), and the like.

[0282] An example of pseudo code to control the Dirac encoder for the CLERS table is given in FIG. 51 .AC coding of attribute residuals.

[0283] When coding vertex attributes such as positions or texture coordinates, example embodiments operate to predict those values and then encode only residuals. Absolute reference values may be coded separately to avoid reducing the performance of the arithmetic coder by spoiling the statistics.

[0284] When encoding using RANS, example embodiments provide the table made of these residuals to the encoder as is.

[0285] In some embodiments, when encoding using Dirac, some control over the contexts may be performed. Example embodiments a coding scheme is used for the arithmetic encoding of motion vectors, based on the Dirac arithmetic coder. The code illustrated in FIG. 52 provides an illustration reproducing part of the coding principle used for motion vectors in some embodiments.

[0286] With this approach, to encode triplets of signed integer values (one per coordinate of a 3D position) example embodiments use 51 contexts. For each value we first encode is this value is 0 as one bit using a first context. If the value is not null, we encode the sign as one bit using a second context. Then we encode if the absolute value of the value to encode is 1 as one bit using a third context. If the absolute value of the value to encode is above 1 , then the absolute value of the value to encode minus one is expGolomb encoded using 2x7 contexts, 7 for the exponent (prefix) part, 7 for the suffix part. This is merely one example, and different configurations may be used in other embodiments. In some embodiments, an offset or shift value is used in conjunction with the expGolomb encoding. Such encoding schemes may allow for better compression of distributions with large probabilities for values -1 0 +1 and adjust to distributions not conforming to the ideal distribution ideally handled by the expGolomb coding. More details on an example offset / shift are given in the example code for ExpGolomb coding as shown in FIG. 53.

[0287] This modelling may not be optimal for the distributions of position or other attributes residuals. Thus, some embodiments use a more elaborate modelling to achieve better results.

[0288] Some example embodiments proceed as follows (the given dimensioning values are examples only). In some embodiments, the threshold before falling back to expGolomb coding has been extended (this is set through the bias parameter). In an example embodiment:1 . Encode one bit to signal whether the value is 0.2. Then if not 0, encode the sign as one bit. We are left with encoding newvalue = abs initialvalue) — 1.3. Then a code (e.g. a simple code) of max length bias is used to encode newvalue < bias, repeatedly repeating 0 and 1 when the bit count is equal to the value to encode and stopping after bias values.4. Then if the last bit transmitted was 0 the value is >= bias, we encode (newvalue — bias) using biaised exp-golomb coding.

[0289] The contexts in step 3 may be conditioned by the fact that the previous coded value has an absolute value smaller than bias. Their number can be limited so that it can be any value from 1 to bias, schematic example of the code for some embodiments is depicted in FIG. 54. In this embodiment, the performances are impacted by the looping order, per component / per residual. Depending on the predictor used and the kind of data an optimal order may be selected (better to loop through values assigned to one component before going to another component for positions with our parallelogram predictor), better to go throughcomponents first for texture coordinates and stretch minimization prediction. If states are duplicated per component there is no such ambiguity, but performances / complexity may be impacted.Entropy coding of per face material attributes or other attributes.

[0290] In some embodiments, when encoding a material I D attributes, or facelD values that are assigned so that large spans of contiguous triangles share common values using a encoding scheme such as detailed above, arrays of values defined by the encoding process may be arithmetically coded using the following scheme. The encoding / prediction process results in• Four Boolean vectors: faceldEqualToPrevious, faceldlsRight, faceldlsLeft, faceld IsFacing.• A vector notPredictedFaceld containing values which are not predicted.

[0291] The four Boolean vectors are arithmetically encoded using four separate contexts.

[0292] The vector containing unsigned face Id values is encoded using exponential Golomb coding and a number of contexts for encoding the suffix and prefix part. Those numbers may be adjusted, taking into account the range of faceld values, so as to balance the complexity / performance trade off. As an example, both prefix and suffix coding may use as many contexts as the number of bits 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.

[0293] In some embodiments, the exponential Golomb coding may use a optimized "shift” parameter as in previous examples.

[0294] In some embodiments, where input face ID or material ID values are not unsigned, an additional parameter may be added to translate the range of values so that translated values are all positive. Alternatively, some embodiments convert values to a positive range using: y= 2*x if x >= 0 , y= - 2*x - 1, if x<0 or any similar bijective transform converting the id range to positive values.

[0295] In some embodiments, the five vectors may be encoded separately, resulting in five coded arrays of bytes.

[0296] In some embodiments, the number of elements coded into each of those vectors (the original vector sizes) may be signaled. The coded byte array sizes enables decoding of each of those in parallel.

[0297] In some alternative embodiments, all the information is encoded into a single byte array using the multiple contexts, and decoding is done progressively, selecting contexts appropriately by performing contexts selection during the decoding process mirroring selections at the encoding stage.

[0298] An example of Dirac AC entropy coding for coding of per-face material IDs is illustrated in FIG. 60.Example low-level syntax.

[0299] This section describes a syntax that is used in some example embodiments.

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

[0301] An example attributes bitstream (DATA_ATTRIBUTES) according to some embodiments is shown in Table 2.Table 2.

[0302] An example configuration information bitstream (CFGJNFO) according to some embodiments is shown in Table 3.Table 3.

[0303] An example data header information bitstream (DATA_HEADER) according to some embodiments is shown in Table 4.Table 4.

[0304] An example data topology bitstream (DATA _TOPOLOGY) according to some embodiments is given in Table 5.Table 5.

[0305] Table 6 illustrates an example of a data position attributes bitstream according to some embodiments.Table 6.

[0306] Table 7 illustrates an example UV coordinate attributes bitstream according to some embodiments.Table 7.Performance.

[0307] Performance of an example embodiment of the overall compression as described herein in the context of V-DMC were compared against comparable compression using Google Draco. See results of figure which shows compression gains for the base mesh coding. FIG. 55 illustrates compression performance of an encoding method as described herein as comparted to Google Draco for the encoding ofbase mesh in V-DMC. Results for each CTC test sequence each averaged over 300 frames. PSNRs are not presented since they are not impacted. The results show an overall average gain of 5.4% over Draco rates.Example system hardware.

[0308] Example embodiments of encoders and / or decoders (collectively coders) configured to implement embodiments described herein may be implemented using systems such as the system of FIG. 56. FIG. 56 is a block diagram of an example of a system in which various aspects and embodiments are implemented. System 1000 can be embodied as a device including the various components described below and is 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, singly or in combination, can be embodied 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, the system 1000 is communicatively coupled to one or more other systems, or other electronic devices, via, for example, a communications bus or through dedicated input and / or output ports. In various embodiments, the system 1000 is configured to implement one or more of the aspects described in this document.

[0309] The system 1000 includes at least one processor 1010 configured to execute instructions loaded therein for implementing, for example, the various aspects described in this document. Processor 1010 can include embedded memory, input output interface, and various other circuitries as known in the art. The 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 can 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, magnetic disk drive, and / or optical disk drive. The storage device 1040 can include an internal storage device, an attached storage device (including detachable and non-detachable storage devices), and / or a network accessible storage device, as non-limiting examples.

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

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

[0312] In some embodiments, memory inside of the processor 1010 and / or the encoder / decoder module 1030 is used to store instructions and to provide working memory for processing that is needed during encoding or decoding. In other embodiments, however, a memory external to the processing device (for example, the processing device can be either the processor 1010 or the encoder / decoder module 1030) is used for one or more of these functions. The external memory can be the memory 1020 and / or the storage device 1040, for example, a dynamic volatile memory and / or a non-volatile flash memory. In several embodiments, an external non-volatile flash memory is used to store the operating system of, for example, a television. In at least one embodiment, a fast external dynamic volatile memory such as a RAM is used as working memory for video coding and decoding operations, such as for MPEG-2 (MPEG refers to the Moving Picture Experts Group, MPEG-2 is also referred to as ISO / IEC 13818, and 13818-1 is also known as H.222, and 13818-2 is also known as H.262), HEVC (HEVC refers to High Efficiency Video Coding, also known as H.265 and MPEG-H Part 2), or WC (Versatile Video Coding, a new standard being developed by JVET, the Joint Video Experts Team).

[0313] The input to the elements of system 1000 can be provided through various input devices as indicated in block 1130. Such input devices include, but are not limited to, (i) a radio frequency (RF) portion that receives an RF signal transmitted, for example, over the air by a broadcaster, (ii) a Component (COMP) input terminal (or a set of COMP input terminals), (iii) a Universal Serial Bus (USB) input terminal, and / or (iv) a High Definition Multimedia Interface (HDMI) input terminal. Other examples, not shown in FIG. 1 C, include composite video.

[0314] In various embodiments, the input devices of block 1130 have associated respective input processing elements as known in the art. For example, the RF portion can be associated with elements suitable for (i) selecting a desired frequency (also referred to as selecting a signal, or band-limiting a signal to a band of frequencies), (ii) downconverting the selected signal, (iii) band-limiting again to a narrower band of frequencies to select (for example) a signal frequency band which can be referred to as a channel incertain embodiments, (iv) demodulating the downconverted and band-limited signal, (v) performing error correction, and (vi) demultiplexing to select the desired stream of data packets. The RF portion of various embodiments includes one or more elements to perform these functions, for example, frequency selectors, signal selectors, band-limiters, channel selectors, filters, downconverters, demodulators, error correctors, and demultiplexers. The RF portion can include a tuner that performs various of these functions, including, for example, downconverting the received signal to a lower frequency (for example, an intermediate frequency or a near-baseband frequency) or to baseband. In one set-top box embodiment, the RF portion and its associated input processing element receives an RF signal transmitted over a wired (for example, cable) medium, and performs frequency selection by filtering, downconverting, and filtering again to a desired frequency band. Various embodiments rearrange the order of the above-described (and other) elements, remove some of these elements, and / or add other elements performing similar or different functions. Adding elements can include inserting elements in between existing elements, such as, for example, inserting amplifiers and an analog-to-digital converter. In various embodiments, the RF portion includes an antenna.

[0315] Additionally, the USB and / or HDMI terminals can include respective interface processors for connecting system 1000 to other electronic devices across USB and / or HDMI connections. It is to be understood that various aspects of input processing, for example, Reed-Solomon error correction, can be implemented, for example, within a separate input processing IC or within processor 1010 as necessary. Similarly, aspects of USB or HDMI interface processing can be implemented within separate interface ICs or within processor 1010 as necessary. The demodulated, error corrected, and demultiplexed stream is provided to various processing elements, including, for example, processor 1010, and encoder / decoder 1030 operating in combination with the memory and storage elements to process the datastream as necessary for presentation on an output device.

[0316] Various elements of system 1000 can be provided within an integrated housing, Within the integrated housing, the various elements can be interconnected and transmit data therebetween using suitable connection arrangement 1140, for example, an internal bus as known in the art, including the Inter- IC (I2C) bus, wiring, and printed circuit boards.

[0317] The system 1000 includes communication interface 1050 that enables communication with other devices via communication channel 1060. The communication interface 1050 can include, but is not limited to, a transceiver configured to transmit and to receive data over communication channel 1060. The communication interface 1050 can include, but is not limited to, a modem or network card and the communication channel 1060 can be implemented, for example, within a wired and / or a wireless medium.

[0318] Data is streamed, or otherwise provided, to the system 1000, in various embodiments, using a wireless network such as a Wi-Fi network, for example IEEE 802.11 (IEEE refers to the Institute of Electrical and Electronics Engineers). The Wi-Fi signal of these embodiments is received over the communicationschannel 1060 and the communications interface 1050 which are adapted for Wi-Fi communications. The communications channel 1060 of these embodiments is typically connected to an access point or router that provides access to external networks including the Internet for allowing streaming applications and other over-the-top communications. Other embodiments provide streamed data to the system 1000 using a set- top box that delivers the data over the HDMI connection of the input block 1130. Still other embodiments provide streamed data to the system 1000 using the RF connection of the input block 1130. As indicated above, various embodiments provide data in a non-streaming manner. Additionally, various embodiments use wireless networks other than Wi-Fi, for example a cellular network or a Bluetooth network.

[0319] The system 1000 can provide an output signal to various output devices, including a display 1100, speakers 1110, and other peripheral devices 1120. The display 1100 of 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. The display 1100 can be for a television, a tablet, a laptop, a cell phone (mobile phone), or other device. The display 1100 can also be integrated with other components (for example, as in a smart phone), or separate (for example, an external monitor for a laptop). The other peripheral devices 1120 include, in various examples of embodiments, one or more of a stand-alone digital video disc (or digital versatile disc) (DVR, for both terms), a disk player, a stereo system, and / or a lighting system. Various embodiments use one or more peripheral devices 1120 that provide a function based on the output of the system 1000. For example, a disk player performs the function of playing the output of the system 1000.

[0320] In various embodiments, control signals are communicated between the system 1000 and the display 1100, speakers 1110, or other peripheral devices 1120 using signaling such as AV. Link, Consumer Electronics Control (CEC), or other communications protocols that enable device-to-device control with or without user intervention. The output devices can be communicatively coupled to system 1000 via dedicated connections through respective interfaces 1070, 1080, and 1090. Alternatively, the output devices can be connected to system 1000 using the communications channel 1060 via the communications interface 1050. The display 1100 and speakers 1110 can be integrated in a single unit with the other components of system 1000 in an electronic device such as, for example, a television. In various embodiments, the display interface 1070 includes a display driver, such as, for example, a timing controller (T Con) chip.

[0321] The display 1100 and speaker 1110 can alternatively be separate from one or more of the other components, for example, if the RF portion of input 1130 is part of a separate set-top box. In various embodiments in which the display 1100 and speakers 1110 are external components, the output signal can be provided via dedicated output connections, including, for example, HDMI ports, USB ports, or COMP outputs.

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

[0323] A mesh encoding method according to some embodiments comprises: for a current face in a mesh having an associated current-face parameter, such as a face identifier, identifying at least one edge-adjacent face, each edge-adjacent face sharing an edge and two vertices with the current face; for at least a first one of the edge-adjacent faces, identifying a first encoded face associated with the first edge-adjacent face, wherein the first encoded face is identified from among a first set of faces, the first set of faces 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 faces that are not the first edge-adjacent face; and encoding a first indication of whether a first adjacent-face parameter associated with the first encoded face is equal to the current-face parameter. A corresponding mesh decoding method is performed in some embodiments.

[0324] In some embodiments, the first indication is an indication that the first adjacent-face parameter associated with the first encoded face is not equal to the current-face parameter, the method further comprising: for a second one of the edge-adjacent faces, identifying a second encoded face associated with the second edge-adjacent face, wherein the second encoded face is identified from among a second set of faces, the second set of faces 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 faces that are not the second edge- adjacent face; and encoding a second indication of whether a second adjacent-face parameter associated with the second encoded face is equal to the current-face parameter.

[0325] In some embodiments, the second indication is an indication that the second adjacent-face parameter associated with the second encoded face is not equal to the current-face parameter, the method further comprising: for a third one of the edge-adjacent faces, identifying a third encoded face associated with the second edge-adjacent face, wherein the third encoded face is identified from among a third set of faces, the third set of faces 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 faces that are not the third edge-adjacent face; and encoding a third indication of whether an adjacent-face parameter associated with the third encoded face is equal to the current-face parameter.

[0326] In some embodiments, the third indication is an indication that the third adjacent-face parameter associated with the third encoded face is not equal to the current-face parameter, the method further comprising encoding a value of the current-face parameter.

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

[0328] In some embodiments, the first indication is performed only in response to a determination that the fourth parameter is not equal to the current-face parameter.

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

[0330] In some embodiments, traversing the faces in the first set according to the predetermined order comprises: traversing the first edge-adjacent face; in response to a determination 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 a determination that no encoded face has yet been traversed in the first set, traversing at least one face that shares a second vertex with both the current face and the first edge-adjacent face. Analogous search orders may be used for other sets.

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

[0332] In some embodiments, one or more of the first, second, and third sets of faces excludes the most- recently-coded face.

[0333] In some embodiments, identifying the first encoded face associated with the first edge-adjacent face comprises: traversing the faces in the first set according to a predetermined order; and selecting the earliest-encountered encoded face in the predetermined order, other than a most-recently-coded face, as the first encoded face. Analogous search techniques may be used for the second and third sets.

[0334] In some embodiments, the first indication is encoded only in response to a determination that the first encoded face is not a most-recently-coded face. Analogous conditions may be applied to encoding of the second and third indications.

[0335] A mesh encoding method according to some embodiments comprises encoding parameters of corresponding faces in a mesh using a set of vectors including: a first vector (faceldEqualToPrevious) including an entry for each of a plurality ef faces in the mesh, each entry in the first vector indicating whether the parameter of the respective face is equal to the parameter of a corresponding most-recently-coded face; a second vector (faceldlsRight) including an entry for each face in the mesh that (1) was not indicated by the first vector to have a parameter equal to the parameter of the corresponding most-recently-coded face, and(2) has a valid first encoded face in a first set of faces associated with the respective face, each entry in the second vector indicating whether the parameter of the respective face is equal to the parameter of the corresponding first encoded face; a third vector (faceldlsLeft) including an entry for each face in the mesh that (1) was not indicated by the second vector to have a parameter equal to the parameter of the corresponding first encoded face, and (2) has a valid second encoded face in a second set of faces associated with the respective face, each entry in the third vector indicating whether the parameter of the respective face is equal to the parameter of the corresponding second encoded face; a fourth vector (faceldlsForward) including an entry for each face in the mesh that (1) was not indicated by the third vector to have a parameter equal to the parameter of the corresponding second encoded face, and (2) has a valid third encoded face in a third set of faces associated with the respective face, each entry in the fourth vector indicating whether the parameter of the respective face is equal to the parameter of the corresponding third encoded face; and a fifth vector (notPredictedFaceld) including an entry for each face in the mesh that was not indicated by the fourth vector to have a parameter equal to the parameter of the corresponding third encoded face, each entry in the fourth vector identifying the parameter of the respective face. A corresponding mesh decoding method is performed in some embodiments.

[0336] In some such embodiments, an encoded face in the first, second, or third set of faces is determined not to be a valid first encoded face in response to a determination that the encoded face is the same as the most-recently-coded face.

[0337] Example embodiments further include the following: corresponding decoding techniques, apparatus comprising one or more processors configured to perform the methods herein, apparatus comprising at least one processor and a computer-readable medium storing instructions for performing the methods described herein, a computer-readable medium storing a mesh encoded according to the methods herein, and a signal conveying a mesh encoded according to the methods herein.

[0338] Note that various hardware elements of one or more of the described embodiments are referred to as "modules” that carry out (i.e., perform, execute, and the like) various functions that are 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) deemed suitable by those of skill in the relevant art for a given implementation. Each described module may also include instructions executable for carrying out the one or more functions described as being carried out by the respective module, and it is noted that those instructions could take the form of or include hardware (i.e., hardwired) instructions, firmware instructions, software instructions, and / or the like, and may be stored in any suitable non-transitory computer-readable medium or media, such as commonly referred to as RAM, ROM, etc.

[0339] Although features and elements are described above in particular combinations, one of ordinary skill in the art will appreciate that each feature or element can be used alone or in any combination with the other features and elements. In addition, the methods described herein may 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, a read only memory(ROM), a random access memory (RAM), a register, cache memory, semiconductor memory devices, magnetic media such as internal hard disks and removable disks, magneto-optical media, and optical media such as CD-ROM disks, and digital versatile disks (DVDs). A processor in association with software may be used to implement a radio frequency transceiver for use in a WTRU, UE, terminal, base station, RNC, or any host computer.

Claims

CLAIMS1. A mesh encoding method comprising: for a current face in a mesh having an associated current-face parameter, identifying at least one edge-adjacent face, each edge-adjacent face sharing an edge and two vertices with the current face; for at least a first one of the edge-adjacent faces, identifying a first encoded face associated with the first edge-adjacent face, wherein the first encoded face is identified from among a first set ef faces, the first set of faces 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 faces that are not the first edge-adjacent face; and encoding a first indication of whether a first adjacent-face parameter associated with the first encoded face is equal to the current-face parameter.

2. A mesh encoding apparatus comprising one or more processors configured to perform: for a current face in a mesh having an associated current-face parameter, identifying at least one edge-adjacent face, each edge-adjacent face sharing an edge and two vertices with the current face; for at least a first one of the edge-adjacent faces, identifying a first encoded face associated with the first edge-adjacent face, wherein the first encoded face is identified from among a first set ef faces, the first set of faces 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 faces that are not the first edge-adjacent face; and encoding a first indication of whether a first adjacent-face parameter associated with the first encoded face is equal to the current-face parameter.

3. The method of claim 1 , or the apparatus of claim 2, wherein the first indication is an indication that the first adjacent-face parameter associated with the first encoded face is not equal to the current-face parameter, the method further comprising: for a second one of the edge-adjacent faces, identifying a second encoded face associated with the second edge-adjacent face, wherein the second encoded face is identified from among a second set of faces, the second set of faces 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 faces that are not the second edge-adjacent face; and encoding a second indication of whether a second adjacent-face parameter associated with the second encoded face is equal to the current-face parameter.

4. The method of claim 3 as it depends from claim 1 , or the apparatus of claim 3 as it depends from claim 2, wherein the second indication is an indication that the second adjacent-face parameter associated with the second encoded face is not equal to the current-face parameter, the method further comprising: for a third one of the edge-adjacent faces, identifying a third encoded face associated with the second edge-adjacent face, wherein the third encoded face is identified from among a third set ef faces, the third set of faces 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 faces that are not the third edge- adjacent face; and encoding a third indication of whether an adjacent-face parameter associated with the third encoded face is equal to the current-face parameter.

5. The method of claim 4 as it depends from claim 1 , or the apparatus of claim 4 as it depends from claim 2, wherein the third indication is an indication that the third adjacent-face parameter associated with the third encoded face is not equal to the current-face parameter, the method further comprising encoding a value of the current-face parameter.

6. The method of claim 1 or claims 3-5 as they depend from claim 1 , or the apparatus of claim 2 or claims 3-5 as they depend from claim 2, further comprising: identifying a most-recently-coded face in the mesh; and encoding a fourth indication of whether a fourth parameter associated with the most-recently-coded face is equal to the current-face parameter.

7. The method of claim 1 or the apparatus of claim 2, wherein identifying the first encoded face associated with the first edge-adjacent face comprises: traversing the faces in the first set according to a predetermined order; and selecting the earliest-encountered encoded face in the predetermined order as the first encoded face.

8. A mesh decoding method comprising for a current face in a mesh having an associated current-face parameter, identifying at least one edge-adjacent face, each edge-adjacent face sharing an edge and two vertices with the current face; for at least a first one of the edge-adjacent faces, identifying a first decoded face associated with the first edge-adjacent face, wherein the first decoded face is identified from among a first set ef faces, the first set of faces 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 faces that are not the first edge-adjacent face; anddecoding a first indication of whether a first adjacent-face parameter associated with the first decoded face is equal to the current-face parameter.

9. A mesh decoding apparatus comprising one or more processors configured to perform at least: for a current face in a mesh having an associated current-face parameter, identifying at least one edge-adjacent face, each edge-adjacent face sharing an edge and two vertices with the current face; for at least a first one of the edge-adjacent faces, identifying a first decoded face associated with the first edge-adjacent face, wherein the first decoded face is identified from among a first set ef faces, the first set of faces 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 faces that are not the first edge-adjacent face; and decoding a first indication of whether a first adjacent-face parameter associated with the first decoded face is equal to the current-face parameter.

10. The method of claim 8 or the apparatus of claim 9, wherein the first indication is an indication that the first adjacent-face parameter associated with the first decoded face is not equal to the current-face parameter, the method further comprising: for a second one of the edge-adjacent faces, identifying a second decoded face associated with the second edge-adjacent face, wherein the second decoded face is identified from among a second set of faces, the second set of faces 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 faces that are not the second edge-adjacent face; and decoding a second indication of whether a second adjacent-face parameter associated with the second decoded face is equal to the current-face parameter.11 . The method of claim 10 as it depends from claim 8, or the apparatus of claim 10 as it depends from claim9, wherein the second indication is an indication that the second adjacent-face parameter associated with the second decoded face is not equal to the current-face parameter, the method further comprising: for a third one of the edge-adjacent faces, identifying a third decoded face associated with the second edge-adjacent face, wherein the third decoded face is identified from among a third set ef faces, the third set of faces 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 faces that are not the third edge- adjacent face; and decoding a third indication of whether an adjacent-face parameter associated with the third decoded face is equal to the current-face parameter.

12. The method of claim 11 as it depends from claim 8, or the apparatus of claim 11 as it depends from claim9, wherein the third indication is an indication that the third adjacent-face parameter associated with the third decoded face is not equal to the current-face parameter, the method further comprising decoding a value of the current-face parameter.

13. The method of claim 8 or claims 9-12 as they depend from claim 8, or the apparatus of claim 8 or claims9-12 as they depend from claim 8, further comprising: identifying a most-recently-decoded face in the mesh; and decoding a fourth indication of whether a fourth parameter associated with the most-recently- decoded face is equal to the current-face parameter.

14. The method of claim 8 or the apparatus of claim 9, wherein identifying the first decoded face associated with the first edge-adjacent face comprises: traversing the faces in the first set according to a predetermined order; and selecting the earliest-encountered decoded face in the predetermined order as the first decoded face.

15. The method of claim 14 as it depends from 8, or the apparatus of claim 14 as it depends from claim 9, wherein traversing the faces in the first set according to the predetermined order comprises: traversing the first edge-adjacent face; in response to a determination that the first edge-adjacent face is not decoded, 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 a determination that no decoded face has yet been traversed in the first set, traversing at least one face that shares a second vertex with both the current face and the first edge- adjacent face.

Images