ORTHOATLAS: Texture Map Generation for Dynamic Meshes Using Orthogonal Projection

Abstract

Texture map generation using orthogonal projection is fast and efficient. A method for generating texture maps is described herein that significantly reduces the time required and allows the maps to exploit correlations between content at different frames in time. Texture mapping can be used for automatic generation of volumetric content or for more efficient compression of dynamic meshes. The texture map generation described herein includes a method for generating texture atlases using orthogonal projection. A new stretch metric for orthogonal projection is described, and a merging algorithm is devised to optimally cluster triangles into a single patch. Additionally, packing techniques can be used for mesh patches that seek to optimize size and temporal stability.

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 / 378,565, entitled "ORTHOATLAS: TEXTURE MAP GENERATION FOR DYNAMIC MESHES USING ORTHOGRAPHIC PROJECTIONS," filed October 6, 2022, which is incorporated herein by reference in its entirety for all purposes.

[0002] The present invention relates to three-dimensional graphics, and more particularly to generating texture maps using orthogonal projection. [Background technology]

[0003] Recently, a new method for compressing volumetric content such as point clouds based on 3D-to-2D projections has been standardized. Also known as V3C (visual volumetric video-based compression), this method maps 3D volume data into a number of 2D patches, which are then arranged into an atlas image, which is then encoded by a video encoder. The atlas image corresponds to the geometry of the points, their respective textures, and an occupancy map that indicates which locations should be considered for point cloud reconstruction.

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

[0005] Due to the success of coding 3D point clouds with projection-based methods (also known as video-based methods, or V-PCC), it is expected that future versions of this standard will include additional 3D data, such as 3D meshes. However, the current version of this standard is only suitable for transmitting sets of unconnected points, and therefore does not have 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 approach 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 approach is that the original mesh must be dense so that the point cloud generated from the vertices can be efficiently encoded after projection, rather than being sparse. Furthermore, because the order of vertices affects connectivity coding, different methods have been proposed to reorganize mesh connectivity. An alternative approach to encoding sparse meshes is to use raw patch data to encode the 3D vertex positions. Because raw patches directly encode (x,y,z), in this method, all vertices are encoded as raw data, while connectivity is encoded using a similar mesh compression method, as described above. Note that in raw patches, vertices can be transmitted in any preferred order, so the order generated from connectivity coding can be used. While this method can encode sparse point clouds, raw patches are not efficient for encoding 3D data, and additional data, such as triangular face attributes, may be missing from this method.

[0007] Microsoft's UVAtlas is the state-of-the-art automatic texture map generation, but it takes a significant amount of time and only optimizes for local frames. V-PCC generates patches using orthogonal projection, but only for point clouds, so it does not support patch generation for meshes. Summary of the Invention [Problem to be solved by the invention]

[0008] Texture map generation using orthogonal projection is fast and efficient. This specification describes a method for generating texture maps that significantly reduces the time required and allows the maps to exploit correlations between content at different frames in time. Texture mapping can be used for automatic generation of volumetric content or for more efficient compression of dynamic meshes. The texture map generation described here includes a method for generating texture atlases using orthogonal projection. A new stretch metric for orthogonal projection is described, and a merging algorithm is devised to optimally cluster triangles into a single patch. Additionally, packing techniques can be used for mesh patches that seek to optimize size and temporal stability. [Means for solving the problem]

[0009] In one aspect, a method programmed into a non-transitory memory of a device includes generating patches from dynamic mesh information and packing the patches into a texture atlas using orthogonal projection. The step of generating the patches from dynamic mesh information further includes generating a list of adjacent triangles, calculating triangle properties, adding neighboring triangles, checking vertex occlusion, and checking surface occlusion. Generating the list of adjacent triangles includes adding triangles that share vertices with a triangle to the list. Generating the list of adjacent triangles includes adding triangles that share edges with a triangle to the list. Calculating triangle properties includes calculating the normal and surface area of ​​each triangle. The method further includes selecting a seed triangle whose normal best aligns with the most frequent orientation and that has not been added to the patch. The method further includes merging the patches based on a calculated cost, the calculated cost being based on the perimeter and ortho stretch value of the patch. Packing the patches into the texture atlas using orthogonal projection includes implementing frame scaling, patch orientation, and temporal stabilization.

