Mesh Zippering

Abstract

Here we describe a method to improve mesh reconstruction by repositioning vertices on the boundary of patches to ensure there are no gaps between adjacent patches (also known as zippering). We disclose six different ways to implement the post-processing operation, as well as syntax elements and semantics for the transmission of filter parameters. A hierarchical method indicates geometric distortions that may cause gaps between patches. A value is transmitted per frame, or per patch, or per boundary object. The number of bits to encode the value also depends on the previous geometric distortion. Another method is to transmit an index match instead of a geometric distortion. A matching index is transmitted for each boundary vertex, but a method of transmitting only one index of a pair is also implemented.

Description

Technical Field

[0001] [Cross - Reference to Related Applications] This application claims priority under 35 U.S.C. § 119 to U.S. Provisional Patent Application No. 63 / 269,911, entitled "Mesh Zippering," filed on March 25, 2022, which is hereby incorporated by reference in its entirety for all purposes.

[0002] The present invention relates to 3D graphics. More specifically, the present invention relates to the coding of 3D graphics.

Background Art

[0003] In recent years, new methods for compressing volumetric content such as point clouds based on projection from 3D to 2D are being standardized. This method, also known as V3C (Visual Volume Video - based Compression), maps 3D volume data to several 2D patches, further arranges the patches in an atlas image, and then encodes them with a video encoder. The atlas image corresponds to the geometry of the points, their respective textures, and an occupancy map indicating which positions should be considered for point cloud reconstruction.

[0004] In 2017, MPEG conducted a Call for Proposals (CfP) for the compression of point clouds. After evaluating several proposals, currently, MPEG is considering two different techniques for point cloud compression, namely, 3D native coding techniques (based on octrees and similar coding methods), or performing conventional video coding after projection from 3D to 2D. For dynamic 3D scenes, MPEG is using Test Model Software (TMC2) based on patch surface modeling, projection of patches from 3D to 2D images, and coding of 2D images by a video encoder such as HEVC. This method has been found to be more efficient than native 3D coding and can achieve a competitive bitrate with acceptable quality.

[0005] Since coding 3D point clouds using projection-based methods (also known as video-based methods or V-PCC) has been successful, future versions of this standard are expected to include further 3D data, such as 3D meshes. However, the current version of this standard is only suitable for transmitting sets of unconnected points and lacks a mechanism for transmitting point connectivity, as required for 3D mesh compression.

[0006] Methods have also been proposed to extend the functionality of V-PCC to meshes. One possible method is to encode vertices using V-PCC and then encode connectivity using a mesh compression method such as TFAN or Edgebreaker. A limitation of this method is that the original mesh must be dense so that the point cloud generated from the vertices is not sparse and can be efficiently encoded after projection. Furthermore, since the order of vertices affects the coding of connectivity, different methods have been proposed for reorganizing the connectivity of the mesh. An alternative method for encoding sparse meshes is to encode the positions of 3D vertices using RAW patch data. Since RAW patches directly encode (x,y,z), in this method all vertices are encoded as RAW data, while connectivity is encoded by a similar mesh compression method as described above. Note that in RAW patches, vertices can be sent in any preferred order, so the order generated from connectivity encoding can be used. While this method can encode sparse point clouds, RAW patches are not efficient for encoding 3D data, and further data such as triangular face attributes may be missing from this method. [Overview of the project] [Problems that the invention aims to solve]

[0007] This specification describes a method (also known as zippering) for improving mesh reconstruction by repositioning vertices at patch boundaries to eliminate gaps between adjacent patches. Six different methods for implementing the post-processing operation, as well as syntactic elements and semantics for sending filter parameters, are disclosed. The hierarchical method indicates geometric distortions that may cause gaps between patches. Values ​​are sent per frame, per patch, or per boundary object. The number of bits used to encode the values ​​also depends on the previous geometric distortion. Alternatively, an index match can be sent instead of geometric distortion. Matching indices are sent per boundary vertex, but a method for sending only one index per pair is also implemented. [Means for solving the problem]