[0010] In another aspect, an apparatus includes: a non-transitory memory for storing an application for generating patches from dynamic mesh information and packing the patches into a texture atlas using orthogonal projection; and a processor coupled to the memory and configured to process the application. Generating the patches from dynamic mesh information further includes generating a list of adjacent triangles, calculating triangle properties, adding neighboring triangles, checking vertex occlusion, and checking surface occlusion. Generating the list of adjacent triangles includes adding triangles that share vertices with a triangle to the list. Generating the list of adjacent triangles includes adding triangles that share edges with a triangle to the list. Calculating triangle properties includes calculating a normal and a surface area of ​​each triangle. The application is further configured to select a seed triangle whose normal best aligns with the most frequent orientation and that has not been added to the patch. The application is further configured to merge the patches based on a calculated cost, the calculated cost being based on a perimeter and an ortho stretch value of the patch. Packing the patches into the texture atlas using orthogonal projection includes implementing frame scaling, patch orientation, and temporal stabilization.

[0011] In another aspect, a system includes one or more cameras for capturing three-dimensional content and an encoder configured to generate patches from dynamic mesh information and pack the patches into a texture atlas using orthogonal projection. Generating the patches from dynamic mesh information further includes generating a list of adjacent triangles, calculating triangle properties, adding neighboring triangles, checking vertex occlusion, and checking surface occlusion. Generating the list of adjacent triangles includes adding triangles that share vertices with a triangle to the list. Generating the list of adjacent triangles includes adding triangles that share edges with a triangle to the list. Calculating triangle properties includes calculating a normal and a surface area of ​​each triangle. The encoder is further configured to select a seed triangle whose normal best aligns with the most frequent orientation and that has not been added to the patch. The encoder is further configured to merge the patches based on a calculated cost, the calculated cost being based on the perimeter and ortho stretch value of the patch. Packing the patches into the texture atlas using orthogonal projection includes implementing frame scaling, patch orientation, and temporal stabilization. [Brief explanation of the drawings]

[0012] [Figure 1] FIG. 1 is a diagram of texture parameterization according to some embodiments. [Figure 2] FIG. 1 is an illustration of adjacent triangle analysis according to some embodiments. [Figure 3] FIG. 10 is a diagram illustrating calculating properties of a triangle according to some embodiments. [Figure 4] FIG. 1 is a diagram illustrating seed selection according to some embodiments. [Figure 5] 1A-1C are diagrams of different sets of connected components according to some embodiments. [Figure 6] FIG. 10 illustrates performing ortho-stretching according to some embodiments. [Figure 7] FIG. 10 illustrates the results of ortho-stretching according to some embodiments. [Figure 8] FIG. 1 is a diagram of packing according to some embodiments. [Figure 9] 1A-1C illustrate images of frame scaling according to some embodiments. [Figure 10] FIG. 10 illustrates an image of a patch orientation according to some embodiments. [Figure 11] FIG. 10 illustrates an image of temporal stabilization according to some embodiments. [Figure 12] FIG. 1 is a block diagram of an exemplary computing device configured to implement a texture map generation method using orthographic projection according to some embodiments. DETAILED DESCRIPTION OF THE INVENTION