[0008] In one embodiment, a method programmed into the device's non-temporary memory includes the steps of: finding a plurality of boundary points; selecting a zippering implementation from a plurality of mesh zippering implementations; and merging vertices based on the selected mesh zippering implementation. The plurality of mesh zippering implementations include a sequence-by-sequence fixed-value implementation, a sequence-by-sequence maximum strain implementation, a frame-by-frame maximum strain implementation, a patch-by-patch maximum strain implementation, a boundary point implementation, and a matched patch / vertex index implementation. The sequence-by-sequence fixed-value implementation includes limiting the scope of the search for matching boundary points based on distance. The boundary point implementation includes receiving strain information without performing a search. The matched patch / vertex index implementation includes matching indices. The step of selecting the zippering implementation from the plurality of mesh zippering implementations is programmed. The step of selecting the zippering implementation from the plurality of mesh zippering implementations is adaptively selected based on a set of detected criteria.

[0009] In another embodiment, the device includes non-temporary memory for storing an application, the application being for finding a plurality of boundary points, selecting a zippering implementation from a plurality of mesh zippering implementations, and merging vertices based on the selected mesh zippering implementation; and a processor coupled to the memory and configured to process the application. The plurality of mesh zippering implementations include a sequence-by-sequence fixed-value implementation, a sequence-by-sequence maximum strain implementation, a frame-by-frame maximum strain implementation, a patch-by-patch maximum strain implementation, a boundary point implementation, and a matched patch / vertex index implementation. The sequence-by-sequence fixed-value implementation includes limiting the scope of the search for matching boundary points based on distance. The boundary point implementation includes receiving strain information without performing a search. The matched patch / vertex index implementation includes a matching index. The selection of the zippering implementation from the plurality of mesh zippering implementations is programmed. The selection of the zippering implementation from the plurality of mesh zippering implementations is adaptively selected based on a set of criteria found.

[0010] In another embodiment, the system includes an encoder configured to encode content, and a decoder configured to find a plurality of boundary points of the content, select a zippering implementation from a plurality of mesh zippering implementations, and merge vertices based on the selected mesh zippering implementation. The plurality of mesh zippering implementations include a fixed-value implementation per sequence, a maximum strain implementation per sequence, a maximum strain implementation per frame, a maximum strain implementation per patch, a boundary point implementation, and a matched patch / vertex index implementation. The fixed-value implementation per sequence includes limiting the scope of the search for matching boundary points based on distance. The boundary point implementation includes receiving strain information without performing a search. The matched patch / vertex index implementation includes a matching index. The selection of the zippering implementation from the plurality of mesh zippering implementations is programmed. The selection of the zippering implementation from the plurality of mesh zippering implementations is adaptively selected based on a set of criteria found. [Brief explanation of the drawing]

[0011] [Figure 1] This figure shows flowcharts of mesh zippering methods according to several embodiments. [Figure 2] This figure shows images of zippering configurations according to several embodiments. [Figure 3] This figure shows images illustrating the advantages and disadvantages of various zipper ring implementations according to several embodiments. [Figure 4] This is a block diagram of an exemplary computer device configured to implement a mesh zippering method according to several embodiments. [Modes for carrying out the invention]

[0012] This specification describes a method (also known as zippering) for improving mesh reconstruction by repositioning vertices at patch boundaries to eliminate gaps between adjacent patches. Six different methods for implementing the post-processing operation, as well as syntactic elements and semantics for sending filter parameters, are disclosed. The hierarchical method indicates geometric distortions that may cause gaps between patches. Values ​​are sent per frame, per patch, or per boundary object. The number of bits used to encode the values ​​also depends on the previous geometric distortion. Alternatively, an index match can be sent instead of geometric distortion. Matching indices are sent per boundary vertex, but a method for sending only one index per pair is also implemented.

[0013] As described in U.S. Patent Application No. 17 / 161,300, “Projection-Based Mesh Compression,” filed on 28 January 2021, and U.S. Provisional Patent Application No. 62 / 991,128, “Projection-Based Mesh Compression,” filed on 18 March 2020 (these applications are incorporated herein by reference in their entirety for all purposes), zippering addresses the problem of vertex displacement.