[0013] A mesh typically consists of a set of polygons representing the surface of a volume. An efficient way to represent the surface properties (e.g., color properties) of a mesh is to generate a texture atlas that maps the 3D surface properties to a 2D surface. However, mapping a 3D surface to 2D is not a trivial problem, and state-of-the-art methods, such as Microsoft's UVAtlas, perform time-consuming optimizations to find appropriate cuts in the mesh and map them using surface harmonics. The latest international point cloud compression standards generate texture map images for point clouds using orthogonal projection. While texture map images are easy to generate, they are used only for point clouds and do not take into account the connectivity structure present in the mesh. The method described herein can generate texture images for meshes using orthogonal projection, similar to that used in the V-PCC standard. Texture mapping can be used for automatic generation of volumetric content or for more efficient compression of dynamic meshes.

[0014] The texture map generation described herein includes a method for generating a texture atlas using orthogonal projection. A new stretch metric for orthogonal projection is described, and a merging algorithm is devised to optimally cluster triangles into a single patch. Additionally, packing techniques can be used for mesh patches that seek to optimize size and temporal stability.

[0015] Texture map generation using orthogonal projection involves patch generation and patch packing. Patch generation involves seed selection using connected components (e.g., triangles that share edges / vertices), orthostretching, which is a projection distortion measure for orthogonal projection, and a rate-distortion-based merging algorithm using orthostretching and patch perimeter. Patch packing involves frame / patch scaling, patch rotation, and temporal alignment.

[0016] Figure 1 shows a diagram of texture parameterization according to some embodiments. In step 100, patches are generated. After the patches are generated, in step 102, the patches are packed. For example, the patches are packed into a texture atlas.

[0017] Generating the patches includes generating connected components in step 110 and projecting in step 130 .

[0018] Generating connected components includes generating a list of neighboring triangles in step 112, calculating triangle properties for each triangle in step 114, selecting a seed (triangle) in step 116, adding neighboring triangles from neighboring triangles according to criteria in step 118, restarting the process with a different seed (triangle) in step 116 if there are any triangles that cannot be added to the patch after checking all neighboring triangles, and merging patches to generate a large surface of connected triangles in step 120 if no triangles remain. Projection is performed, which includes checking for vertex occlusion in step 132 and checking for surface occlusion in step 134. If there is vertex occlusion or surface occlusion, the triangle is removed from the patch and included in a different patch.

[0019] Figure 2 shows an illustration of adjacent triangle analysis according to some embodiments. Triangle 200 has many adjacent and neighboring triangles. A triangle's neighborhood can be defined by sharing a single vertex (params.useVertexCriteria=true) or by sharing an edge (params.useVertexCriteria=false). An adjacent triangle is a triangle that shares at least one vertex with the specified triangle. For example, triangles 1-15 {T1, ..., T 15} all share a vertex with triangle 200. Neighboring triangles share an edge with triangle 200. For example, triangles 4, 10, and 14 {T4, T 10 , and T 14} shares an edge with triangle 200. A list of adjacent and neighboring triangles can be kept for each triangle. A flag can also be included to keep bounds.

[0020] Figure 3 shows a diagram of calculating triangle properties according to some embodiments. For each triangle, several properties are calculated (e.g., normals and surface area in 3D). The surface area and normals of a triangle can be derived from the projected area.

[0021] Figure 4 shows a diagram of selecting seeds according to some embodiments. The most frequent orientation is obtained by checking a histogram of triangle categories. If params.bUseSeedHistogram=true, the seed is the triangle whose normals best align with the most frequent orientation and that has not been added to a connected component. If params.bUseSeedHistogram=false, the seed is the first available triangle (e.g., not yet a connected component).

[0022] To add a neighboring triangle to the list, the following criteria are checked: whether the triangle category is the same as the orientation of the connected component, whether the angle between the last inserted normal and the current normal is less than a certain threshold, whether the area of ​​the patch is less than a fraction of the total area, and whether the number of triangles is less than a threshold. In some embodiments, a neighboring triangle is added to the list only if all of the above criteria are met.

[0023] FIG. 5 illustrates a diagram of different sets of connected components according to some embodiments.

[0024] The merge function merges neighboring connected components according to a cost based on the perimeter and orthostretch (e.g., orthographic stretch) of the connected components. The merge algorithm starts by generating an ordered list of connected components. The list is ordered by 1) the fewest number of triangles, and 2) the average normal that best aligns with the orientation (weighted by the triangle area). Each connected component is assigned a cost, COST(M i )=L 2 (M i)+λPERIMETER(M i ), where M i is the connected component, L is the rate-distortion, and λ is a parameter that provides a weighting between rate-distortion and perimeter. If λ is 0, perimeter is not considered in the cost. If λ is a very high value, only perimeter is considered in the cost, and rate-distortion becomes irrelevant. Continuing this example, if there are very few bits available, distortion is not very important and a very large value for λ is used. If quality is very important, λ will be 0 or very small, and distortion will be minimized in order to minimize cost.

[0025] If the list is not empty, the following steps are performed: The top element of the list (M i ) is deleted; A list of nearby triangle candidates ( TIFF2025532407000002.tif13150 is obtained, where TIFF2025532407000003.tif13150 is M i is a list of connected components that share an edge / vertex with For each neighbor candidate: Calculate the merge cost: COST(M i +M j )=L 2 (M i +M j )+λPERIMETER(Mi); If the cost is reduced by a merge operation with one of the neighboring triangles (connected components that share at least one edge), then COST(M i +M j ) <COST(M i )+COST(M j )), select the neighboring triangles that minimize the join cost: TIFF2025532407000004.tif20150 If neighboring triangles are selected for merging, the connected components (M i →M j) and sort the list.

[0026] FIG. 6 illustrates performing ortho-stretching according to some embodiments. Functions (e.g., projection functions) that map points in 3D space to 2D space are described herein. Connecting points in 3D space to points in 2D space is barycentric interpolation. Barycentric interpolation uses the area of ​​the projected triangle to generate weights, which are then used to derive any point on the surface. This can be done in any direction (e.g., x, y, z). For example, triangles within triangle 600 (and other triangles) can be generated by connecting vertices to point p. The value of point p in 3D space can then be obtained by interpolating the areas of those triangles in projected space. The value q can be obtained by weighting the points at vertices q1, q2, and q3 by the area of ​​the projected triangle. The ratio of areas is found by solving the following equation, regenerating the point in 3D space based on the projection in 2D space: S XY (p)=q TIFF2025532407000005.tif20113 where, TIFF2025532407000006.tif28107 Given the above, it is possible to obtain the Jacobian of the function. By decomposing the Jacobian into its eigenvalues ​​and eigenvectors, the stretch (e.g., reduction in size of a triangle from 3D space to 2D space) can be determined. The stretch is the ratio of the areas of the 3D and 2D spaces. In some embodiments, the area has been pre-computed, so the stretch can be calculated in advance or quickly. JPEG2025532407000008.jpg1855 JPEG2025532407000009.jpg2294 Maximum (Γ) and minimum (Υ) singular values: TIFF2025532407000010.tif19130 where, JPEG2025532407000011.jpg34103 Triangle Stretch L 2 XY , L 2 XZ , L 2 ZY : TIFF2025532407000012.tif61119Mesh L 2 stretch: JPEG2025532407000013.jpg35156 where, TIFF2025532407000014.tif12113

[0027] FIG. 7 illustrates the results of ortho-stretching according to some embodiments. The original mesh 700 has 2351 connected components (e.g., initially individual triangles), a perimeter of 186071, and a stretch of 1.0978. Mesh 702 performs clustering with neighboring triangles (without additional analysis), resulting in 251 connected components and a reduced perimeter of 50721.7, but a slight increase in stretch to 1.14037. Mesh 704 also implements merging, resulting in 55 connected components and a perimeter of 28935.2, but a stretch of 1.6506. With 55 connected components, significantly fewer bits are required. Mesh 706 performs projection analysis (e.g., ensuring connected components do not overlap), resulting in 68 connected components, a perimeter of 31455.1, and a stretch of 1.69315. Projection allows texture coordinates to be determined by the projection information.