[0014] Figure 1 shows flowcharts of mesh zippering methods according to several embodiments. In step 100, boundary points are found. Boundary points can be found by any method. After finding boundary points, mesh zippering is implemented. Mesh zippering includes determining adjacent vertices of boundary vertices and merging specific adjacent boundary vertices. Mesh zippering can be implemented using one or more different implementations. Mesh zippering is used to find matching points / vertices and remove gaps in the mesh. To find matching points, the search is performed by searching for adjacent points of a point in 3D space. The range of the search can be limited (for example, based on a fixed value such as a maximum distance of 5, or based on maximum distortion). Therefore, if the distance is greater than 5, a point cannot find a matching point. The search can also be limited based on maximum distortion. The maximum distortion of each point may be different. Sequence-by-sequence mesh zippering can limit the search using distance or maximum distortion. Since searching based on maximum distortion may be too time-consuming or computationally expensive for the entire sequence, it may be better to search frame by frame. For example, most frames are searched based on a fixed value (e.g., maximum distance), but a particular frame is searched based on maximum distortion. Maximum distortion can be implemented per patch. For example, there may be a large patch with small distortion. In another example, there may be a small patch with large distortion. Distortion can be sent per boundary / boundary point. In this implementation, no search is performed; rather, distortion is applied when it is received. However, since more distortion information is sent, the bitrate will be higher, but the mesh reconstruction will be better (e.g., more accurate).

[0015] In step 102, implement frame-by-frame zippering. As explained, zippering uses maximum strain to search each point within a frame. By performing zippering frame by frame rather than the entire sequence, some processing is performed without strain information, and only frames with greater strain use zippering based on maximum strain. In step 104, implement patch-by-patch zippering. By performing patch-by-patch zippering, some processing is performed without strain information, and only patches with greater strain use zippering based on maximum strain. In step 106, implement boundary point zippering. No search is performed in boundary point zippering; rather, strain is applied as it is received. However, more strain information is transmitted, resulting in a higher bitrate, but the mesh reconstruction is better (e.g., more accurate). In step 108, implement zippering border point match. Indices that match each other are transmitted. The decoder determines where the patch will be placed in 3D space based on matching vertices (e.g., by averaging the distance between two points or by selecting one of the points). The zippering implementation can be selected in any way, such as being programmed or adaptively selected based on a set of detected criteria (e.g., by detecting if a frame or patch contains a distortion amount exceeding a threshold).

[0016] In step 110, the vertices are merged. Vertex merging can be performed in any way. In some embodiments, fewer or additional steps are implemented. In some embodiments, the order of the steps is changed. The zippering implementation is performed on the decoder side.

[0017] Figure 2 shows images of zippering in several embodiments. Image 200 shows that gaps may exist between boundary points. In Image 202, zippering is applied to boundary vertices to narrow or eliminate gaps. As previously mentioned, zippering includes classifying vertices as boundary vertices or non-boundary vertices, determining adjacent vertices to boundary vertices, and merging adjacent boundary vertices. Image 204 shows a gapless decoded image obtained by utilizing zippering.

[0018] Figure 3 shows images illustrating the advantages and disadvantages of various zippering implementations according to several embodiments. Image 300 is the original image. Image 302 is without zippering, at 12.172 Mbps. Image 304 is with zippering, at 12.222 Mbps. Image 306 is with zippering, at 13.253 Mbps. Image 308 is with zippering, at 13.991 Mbps. Zippering can fill gaps in areas such as the face, hair, and ears.