[0028] Figure 8 shows a diagram of packing according to some embodiments. After patches (e.g., connected components) are generated, the patches are placed on 2D images in a video, and then the video is encoded. The patches are scaled to fit the surface (e.g., frame scaling). Patch scaling is implemented for each patch.

[0029] Figure 9 shows an image of frame scaling according to some embodiments. An initial scaling is used to generate a projection that occupies most of the texture map surface. For example, for a 2Kx2K surface, patches are adjusted to occupy the surface as efficiently as possible. The size of the patches is maximized to occupy the entire surface. If packing is not successful, the scaling is reduced by 10% (or another value) to provide more space for the projected connected components. TIFF2025532407000015.tif26150, where adjustment is a scaling value (e.g., 10%), BB is the dimension of the bounding box 900, height is the height of the texture map 902, and occRes is the occupied resolution, which is the resolution of a 16x16 (or other sized) block, not in pixels.

[0030] In the example image, BB Y is the maximum dimension, so the height of the texture map is BB Y The height of the patch is set to be close to or equal to the height of the texture map. However, it is possible that the patch is too large to fit into the texture map. If the patches are too large, all patches are scaled down by 10%. If the scaled down patches still do not fit into the texture map, the patches are scaled down by another 10%, and the process loops until the patches fit into the texture map.

[0031] For each patch, the scale, orientation, and position of the patch can be adjusted.

[0032] Patch scaling is performed in addition to frame scaling to allow for texture size adaptation on a per-patch basis. Patch scaling allows more texture space to be used in certain high-detail areas (e.g., faces). In an example implementation, if params.bPatchScaling=true, the initial size of the patch is doubled (or increased by another amount). If the patch cannot be packed, its size is reduced by 10%. If the total size reduction exceeds 50% of the size of the patch, the packing is considered unsuccessful and a new frame scaling is calculated.

[0033] Figure 10 shows images of patch orientations according to some embodiments. Similar to V-PCC, patches can be rotated within the texture atlas domain to obtain a better fit. However, in some embodiments, to maintain the curvature of the triangle, only rotations of 0°, 90°, 180°, and 270° are allowed. For example, image 1000 shows an unrotated patch in a texture map, and image 1002 shows a rotated patch.

[0034] 11 shows images of temporal stabilization according to some embodiments. Matching patches are determined by checking the projection direction and the ratio of the volume of the intersection of both patches in 3D to the volume of the union of both patches in 3D. A matched patch has the same position (U0, V0), the same orientation (O), and the same scale (S) as the unmatched patch. Image 1100 shows a texture map without temporal stabilization, and image 1102 shows a texture map with temporal stabilization.

[0035] The texture map coordinates can be derived by applying the following transformation: TIFF2025532407000016.tif3066where, TIFF2025532407000017.tif16161 TIFF2025532407000018.tif17161 TIFF2025532407000019.tif20150 where, TIFF2025532407000020.tif16160 TIFF2025532407000021.tif16160