[0019] The updated zippering syntax is described below. TIFF0007881739000001.tif223169 TIFF0007881739000002.tif219169 TIFF0007881739000003.tif106169 gs_zippering_max_match_distance[k] specifies the value of the variable zipperingMaxMatchDistance[k] used to process the current mesh frame of the geometry smoothing instance at index k when the zippering filtering process is used. If gs_zippering_send_border_point_match[k] is equal to 1, it specifies that zippering by sending a matching index will be applied to the boundary point of the geometry smoothing instance at index k. When gs_zippering_send_border_point_match[ k ] is equal to 0, it specifies that zippering by sending the matching index is not applied to the border points of the geometry smoothing instance at index k. The default value of gs_zippering_send_border_point_match[ k ] is 0. gs_zippering_number_of_patches[ k ] indicates the number of patches filtered by the current SEI message. The value of gs_zippering_number_of_patches must be in the range from 0 to MaxNumPatches[ frameIdx ]. The default value of gs_zippering_number_of_patches is 0. gs_zippering_number_of_border_points[ k ][ p ] indicates the number of border points numBorderPoints[ p ] of the patch at index p. gs_zippering_border_point_match_patch_index[ k ][ p ][ b ] specifies the value of the variable zipperingBorderPointMatchPatchIndex[ k ][ p ][ b ] used to process the current border point at index b in the current patch at index p within the current mesh frame of the geometry smoothing instance at index k when the zippering filtering process is used. gs_zippering_border_point_match_border_point_index[ k ][ p ][ b ] specifies the value of the variable zipperingBorderPointMatchBorderPointIndex[ k ][ p ][ b ] used to process the current border point at index b in the current patch at index p within the current mesh frame of the geometry smoothing instance at index k when the zippering filtering process is used. When gs_zippering_send_distance_per_patch[ k ] is equal to 1, it specifies that zippering by sending the matching distance per patch is applied to the boundary points of the geometry smoothing instance at index k. When gs_zippering_send_distance_per_patch[ k ] is equal to 0, it specifies that zippering by sending the matching distance per patch is not applied to the boundary points of the geometry smoothing instance at index k. The default value of gs_zippering_send_distance_per_patch[ k ] is 0. When gs_zippering_send_distance_per_border_point[ k ] is equal to 1, it specifies that zippering by sending the matching distance per border point is applied to the boundary points of the geometry smoothing instance at index k. When gs_zippering_send_distance_per_border_point[ k ] is equal to 0, it specifies that zippering by sending the matching distance per border point is not applied to the boundary points of the geometry smoothing instance at index k. The default value of gs_zippering_send_distance_per_border_point[ k ] is 0. gs_zippering_max_match_distance_per_patch[ k ] specifies the value of the variable zipperingMaxMatchDistancePerPatch[ k ][ p ] used to process the current patch at index p within the current mesh frame of the geometry smoothing instance at index k when the zippering filtering process is used. gs_zippering_border_point_distance[k][p][b] specifies the value of the variable zipperingMaxMatchDistancePerBorderPoint[k][p][b] used when the zippering filtering process is used to process the current boundary point of index b in the current patch of index p within the current mesh frame of the geometry smoothing instance of index k.

[0020] As explained, trade-offs can be achieved by choosing different zippering methods. This includes using only one SEI message when sending a single distance for the entire sequence, or sending an SEI message per frame when sending distances per frame, patch, or boundary distance. However, the subjective impact can be significant, as the chosen zippering method may or may not reveal gaps.

[0021] Figure 4 shows a block diagram of an exemplary computer device configured to implement a mesh zippering method according to several embodiments. The computer device 400 can be used to acquire, store, compute, process, communicate, and / or display information such as images and videos, including 3D content. The computer device 400 can implement any form of encoding / decoding. Generally, a suitable hardware structure for implementing the computer device 400 includes a network interface 402, memory 404, a processor 406, (one or multiple) I / O devices 408, a bus 410, and a storage device 412. The choice of processor is not critical as long as a suitable processor of sufficient speed is selected. The memory 404 can be any conventional computer memory known in the art. The storage device 412 can include a hard drive, CD-ROM, CDRW, DVD, DVDRW, high-definition disk / drive, ultra-high-definition drive, flash memory card, or any other storage device. The computer device 400 can include one or more network interfaces 402. Examples of network interfaces include a network card connected to Ethernet or other types of LANs. The (single or duplicate) I / O devices 408 may include one or more of the following: keyboards, mice, monitors, screens, printers, modems, touchscreens, button interfaces, and other devices. The storage devices 412 and memory 404 store the (single or duplicate) mesh zippering applications 430 used to carry out the implementation of mesh zippering, and are likely to be processed as the application would normally be processed. The computer device 400 may also include more or fewer components than those shown in Figure 4. In some embodiments, mesh zippering hardware 420 is included. The computer device 400 in Figure 4 includes the application 430 and hardware 420 for the implementation of mesh zippering, but the mesh zippering method may also be implemented on the computer device in hardware, firmware, software, or a combination of these.For example, in some embodiments, the mesh zippering application 430 is programmed in memory and executed using a processor. In another example, in some embodiments, the mesh zippering hardware 420 is programmed hardware logic including gates specifically designed to implement the mesh zippering method.

[0022] In some embodiments, the (single or multiple) mesh zippering application 430 includes multiple applications and / or modules. In some embodiments, a module also includes one or more submodules. In some embodiments, fewer or more modules may be included.

[0023] Examples of suitable computer devices include personal computers, laptop computers, computer workstations, servers, mainframe computers, handheld computers, personal digital assistants (PDAs), cellular / mobile phones, smart home appliances, game consoles, digital cameras, digital camcorders, camera phones, smartphones, portable music players, tablet computers, mobile devices, video players, video disc writers / players (e.g., DVD writers / players, high-definition disc writers / players, ultra-high-definition disc writers / players), televisions, home entertainment systems, augmented reality devices, virtual reality devices, smart jewelry (e.g., smartwatches), vehicles (e.g., autonomous vehicles), or any other suitable computer device.