[0036] FIG. 12 illustrates a block diagram of an exemplary computing device configured to implement a texture map generation method using orthogonal projection according to some embodiments. The computing device 1200 can be used to acquire, store, compute, process, communicate, and / or display information, such as images and videos, including 3D content. The computing device 1200 can implement any of the encoding / decoding aspects. In general, a hardware configuration suitable for implementing the computing device 1200 includes a network interface 1202, memory 1204, a processor 1206, I / O device(s) 1208, a bus 1210, and storage 1212. The selection of the processor is not critical as long as a suitable processor with sufficient speed is chosen. The memory 1204 can be any conventional computer memory known in the art. The storage 1212 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 computing device 1200 can include one or more network interfaces 1202. An example of a network interface includes a network card that connects to an Ethernet or other type of LAN. I / O device(s) 1208 can include one or more of a keyboard, mouse, monitor, screen, printer, modem, touch screen, button interface, and other devices. Texture map generation using orthographic projection application(s) 1230 used to implement the texture map generation using orthographic projection implementation are likely stored in storage 1212 and memory 1204 and processed as applications are typically processed. Computing device 1200 can include more or fewer components than those shown in FIG. 12 . In some embodiments, texture map generation using orthographic projection hardware 1220 is included.12 includes hardware 1220 and application 1230 for implementing texture map generation using orthographic projection, the texture map generation using orthographic projection method may be implemented in a computing device as hardware, firmware, software, or any combination thereof. For example, in some embodiments, texture map generation using orthographic projection application 1230 is programmed into memory and executed using a processor. As another example, in some embodiments, texture map generation using orthographic projection hardware 1220 is programmed hardware logic that includes gates specifically designed to implement the texture map generation using orthographic projection method.

[0037] In some embodiments, texture map generation application(s) 1230 using orthographic projection includes several applications and / or modules. In some embodiments, a module also includes one or more sub-modules. In some embodiments, fewer or additional modules may be included.

[0038] Examples of suitable computing devices include a personal computer, a laptop computer, a computer workstation, a server, a mainframe computer, a handheld computer, a personal digital assistant, a cellular / mobile phone, a smart appliance, a game console, a digital camera, a digital camcorder, a camera phone, a smartphone, a portable music player, a tablet computer, a mobile device, a video player, a video disc writer / player (e.g., a DVD writer / player, a high-definition disc writer / player, an ultra-high-definition disc writer / player), a television, a home entertainment system, an augmented reality device, a virtual reality device, smart jewelry (e.g., a smart watch), a vehicle (e.g., an autonomous vehicle), or any other suitable computing device.

[0039] To utilize the texture map generation method using orthographic projection, a device acquires or receives 3D content (e.g., point cloud content). The texture map generation method using orthographic projection can be implemented with user assistance or automatically without user involvement.

[0040] In operation, texture map generation using orthogonal projection is fast and efficient. Currently, texture map generation relies on complex optimizations to reduce mapping distortion and texture seams. However, such procedures are not suitable for real-time applications and are typically performed frame-by-frame, thereby not exploiting temporal correlations between texture maps. This specification describes a method for generating texture maps that significantly reduces the time required and allows the maps to exploit correlations between the content of different frames in time. Texture mapping can be used for automatic generation of volumetric content or for more efficient compression of dynamic meshes.

[0041] Orthoatlas: Some embodiments of texture map generation for dynamic meshes using orthogonal projection 1. A method programmed into a non-transitory memory of a device, comprising: generating patches from the dynamic mesh information; packing the patches into a texture atlas using orthogonal projection; A method comprising:

[0042] 2. The step of generating the patch from dynamic mesh information includes: generating a list of adjacent triangles; Calculating the properties of the triangle; Adding neighboring triangles; Checking for vertex occlusion; Checking surface shielding and 2. The method of claim 1, further comprising:

[0043] 3. The method according to claim 2, wherein generating the list of adjacent triangles includes adding to the list triangles that share vertices with the triangle.

[0044] 4. The method of claim 2, wherein generating the list of adjacent triangles includes adding triangles that share an edge with a triangle to the list.

[0045] 5. The method of claim 2, wherein calculating the triangle properties includes calculating the normal and surface area of ​​each triangle.

[0046] 6. The method of claim 2, further comprising the step of selecting a seed triangle whose normals are best aligned with the most frequent orientation and that has not been added to the patch.

[0047] 7. The method of claim 2, wherein the method further comprises merging the patches based on a calculated cost, the calculated cost being based on the perimeter and ortho stretch value of the patches.

[0048] 8. The method of claim 1, wherein packing the patches into the texture atlas using orthogonal projection includes implementing frame scaling, patch orientation, and temporal stabilization.