[0024] To utilize the mesh zippering method, the device acquires or receives 3D content (e.g., point cloud content). The mesh zippering method can be implemented with or without user assistance.

[0025] During operation, the mesh zippering method enables more efficient and accurate 3D content decoding compared to conventional implementations.

[0026] Several embodiments of mesh zippering 1. A method programmed into the non-temporary memory of a device, Steps to find multiple boundary points, The steps include selecting a zippering implementation from multiple mesh zippering implementations, A step of merging vertices based on the selected mesh zippering implementation, A method that includes this.

[0027] 2. The aforementioned multiple mesh zippering implementations are, Fixed value implementation for each sequence, Implementation of maximum distortion per sequence, Implementation of maximum distortion per frame, Maximum distortion implementation for each patch, Implementation for each boundary point, Matching patch / vertex index implementation, The method described in paragraph 1, including the method described in paragraph 1.

[0028] 3. The method according to paragraph 2, wherein the fixed-value implementation for each sequence includes limiting the range of searching for matching boundary points based on distance.

[0029] 4. The method described in paragraph 2, wherein the implementation for each boundary point includes receiving distortion information without performing a search.

[0030] 5. The matching patch / vertex index implementation is the method described in Section 2, including the matching index.

[0031] 6. The step of selecting the zippering implementation from the plurality of mesh zippering implementations is programmed, as described in paragraph 1.

[0032] 7. The method of paragraph 1, wherein the step of selecting the zipper ring implementation from the plurality of mesh zipper ring implementations is adaptively selected based on a set of detected criteria.

[0033] 8. A device, Non-temporary memory for storing applications, wherein the applications are Finding multiple boundary points, Selecting a zippering implementation from multiple mesh zippering implementations, Merging vertices based on the selected mesh zippering implementation, Non-temporary memory is used to perform this task, A processor coupled to the memory and configured to process the application, A device that includes this.

[0034] 9. The aforementioned multiple mesh zippering implementations are Fixed value implementation for each sequence, Implementation of maximum distortion per sequence, Implementation of maximum distortion per frame, Maximum distortion implementation for each patch, Implementation for each boundary point, Matching patch / vertex index implementation, The apparatus described in paragraph 8, including the apparatus described in paragraph 8.

[0035] 10. The apparatus according to paragraph 9, wherein the fixed-value implementation for each sequence includes limiting the range of searching for matching boundary points based on distance.

[0036] 11. The implementation for each boundary point is the apparatus described in paragraph 9, which includes receiving strain information without performing a search.

[0037] 12. The matching patch / vertex index implementation is the device described in Section 9, which includes the matching index.

[0038] 13. The apparatus described in Section 8 is programmed to select the zippering implementation from the plurality of mesh zippering implementations.

[0039] 14. The apparatus described in paragraph 8, wherein the selection of the zipper ring implementation from the plurality of mesh zipper ring implementations is adaptively selected based on a set of detected criteria.

[0040] 15. A system, An encoder configured to encode content, Find multiple boundary points of the aforementioned content, Select a zippering implementation from multiple mesh zippering implementations. Based on the selected mesh zippering implementation, merge the vertices. A decoder configured as follows, A system that includes this.

[0041] 16. The above-mentioned multiple mesh zippering implementations are, Fixed value implementation for each sequence, Implementation of maximum distortion per sequence, Implementation of maximum distortion per frame, Maximum distortion implementation for each patch, Implementation for each boundary point, Matching patch / vertex index implementation, The system described in paragraph 15, including the system described in paragraph 15.

[0042] 17. The system described in paragraph 16, wherein the fixed-value implementation for each sequence includes limiting the range of the search for matching boundary points based on distance.

[0043] 18. The implementation for each boundary point is the system described in Section 16, which includes receiving distortion information without performing a search.

[0044] 19. The matching patch / vertex index implementation is the system described in Section 16, which includes the matching index.

[0045] 20. The system described in Section 15 is programmed to select the zippering implementation from the plurality of mesh zippering implementations.

[0046] 21. The system described in paragraph 15, wherein the selection of the zippering implementation from the plurality of mesh zippering implementations is adaptively selected based on a set of detected criteria.