[0049] 9. An apparatus comprising: A non-transitory memory for storing an application, said application comprising: Generate patches from dynamic mesh information, Packing the patches into a texture atlas using orthogonal projection; a non-transient memory for a processor coupled to the memory and configured to process the application; An apparatus comprising:

[0050] 10. Generating the patch from dynamic mesh information generating a list of adjacent triangles; Calculating the properties of the triangle; Adding neighboring triangles; Checking for vertex occlusion; Checking surface shielding and 10. The apparatus of claim 9, further comprising:

[0051] 11. The apparatus of claim 10, wherein generating the list of adjacent triangles includes adding triangles that share vertices with a triangle to the list.

[0052] 12. The apparatus of claim 10, wherein generating the list of adjacent triangles includes adding triangles that share an edge with a triangle to the list.

[0053] 13. The apparatus of claim 10, wherein calculating the triangle properties includes calculating the normal and surface area of ​​each triangle.

[0054] 14. The apparatus of clause 10, wherein the application is further configured to select a seed triangle whose normals are best aligned with the most frequent orientation and that has not been added to the patch.

[0055] 15. The apparatus of claim 10, wherein the application is further configured to merge the patches based on a calculated cost, the calculated cost being based on the perimeter and ortho stretch value of the patches.

[0056] 16. The apparatus of claim 9, wherein packing the patches into the texture atlas using orthogonal projection includes implementing frame scaling, patch orientation, and temporal stabilization.

[0057] 17. A system comprising: one or more cameras for capturing three-dimensional content; Generate patches from dynamic mesh information, Packing the patches into a texture atlas using orthogonal projection; an encoder configured as follows: A system including:

[0058] 18. Generating the patch from dynamic mesh information generating a list of adjacent triangles; Calculating the properties of the triangle; Adding neighboring triangles; Checking for vertex occlusion; Checking surface shielding and 20. The system of claim 17, further comprising:

[0059] 19. The system of claim 18, wherein generating the list of adjacent triangles includes adding triangles that share vertices with a triangle to the list.

[0060] 20. The system of claim 18, wherein generating the list of adjacent triangles includes adding triangles that share an edge with a triangle to the list.

[0061] 21. The system of claim 18, wherein calculating the triangle properties includes calculating the normal and surface area of ​​each triangle.

[0062] 22. The system of clause 18, wherein the encoder is further configured to select a seed triangle whose normals are best aligned with the most frequent orientation and that has not been added to the patch.

[0063] 23. The system of claim 18, wherein the encoder is further configured to merge the patches based on a calculated cost, the calculated cost being based on the perimeter and ortho stretch value of the patches.

[0064] 24. The system of claim 17, wherein packing the patches into the texture atlas using orthogonal projection includes implementing frame scaling, patch orientation, and temporal stabilization.

[0065] The present invention has been described with reference to specific embodiments incorporating details to facilitate an understanding of the principles of construction and operation of the invention. Reference herein to specific embodiments and their details is not intended to limit the scope of the claims appended hereto. Those skilled in the art will readily appreciate that various other modifications can be made to the embodiments chosen for illustration without departing from the spirit and scope of the invention as defined by the claims. [Explanation of symbols]

[0066] Generate 100 patches Packing 102 Patches 110 Connected Components 112 adjacent triangles 114 Properties of Triangles 116 Select Seed 118 Add neighboring triangles 120 Merge 130 Projection 132 Check for vertex occlusion 134 Check surface occlusion 200 triangles 600 triangles 700 original mesh 702 mesh 704 mesh 706 mesh 900 bounding boxes 902 Texture Maps 1000 images 1002 images 1100 images 1102 images 1200 Computer Equipment 1202 network interface 1204 memory 1206 processor 1208 I / O Devices 1210 Bus 1212 Storage device 1220 Texture map generation hardware using orthographic projection 1230 Texture Map Generation Application Using Orthographic Projection

Claims