[0047] The present invention has been described in relation to specific embodiments, including details, to facilitate understanding of its structure and operating principles. Such references to specific embodiments and their details herein are not intended to limit the claims appended herein. Those skilled in the art will readily see that various other modifications can be made to the embodiments selected for illustrative purposes without departing from the spirit and scope of the invention as defined by the claims. [Explanation of symbols]

[0048] Find 100 boundary points. 102 Zippering per frame 104 Zippering per patch 106 Zippering at each boundary point 108 Zippering of Boundary Point Match Merge 110 vertices 200 images 202 images 204 images 300 images 302 images 304 images 306 images 308 images 400 Computer devices 402 Network Interface 404 memory 406 Processors 408 I / O devices 410 Bus 412 Storage device 420 Mesh Zippering Hardware 430 Mesh Zippering Application

Claims

1. A method programmed into the device's non-temporary memory, The steps include finding multiple boundary points, which are vertices located at the patch boundary among the vertices that make up the mesh, The steps include selecting a zippering implementation from multiple mesh zippering implementations, A step of merging vertices based on the selected mesh zippering implementation, Includes, The aforementioned multiple mesh zipper implementations are, Fixed value implementation for each sequence, Implementation of maximum distortion per sequence, Implementation of maximum distortion per frame, Maximum distortion implementation for each patch, Implementation for each boundary point, Matching patch / vertex index implementation, A method characterized by including the following.

2. The method according to claim 1, characterized in that the fixed value implementation for each sequence includes limiting the range of searching for matching boundary points based on distance.

3. The method according to claim 1, characterized in that the implementation for each boundary point includes receiving distortion information without performing a search.

4. The method according to claim 1, characterized in that the matching patch / vertex index implementation includes matching indices.

5. The method according to claim 1, characterized in that the step of selecting the zipper ring implementation from the plurality of mesh zipper ring implementations is programmed.

6. The method according to claim 1, characterized in that the step of selecting the zipper ring implementation from the plurality of mesh zipper ring implementations is adaptively selected based on a set of detected criteria.

7. It is a device, Non-temporary memory for storing applications, wherein the applications are Finding multiple boundary points, which are vertices located at the patch boundaries among the vertices that make up the mesh, Selecting a zippering implementation from multiple mesh zippering implementations, Merging vertices based on the selected mesh zippering implementation, Non-temporary memory is used to perform this task, A processor coupled to the non-temporary memory and configured to process the application, Includes, The aforementioned multiple mesh zipper implementations are, Fixed value implementation for each sequence, Implementation of maximum distortion per sequence, Implementation of maximum distortion per frame, Maximum distortion implementation for each patch, Implementation for each boundary point, Matching patch / vertex index implementation, An apparatus characterized by including

8. The apparatus according to claim 7, characterized in that the fixed value implementation for each sequence includes limiting the range of searching for matching boundary points based on distance.

9. The apparatus according to claim 7, characterized in that the implementation for each boundary point includes receiving strain information without performing a search.

10. The apparatus according to claim 7, characterized in that the matching patch / vertex index implementation includes matching indices.

11. The apparatus according to claim 7, characterized in that the selection of the zipper ring implementation from the plurality of mesh zipper ring implementations is programmed.

12. The apparatus according to claim 7, characterized in that the selection of the zipper ring implementation from the plurality of mesh zipper ring implementations is adaptively selected based on a set of detected criteria.

13. It is a system, An encoder configured to encode content, Find multiple boundary points of the content, which are vertices located at the patch boundaries among the vertices that make up the mesh. Select a zippering implementation from multiple mesh zippering implementations. Based on the selected mesh zippering implementation, merge the vertices. A decoder configured as follows, Includes, The aforementioned multiple mesh zipper implementations are, Fixed value implementation for each sequence, Implementation of maximum distortion per sequence, Implementation of maximum distortion per frame, Maximum distortion implementation for each patch, Implementation for each boundary point, Matching patch / vertex index implementation, A system characterized by including

14. The system according to claim 13, characterized in that the fixed value implementation for each sequence includes limiting the range of searching for matching boundary points based on distance.

15. The system according to claim 13, characterized in that the implementation for each boundary point includes receiving distortion information without performing a search.

16. The system according to claim 13, characterized in that the matching patch / vertex index implementation includes matching indices.

17. The system according to claim 13, characterized in that the selection of the zippering implementation from the plurality of mesh zippering implementations is programmed.

18. The system according to claim 13, characterized in that the selection of the zipper ring implementation from the plurality of mesh zipper ring implementations is adaptively selected based on a set of detected criteria.

Images