1. 1. A method programmed into a non-transitory memory of a device, comprising: generating patches from the dynamic mesh information; packing the patches into a texture atlas using orthogonal projection; A method comprising:

2. The step of generating the patch from dynamic mesh information includes: generating a list of adjacent triangles; Calculating the properties of the triangle; Adding neighboring triangles; Checking for vertex occlusion; Checking surface shielding and The method of claim 1 further comprising:

3. 3. The method of claim 2, wherein generating the list of neighboring triangles includes adding to the list triangles that share a vertex with a triangle.

4. 3. The method of claim 2, wherein generating the list of neighboring triangles includes adding to the list triangles that share an edge with a triangle.

5. 3. The method of claim 2, wherein calculating the triangle properties includes calculating the normals and surface area of ​​each triangle.

6. The method of claim 2 further comprising the step of selecting a seed triangle whose normals are best aligned with the most frequent orientation and that has not been added to the patch.

7. 3. The method of claim 2, further comprising merging the patches based on a calculated cost, the calculated cost being based on a perimeter and an ortho stretch value of the patches.

8. 10. The method of claim 1, wherein packing the patches into the texture atlas using orthogonal projection includes implementing frame scaling, patch orientation, and temporal stabilization.

9. 1. An apparatus comprising: A non-transitory memory for storing an application, said application comprising: Generate patches from dynamic mesh information, Packing the patches into a texture atlas using orthogonal projection; a non-transient memory for a processor coupled to the memory and configured to process the application; 10. An apparatus comprising:

10. generating the patch from dynamic mesh information, generating a list of adjacent triangles; Calculating the properties of the triangle; Adding neighboring triangles; Checking for vertex occlusion; Checking surface shielding and The apparatus of claim 9 further comprising:

11. The apparatus of claim 10 , wherein generating the list of neighboring triangles includes adding to the list triangles that share a vertex with a triangle.

12. The apparatus of claim 10 , wherein generating the list of neighboring triangles includes adding to the list triangles that share an edge with a triangle.

13. 11. The apparatus of claim 10, wherein calculating the triangle properties includes calculating a normal and a surface area of ​​each triangle.

14. The apparatus of claim 10 , wherein the application is further configured to select a seed triangle whose normals are best aligned with the most frequent orientation and that has not been added to the patch.

15. The apparatus of claim 10 , wherein the application is further configured to merge the patches based on a calculated cost, the calculated cost being based on a perimeter and an orthostretch value of the patches.

16. 10. The apparatus of claim 9, wherein packing the patches into the texture atlas using orthogonal projection includes implementing frame scaling, patch orientation, and temporal stabilization.

17. 1. A system comprising: one or more cameras for capturing three-dimensional content; Generate patches from dynamic mesh information, Packing the patches into a texture atlas using orthogonal projection; an encoder configured as follows: A system comprising:

18. generating the patch from dynamic mesh information, generating a list of adjacent triangles; Calculating the properties of the triangle; Adding neighboring triangles; Checking for vertex occlusion; Checking surface shielding and 20. The system of claim 17, further comprising:

19. 20. The system of claim 18, wherein generating the list of neighboring triangles includes adding to the list triangles that share a vertex with a triangle.

20. 20. The system of claim 18, wherein generating the list of neighboring triangles includes adding to the list triangles that share an edge with a triangle.

21. 20. The system of claim 18, wherein calculating the triangle properties includes calculating a normal and a surface area of ​​each triangle.

22. 20. The system of claim 18, wherein the encoder is further configured to select a seed triangle whose normals are best aligned with the most frequent orientation and that has not been added to the patch.

23. 20. The system of claim 18, wherein the encoder is further configured to merge the patches based on a calculated cost, the calculated cost being based on a perimeter and an orthostretch value of the patches.

24. 20. The system of claim 17, wherein packing the patches into the texture atlas using orthogonal projection includes implementing frame scaling, patch orientation, and temporal stabilization.

Images