Low polygon mesh generation of three-dimensional models

Abstract

According to an aspect of the present disclosure, a method of generating a low polygon mesh of a three-dimensional (3D) model is provided. In the method, an edge folding operation is performed on each of a plurality of edges of an input mesh to generate a simplified mesh, where the number of faces of the input mesh is reduced by the edge folding operation. The position of at least one vertex of the simplified mesh is updated to generate an updated mesh where the distance between the simplified mesh and the input mesh decreases. A low polygon mesh is generated based on the aligned mesh, where the positions of vertices of the updated mesh are optimized by minimizing shape differences between the simplified mesh and the updated mesh.

Description

Incorporation by reference

[0001] This application claims the benefit of priority to U.S. patent application Ser. No. 18 / 112,445, filed on February 21, 2023, entitled “LOW-POLY MESH GENERATION FOR THREE-DIMENSIONAL MODELS,” which is incorporated herein by reference in its entirety. Technical Field

[0002] This disclosure describes embodiments generally directed to computational methods involving mesh geometric models. Background Art

[0003] The background description provided herein is for the purpose of generally presenting the context of the present disclosure. To the extent that the work of the presently named inventors described in this background section and in various aspects of this specification qualifies as prior art at the time of filing, it is not intended, either expressly or by implication, that it is admitted as prior art with respect to the present disclosure.

[0004] Meshes are a ubiquitous representation of three-dimensional (3D) models in digital games. While meshes with a high number of polygons (e.g., high polygons) are required to express visually appealing details of 3D shapes, low-polygon approximations that render 3D shapes at long distances are the typical solution for achieving real-time gaming experiences, such as on low-end devices. Whether high-polygons are created manually using modeling software or automatically converted from constructive solid geometry (CSG) and implicit functions, high-polygons typically have complex topology and geometry, such as a large number of components, high genus, non-manifolds, self-intersections, degenerate elements, gaps, and inconsistent orientations. The complexity of high-polygons poses a significant challenge to the design of automatic low-poly mesh generation algorithms. In practice, artists still manually create low-poly meshes to ensure that they have a low number of triangles and maintain the visual appearance of the original mesh as closely as possible. However, manual low-poly mesh creation often requires multiple iterations of manual adjustments, which is labor-intensive and prolongs project cycles, posing a bottleneck in the rapidly evolving gaming industry. Therefore, automated methods for generating satisfactory low-poly meshes are highly desired. Summary of the Invention

[0005] Aspects of the present disclosure include methods, apparatus, and non-transitory computer-readable storage media for computing methods.In some examples, an apparatus for generating a mesh geometric model includes processing circuitry.

[0006] According to one aspect of the present disclosure, a method for generating a low-polygon mesh of a three-dimensional (3D) model is provided. In the method, an edge collapse operation may be performed on each of a plurality of edges of an input mesh to generate a simplified mesh, wherein the number of faces of the input mesh may be reduced by the edge collapse operation. A position of at least one vertex of the simplified mesh may be updated to generate an updated mesh, wherein a distance between the simplified mesh and the input mesh may be reduced. The low-polygon mesh may be generated based on an aligned mesh, wherein the positions of the vertices of the updated mesh are optimized by minimizing the shape difference between the simplified mesh and the updated mesh.

[0007] In one example, the input mesh is an isosurface mesh generated based on a plurality of isosurfaces in a plurality of voxels of the 3D model, wherein the plurality of isosurfaces are determined based on isovalues.

[0008] In one example, an edge collapse operation is performed on a first edge of a plurality of edges of an input mesh to generate a simplified mesh. A determination is made as to whether the simplified mesh satisfies topological consistency based on whether the simplified mesh is manifold and sealed and has the same genus and the same number of components as the input mesh. In response to the simplified mesh satisfying topological consistency, a determination is made as to whether the simplified mesh has no self-intersections. In response to the simplified mesh having no self-intersections, a determination is made as to whether a first distance between a submesh of the input mesh and a submesh of the simplified mesh is greater than an equal value. The submesh of the input mesh includes faces adjacent to the first edge before the edge collapse operation, and the submesh of the simplified mesh includes faces associated with the first edge after the edge collapse operation. In response as to whether the first distance is less than the equal value, a determination is made as to whether a second distance is less than a third distance. A second distance is determined between the submesh of the input mesh and a reference mesh. A third distance is determined between the submesh of the simplified mesh and the reference mesh.

[0009] In some embodiments, a first submesh is determined in a simplified mesh, comprising at least one first face. Each of the at least one first face contacts a vertex determined when an edge collapse operation is applied to the first edge. A second submesh is determined in the simplified mesh. The second submesh comprises a plurality of second faces, wherein each of the plurality of second faces shares at least one vertex of the first submesh. A third submesh is determined in the simplified mesh, wherein the third submesh comprises a plurality of third faces, the plurality of third faces not included in the first submesh and the second submesh. A BVH tree data structure for the third submesh is constructed based on a BVH tree type. For each of the one or more first faces of the first submesh, a nearest face of the corresponding first face is determined in the third submesh. A determination is then made as to whether each of the one or more first faces of the first submesh intersects with the nearest face of the corresponding first face.

[0010] In some embodiments, a target vertex is determined in the input mesh, the target vertex being the closest vertex to a first vertex of the simplified mesh. A vector is determined between the target vertex and the first vertex. The vector is equal to the difference between the position of the target vertex and the position of the first vertex divided by a first constant value. The first vertex is updated based on the vector and the position of the first vertex.

[0011] In one example, to update a first vertex, the position of the first vertex is updated to the sum of: (i) the position of the first vertex and (ii) the product of a vector and a second constant value. A determination is made as to whether a first face in the simplified mesh that includes the first vertex intersects at least one adjacent face in the simplified mesh. In response to the first face intersecting the at least one adjacent face, the position of the first vertex is updated to the sum of: (i) the position of the first vertex and (ii) the product of the vector, half of the second constant value, and a third constant value. In response to the first face not intersecting the at least one adjacent face, the position of the first vertex is updated to the sum of: (i) the position of the first vertex and (ii) the product of the vector, half of the second constant value, and a third constant value.

[0012] In some embodiments, the first constant value is 8, the second constant value is 1, and the third constant value is 0.95.

[0013] In some embodiments, a non-normalized face normal of a first face in a face union is determined. The face union includes faces in the updated mesh and contacts a first vertex in the updated mesh. A normal constant is determined based on the modulus of the non-normalized face normal of the first face. Non-normalized face normals of faces corresponding to the first face in the simplified mesh are determined. An optimized position for the first vertex is then determined by minimizing an unconstrained quadratic function.

[0014] In one example, the unnormalized face normal of the first face is determined as a cross product of two face edges of the first face.

[0015] In one example, the unnormalized face normal of the face corresponding to the first face is determined as a cross product of two face edges of the face corresponding to the first face.

[0016] In one example, the unconstrained quadratic function is: c n is the normal constant, N(v) is the face union, n(f) is the unnormalized face normal of the first face, is the unnormalized face normal of the face corresponding to the first face.

[0017] In some embodiments, a vector between the position of the first vertex and the optimized position of the first vertex is determined, and the first vertex is then updated based on the determined vector to generate an aligned mesh.

[0018] In some embodiments, an iterative process is performed to generate a low-polygon mesh. In response to one of: (i) a number of iterations of the iterative process being less than a target value and (ii) a Hausdorff distance between the input mesh and the aligned mesh being less than a threshold, an edge collapse operation is performed on each of a plurality of edges of the aligned mesh to generate another simplified mesh.

[0019] According to another aspect of the present disclosure, a device is provided. The device has a processing circuit that can be configured to perform any one or a combination of methods for generating a low-polygon mesh.

[0020] Aspects of the present disclosure also provide a non-transitory computer-readable medium storing instructions that, when executed by at least one processor, cause the at least one processor to perform any one or a combination of methods for generating a low-polygon mesh. BRIEF DESCRIPTION OF THE DRAWINGS

[0021] Further features, nature, and various advantages of the disclosed subject matter will become more apparent from the following detailed description and accompanying drawings, in which:

[0022] Figure 1 Shown are examples of a high polygon mesh and its corresponding low polygon mesh.

[0023] Figure 2 is an illustration of an exemplary flow of an algorithm for generating a low-polygon mesh.

[0024] Figure 3 is a schematic illustration of an exemplary isosurface in a voxel.

[0025] Figure 4 is a schematic illustration of an exemplary isosurface extraction.

[0026] Figure 5 is a diagram of an exemplary process of isosurface extraction.

[0027] Figure 6 is a diagram of an exemplary feature alignment process.

[0028] Figure 7 is a diagram of exemplary edge operations and exemplary vertex operations.

[0029] Figure 8 Shown is an exemplary comparison of different methods for generating low-polygon meshes, according to some embodiments.

[0030] Figure 9 Shown is an exemplary comparison of different methods for generating low-polygon meshes, according to some embodiments.

[0031] Figure 10 Shown is an exemplary comparison of different methods for generating low-polygon meshes, according to some embodiments.

[0032] Figure 11 Exemplary time statistics for generating a low polygon mesh are shown, according to some embodiments.

[0033] Figure 12 An exemplary comparison of different remeshing results based on different user-specified distance tolerances is shown in accordance with some embodiments.

[0034] Figure 13 An exemplary comparison of different remeshing results based on different voxel sizes is shown in accordance with some embodiments.

[0035] Figure 14 An exemplary comparison of different remeshing results based on different thresholds of characteristic curve length is shown, according to some embodiments.

[0036] Figure 15 An exemplary comparison of different remeshing results based on different flow step fraction ratios is shown, according to some embodiments.

[0037] Figure 16 An exemplary comparison of different remeshing results based on different isosurface extraction methods according to some embodiments is shown.

[0038] Figure 17 An exemplary generated shell of a cartoon octopus is shown.

[0039] Figure 18 Shown is an exemplary comparison of different methods for generating low-polygon meshes, according to some embodiments.

[0040] Figure 19 is an exemplary diagram of an EMC 33 lookup table.

[0041] Figure 20 is an exemplary illustration of a separation strategy for EMC 33 .

[0042] Figure 21 A flowchart outlining an exemplary process for generating a low polygon mesh according to some embodiments of the present disclosure is shown.

[0043] Figure 22 is a schematic diagram of a computer system according to an embodiment. DETAILED DESCRIPTION

[0044] Over the past few decades, various types of automatic methods have been developed to obtain meshes with a reduced number of elements. Two types of automatic methods include: (1) mesh reduction, which gradually reduces the number of triangles by iteratively applying local operations or clustering (such as edge collapsing and triangle clustering); and (2) remeshing, which ignores the original mesh structure and generates a new mesh from scratch. Although these mesh reduction methods can maintain properties defined on the mesh surface (such as UV mapping and textures), the local operations of mesh reduction methods rely on existing mesh vertices and connectivity. Therefore, mesh reduction methods may not be able to simplify meshes with overly complex topology, such as Figure 9 and Figure 10 The mesh shown. On the other hand, remeshing methods seek to use a proxy mesh to represent the original mesh and simplify the proxy mesh through a series (or more) of different techniques. For example, remeshing methods may include: polygon mesh construction through plane fitting and mixed integer optimization, cage mesh generation through voxel expansion and mesh simplification, shape abstraction through feature simplification, very low polygon meshing using visual-hull Boolean operations, mesh simplification through differentiable rendering, closed mesh generation through alpha wrapping with offset, and learning-based methods. However, these remeshing methods either rely on a lot of user interaction (which requires careful parameter tuning) or are applicable to a limited type of models. Commercial software (such as Simplygon) also has low polygon mesh capabilities, but the results generated by commercial software are unsatisfactory in many cases. For example, Figure 8 As shown in Tables 4 and 5, different low-polygon building blocks based on Simplygon can be used to generate low-polygon meshes. Simplygon either fails to guarantee geometric properties (e.g., no intersection) or results in severe visual artifacts. Therefore, automatically and robustly generating low-polygon meshes for common 3D models used in the industry remains a challenging task.

[0045] Obtaining low-polygon meshes has been a research focus in computer graphics for decades. Early work used various mesh reduction techniques to operate directly on the original input by iteratively removing local elements. Examples include geometric error-guided techniques, structure-preserving constraint techniques, volume-preserving techniques, image-driven techniques, and so on. Clustering-based methods can provide another direction for reducing the number of elements. The methods mentioned above are well recognized in the game production process. However, the above methods are more suitable for reducing the mesh size of the original model to a moderate level, such as reducing the number of faces by 20% to 80%. Unfortunately, for 3D graphics applications running on low-end devices, a coarser low-polygon mesh is desired. Such an extremely low-polygon mesh requires topology and geometry simplification, which is beyond the capabilities of related mesh reduction techniques.

[0046] In contrast to mesh reduction techniques, parallel efforts, such as remeshing, aim to completely reconstruct a new mesh that mimics the original. These approaches vary widely in their techniques. Methods that completely reconstruct a new mesh that mimics the original can be categorized based on their key characteristics, such as voxel-based remeshing, primitive fitting, vision-driven, and learning-based.

[0047] In voxelization-based remeshing, voxelization of the raw input can be performed to obtain a clean voxel surface. In a related example, feature-guided re-triangulation, deformation, and curve network cleanup are desirable to generate shape abstractions of objects such as buildings. The input mesh can have a clear separation of interior and exterior spaces, and the final low-polygon generation relies heavily on user interaction.

[0048] In primitive fitting, various primitives can be combined to fit an object. In a related example, a set of planes can be computed to approximate patch features detected in a point cloud or 3D shape, and then a faithful subset of intersecting planes can be selected to obtain the desired mesh. However, the key challenges of the related examples include: (1) correctly computing a set of suitable candidate planes is already a difficult problem; and (2) the complexity of the resulting mesh is highly unpredictable, which may require a lot of trial and error to find a set of parameters that may be good. Work using other primitives (such as boxes, convex shapes, curves, etc.) has also been explored, but none of the work is specifically designed for generating low-polygons.

[0049] Among vision-driven methods, differentiable rendering has become a hot topic, which can continuously optimize scene elements by guiding the rendered image loss. However, most vision-driven methods require an initial mesh, which is usually a uniformly discretized sphere. A key obstacle to generating low polygons through differentiable rendering is the inability to model mesh reduction as a differentiable optimization process. Although analysis-synthesis type optimization can be adopted, the Laplacian regularization term used by most differentiable rendering techniques may infer a mesh that is far from the ground truth in extremely low polygon settings. A visual shell-based method was recently proposed to generate extremely low polygons for model construction. However, the visual shell-based method not only creates sharp creases for organic shapes, but also has difficulty in determining the target number of elements for the desired low polygon.

[0050] In learning-based methods, the commonly used 3D mesh reconstruction process includes three steps: plane detection, intersection, and selection. In a related example, low polygons can be extracted from an image by converting them into a binary space partitioning (BSP) network. However, the related examples have common shortcomings of learning-based methods. For example, a large data set is required for network training, and the learned model is only applicable to similar types of meshes. The related examples also require that the voxelization of the data set has a well-defined input / output partitioning. In addition, the generated mesh inherits problems similar to the polyfit method. For example, sharp creases are generated that do not exist in high polygons, and parameter adjustment is difficult. In another related example, by embedding a neural network of moving tetrahedrons into a differentiable rendering framework, the mesh and material can be optimized simultaneously. By controlling the resolution of the rendered image, a 3D model can be generated in an LOD manner.

[0051] A marching cube (MC) algorithm is proposed to reconstruct isosurfaces from discrete signed distance fields. Related work includes resolving the ambiguity of tessellations in each cube. One of the MC methods is MC33, which enumerates all possible topological cases based on trilinear interpolation in the cube. Related work on MC33 includes resolving non-manifold edges in the initial MC33 method. For example, MC33 was correctly implemented after the defects of the previous implementation were resolved. However, none of the related examples can recover sharp features.

[0052] To capture sharp features on iso-surfaces, the Extended Marching Cubes (EMC) method can be used to insert additional feature points, provided that normals to some intersection points are available. Dual Contouring (DC) employs additional feature points with Hermite data (e.g., the gradient of an implicit surface function). In the dual contouring method, a dual feature point is inserted into the interior of the cube, and these dual feature points are then connected to form an iso-surface. DC does not require edge flipping but often produces non-manifold surfaces with many self-intersections. While both non-manifold and self-intersection problems can be addressed in related methods, none address both simultaneously. Dual Marching Cubes (DMC) extracts iso-surfaces from the dual mesh, taking into account the alignment of the dual mesh with the features of the implicit function. DMC preserves sharp features without the over-meshing required by DC. However, DMC still cannot guarantee that the generated mesh is free of self-intersections. In a related approach, to avoid self-intersections, each cube can be subdivided into 48 tetrahedra, and then marching tetrahedra (MT) can be applied to extract isosurfaces. This approach can solve the problems of the DMC method, but the 48 tetrahedron partitioning and the octree structure used together make the algorithm either generate an overly dense mesh or require trial and error to obtain a suitable octree depth parameter setting. Recently, an algorithm was proposed to generate a closed (watertight) and orientable surface that strictly surrounds the input. The output can be obtained by refining and carving a 3D Delaunay triangulation of the offset surface. However, this output lacks the property of preserving features.

[0053] Other learning-based methods for isosurface extraction can include Deep Marching Cubes and Deep Marching Tetrahedrons. Deep Marching Cubes and / or Deep Marching Tetrahedrons can learn differentiated MC and MT results. However, neither Deep Marching Cubes nor Deep Marching Tetrahedrons can capture the sharp features of the initial surface. Neural Marching Cubes and Neural Dual Contours can train the network to capture sharp features without the need for additional Hermite information. However, Neural Marching can generate self-intersecting meshes, and Neural Dual Contours can lead to non-manifold results.

[0054] Various exemplary methods are summarized in Table 1. Advantages and disadvantages of various methods are provided based on topological and geometric properties: manifold, no self-intersection, and sharp feature preservation. Table 1 Summary of related methods

[0055] Determining self-intersections within a mesh can be viewed as discrete collision detection (DCD) between non-adjacent triangles at static time, which is technically easy to compute but can be difficult to compute quickly. Various continuous collision detection (CCD) methods have been proposed to check for any collisions between objects over time. For example, a self-intersection check can be applied to determine any self-intersections within a mesh.

[0056] In order to quickly determine whether a mesh has self-intersections, a key point is to eliminate unnecessary triangle pair checks in a conservative but as tight a manner as possible, and to perform as few triangle intersection calculations as possible. Although a bounding volume hierarchy (BVH) is used to reject intersection checks on triangles that do not share any vertices or edges, normal cone methods and related methods of normal cones have been introduced to conservatively perform intersection checks on triangles in local areas. The normal cone test contains two conditions: a surface normal test and a contour test. When both tests pass, it can be determined that the surface has no intersection. Although the surface normal test is fast to evaluate, the contour test requires a 2D loop projection and a self-intersection check on the entire loop, which is computationally expensive. Normal cone related methods, such as a double normal cone test and / or an enhanced double normal cone test, only alleviate the problems of the normal cone test.

[0057] In this disclosure, if the mesh is manifold, closed, and updated only after edge collapse and edge flip operations, the contour test can be skipped for the normal cone test. Skipping the contour test can speed up the self-intersection check by more than 100 times, as shown in Tables 2 and 3.

[0058] In the present disclosure, a remeshing method is provided to generate low polygon meshes without manual intervention. The method of the present disclosure can be seamlessly integrated into a mesh-based 3D asset production process. The method of the present disclosure may include: (1) a robust isosurface mesh extraction algorithm that ensures that the output is closed, manifold, self-intersection-free, and feature-preserving; and (2) a progressive mesh flow process that brings two meshes closer to each other, which produces the desired low polygons with high visual similarity to the input. The simplicity of the low polygons can be controlled by the target rendering screen size and the isosurface offset. For example, reducing the screen size and increasing the offset can both result in low polygons with a smaller number of elements and an increased geometric deviation from the original model. The method of the present disclosure is evaluated on several datasets containing models of different topological and geometric complexities created by practitioners in different fields. Compared to the current state-of-the-art methods and widely used software, the method of the present disclosure shows improvements in the number of elements, visual quality, geometry and / or topological guarantees of the generated low polygons.

[0059] For meshes with arbitrary topology and geometric properties, the remeshing method of the present disclosure can generate low polygons (or low polygon meshes) to achieve a good balance between mesh simplification and visual appearance preservation, but the requirements are manifold, closed and no self-intersection. In one embodiment, the remeshing method of the present disclosure may include two stages. In the first stage, an unsigned distance field can be constructed for the input, and an isosurface extraction method can be introduced for the offset distance (or isovalue) d. The isosurface generation method of the present disclosure can meet the requirements of manifold, closed and no self-intersection while maintaining the shape characteristics of the input mesh. In the second stage, three steps can be performed in sequence. The tree step may include mesh simplification, mesh flow process and feature alignment to reduce the number of elements and make the simplified mesh close to the input. These three steps are local steps, so that any step that violates hard constraints can be easily rolled back or skipped. Based on the remeshing method of the present disclosure, two key goals can be achieved: (1) topology and no intersection guarantees; and (2) a practically small silhouette difference between the simplified mesh and the input mesh.

[0060] In some embodiments, the algorithm of the present disclosure requires only a single parameter from the user, which may be the number of pixels n obtained along the diagonal length l of the bounding box of the input mesh when it is rendered on the screen. p The visual appearance of a 3D shape can be determined primarily by the contour of the 3D shape and the surface normal of the 3D shape. p ) will n pMapping to d can indirectly ensure visual preservation of the algorithm's output. Therefore, the maximum contour difference between the simplified mesh and the input mesh can be constrained within d, and the average normal difference between the mesh before and after simplification can be minimized based on the mesh flow process.

[0061] In this disclosure, a robust and automatic algorithm is constructed. By batch processing several datasets containing 3D models of varying complexity, the effectiveness of the algorithm in generating low-polygon models with low triangle count and high visual quality is demonstrated by comparison with state-of-the-art methods and widely used software. For example, the comparison results can be seen in Figures 8 to 10 , Table 4 and Table 5.

[0062] Figure 1 Several exemplary three-dimensional (3D) models processed based on the method of the present disclosure are shown. The 3D models can be used in various environments such as virtual reality and gaming applications. Figure 1 As shown, an atlas of high polygon input meshes (e.g., (102)) and corresponding low polygon outputs (e.g., (104)) generated based on the method of the present disclosure is provided. The low polygon mesh can be closed and have no self-intersections.

[0063] In this disclosure, given an input polygonal mesh M i , the maximum number of screen pixels that the input occupies n p and an optional user-specified target number of triangles n F , a triangular mesh M with the following properties can be generated o : (1) If n F If M is provided as a parameter, o The number of triangles is either as small as possible or equal to n F ; (2) When rendering at view distance so that along M i The number of pixels occupied by the diagonal of the bounding box is less than n p When M o With M i indistinguishable; (3)M o Topologically and geometrically clean, e.g., closed, manifold, and non-intersecting; and (4)M o Keep M as much as possible i Sharp features.

[0064] M o The first three properties of ensure the rendering quality and make the Mo Any downstream processing of the M is computationally efficient and does not require a mesh repair step. The last property is a relatively soft requirement, often desired by artists and essential for achieving M i It is also important to maintain the visual appearance.

[0065] Several principles can be followed to design the remeshing method of the present disclosure: (1) No assumptions are made on the topological or geometric properties of the input, which enables the remeshing method to handle any model created in the wild (or with many details); (2) A strategy similar to interior point optimization can be used to achieve the above-mentioned properties one by one. This means that once a property is satisfied, it can be maintained for the remaining steps; (3) The robustness of the remeshing method is given the highest priority, so that the remeshing method can handle any input created by different application fields. While ensuring robustness, the computational efficiency is improved as much as possible.

[0066] The remeshing method may include two main stages: mesh extraction and mesh optimization. During the mesh extraction stage, M i For positive offset distances (or iso-values) d, an isosurface mesh extraction method can be introduced. All invisible disconnected components can also be removed from the extracted isosurface to obtain a mesh M d The generated M d The sharp features implied by the d-isosurface of the distance field (e.g. d = l / n p ), and ensure closed, manifold and no self-intersection. The purpose of the mesh extraction stage is to generate the input M i A "clean" proxy grid M d , but M i May have a "dirty" topology and geometry configuration. During the mesh optimization phase, a while loop of three sequential steps can be implemented: simplification, flow, and alignment. The simplification step aims to reduce M by performing a secondary edge collapse extraction on the entire mesh. d The flow step aims to minimize the distance between each vertex, while M d With M i The alignment step aims to optimize M d The surface normals of the mesh are adjusted to maintain sharp features, which can be achieved by optimizing the local surface patch. When the while loop stops, the final mesh M can be output. o Since all three steps contain only local operations, the M achieved during the first phase can be easily preserved by skipping any operation that violates the guarantee d guarantee.

[0067] Figure 2 FIG. 2 shows an exemplary process (200) of the re-gridding method of the present disclosure. Figure 2 As shown, a high polygon surface M can be provided as input i (202) as the input mesh. Input mesh (or input surface) M i (202) may not be manifold, orientable, or self-intersecting. In one example, the input surface M i (202) is not a 2-manifold (has 114 non-2-manifold edges), has 751 components, and is not orientable (backface rendered in black). Input surface M i (202) can have more than 36,000 faces, of which 23,345 faces are self-intersecting. Based on mesh extraction, the extracted isosurface M can be obtained. d (204). Can be based on the equivalent value 1 / 200×M i (202) to obtain the diagonal length of the bounding box to obtain M d (204). M d (204) can be an orientable, closed, non-self-intersecting mesh and includes 19 component surfaces with 760,000 faces. Surfaces (206), (208), and (210) illustrate mesh optimization steps during which mesh simplification, flow, and alignment are performed, respectively, without destroying the M d (204) any existing topological and geometric properties. Figure 2 As shown, with the input grid M i (202) Compared with the final grid M o (210) is a low polygonal (eg, 2703 faces), orientable, and closed surface with only 19 connected components. Figure 2 The example shown solves existing topological problems (such as non-manifold properties) and geometric problems (such as self-intersections) with only the input mesh M i (202) is 7.3% of the face count of the input mesh M. i Similar shape to (202).

[0068] Given M i The goal of mesh extraction is to extract a d-isosurface mesh M that is topologically closed and manifold, geometrically maintains features, and has no self-intersection. d Guaranteed M d Having any of these properties is a solved problem. However, ensuring that M d It is a challenging task to extract all the attributes of M. In the present disclosure, mesh extraction may include the following steps: (1) Calculate M iThe method comprises the following steps: (1) performing an appropriate voxel discretization of the unsigned distance function defined in the algorithm; (2) extracting an isosurface with recovered feature vertices for each voxel; (3) edge flipping the extracted mesh to recover feature lines; and (4) performing post-processing to suppress noise in feature calculations. For the extracted mesh, interior components may also be removed.

[0069] In the first step of mesh extraction, an implicit function discretization can be performed to obtain the i A plurality of voxels are generated in the bounding box of the image, and one or more isosurfaces can be determined in each voxel.

[0070] Input grid M i An exemplary process of voxel generation in can be shown in Algorithm 1. As shown in step 1 of Algorithm 1, the input grid M can be determined i At step 2, the diagonal length L of the bounding box can be determined. At step 3, the length parameter L can be determined d is the product of the following two items: (i) the larger value of the equal value d and a constant value (such as 0.1) and (ii) the diagonal length L. At step 4, the upper right coordinate M can be determined by shifting the upper right coordinate of the bounding box, for example, shifting the upper right coordinate of the bounding box by the length parameter L d The lower left coordinate m can be determined by shifting the lower left coordinate of the bounding box, for example, by shifting the lower left coordinate of the bounding box by the length parameter L. d . At step 6, the size of each voxel may be determined. For example, the size of each voxel may be determined as a value (which may be equal to the product of the value d and the modulus obtained by subtracting the lower left coordinate m from the upper right coordinate M) divided by the square root of 3. At step 7, a first voxel number N indicating the number of the plurality of voxels in a first direction (e.g., x) may be determined. x , a second voxel number N indicating the number of the plurality of voxels in a second direction (eg, y) y , and a third voxel number N indicating the number of the plurality of voxels in a third direction (eg, z) z At step 8 , a number of voxels in a bounding box of the input mesh may be determined based on the first number of voxels, the second number of voxels, the third number of voxels, the upper right coordinate, and the lower left coordinate.

[0071] Because M i is topologically complex and has an undefined interior (or has an interior that includes detailed features), and therefore may not be an M iCalculate the signed distance function. Therefore, an unsigned distance function can be applied to avoid any ambiguity. The unsigned distance function can be defined as follows: p can be M i point in the environment space of M, and q can be i surface points.

[0072] Therefore, the d-isosurface can be determined by solving f(p) = d. Since it is difficult to obtain an exact solution for this p, it is possible to make M i The surrounding environment is uniformly voxelized and can be approximated using piecewise linear interpolation. The size of the voxel plays a crucial role in the mesh to be extracted. Too large a voxel may miss important solutions, while too small a voxel may result in a dense mesh that is computationally expensive. Figure 13 An exemplary diagram of a grid extracted based on different voxel sizes is shown. To determine the side length of the voxel to avoid missing some geometric structures. Figure 3 Exemplary sizes of voxels are shown. Figure 3 As shown, for example, a plurality of voxels (e.g., (320) and (340)) may be determined according to Algorithm 1. The input surface (306) may pass through the voxel. One or more theoretical d-isosurfaces (e.g., (308) and (310)) may be identified as passing through the voxel. The theoretical d-isosurfaces (308) and (310) may be parallel to the input surface (306) and have the same distance from the input surface (306). The theoretical d-isosurfaces may not be captured by actual isosurface extraction.

[0073] In the second step of mesh extraction, characteristic vertices (or characteristic points) may be determined based on the isosurfaces determined in the first step. For each voxel, a root-finding approximation template may be applied to determine connected iso-contours. Figure 19 An exemplary illustration of a template of isolines (or isosurfaces) in a voxel is provided in . Additional feature vertices (or feature points) can then be calculated (or determined) for each isoline, and the isolines can ultimately be triangulated. The extracted mesh can be obtained based on a marching cube (MC) method or MC33 to ensure that the extracted mesh is closed and manifold. In one embodiment, MC33 can be applied in the present disclosure as a base template to determine the extracted mesh, because MC33 can cover more linear interpolation cases, resolve ambiguities in MC, and achieve a smaller number of genus in the final extracted mesh.

[0074] like Figure 4As shown, for the contour surface (404), vertices (or feature points) can be inserted into each MC33 component to provide more degrees of freedom to capture possible feature points. Figure 4 is a 2D illustration of the isosurface extraction step within a square (e.g., (402)). The square (e.g., (402)) may represent a top view of a voxel. The curve (404) r0 may represent a theoretical isosurface. The line (410) r e Can represent the extracted isosurface. np e (406) can be the intersection point p between r0 and the square e Input normal information at (420). p s (414) may be a separating plane used to prevent self-intersection within the square (402). The separating plane (414) may separate the voxel into two components. s (412) can be the normal to the separating plane (414). Feature points (408) and (422) can be determined in each component of the voxel (or square). Therefore, the theoretical isosurface (404) can be formed based on the intersection point p e (420) and the extracted isosurface (406) formed by the feature points (408) are represented.

[0075] Figure 4 It is shown that the intersection of tangent planes (e.g., (410)) with roots (e.g., (420)) computed on voxel edges can produce additional points (e.g., (408)) near sharp features. However, the additional vertices may be positioned arbitrarily and result in self-intersections in the extracted isosurface. For example, Figure 4 As shown, the extracted isosurface (416) based on the feature vertex (426) and the extracted isosurface (418) based on the feature vertex (424) intersect. To solve the intersection problem, the feature vertex can be constrained to be within the subspace of the voxel to ensure that the extracted mesh has no self-intersection. The subspace of the voxel can be constructed for each feature point by simply inserting a set of cutting planes into the voxel. Although Figure 4 The subspace construction strategy is shown in 2D, but Figure 19 and Figure 20 Provides 3D situations corresponding to the MC33 template. Figure 19 For each of the MC33 templates shown, a cutting plane can be generated separately. For the case with only a single contour, the cutting plane can simply be the six faces of the voxel, such as Figure 19 As shown in case 0. For the case with more than one contour, the voxel can be divided into several polyhedra, where each polyhedron can be a subspace. Figure 4 A 2D diagram is given. Figure 4In the example of , two components (402A) and (402B) are located on both sides of the voxel (402). Therefore, the voxel can be divided into a "lower left" side (402B) and an "upper right" side (402A), and the corresponding feature points (such as (408) and (422)) are constrained within the corresponding domains.

[0076] Therefore, the coordinate x of the feature point can be obtained by solving the linear constrained quadratic programming (or function), as shown in equation (2): Condition: n i ·x≥0∧lx≤x≤ux Among them, p e is the root found for each voxel edge, It is p e Any normalized component of the Clarke subdifferential at n s Is to constrain x to stay in multiple The normal of the partitioning plane inside the face, and lx, ux are the lower and upper bounds of the coordinate of x, respectively, to ensure that x lies inside the cube. e ∈M i , in order to calculate The mesh normal can be used. First, we can solve any Then set After computing an isosurface with characteristic vertices for each voxel, a closed and manifold mesh can be extracted by approximating f(p)=d.

[0077] In the third step of mesh extraction, the characteristic edges can be recovered. As mentioned in the second step of mesh extraction, the points on the characteristic lines can be recovered. In the third step, if the flipped edge can connect two characteristic points, an edge flipping operation can be applied to each extracted mesh edge to restore the characteristic edge. In one example, the edge flipping operation can flip the edge to the opposite orientation of the edge. For example, Figure 7 As shown, the edge (701) is rotated to the edge (720) based on the edge flip operation. For example, Figure 5 The detailed process of feature edge recovery is shown in Algorithm 2. In order to ensure the no self-intersection guarantee, edge flipping that may cause self-intersection can be skipped.

[0078] As shown in step 1 of Algorithm 2, the feature grid M t Assignable to M d M can be generated in step 2 of mesh extraction by connecting the determined feature points. t As shown in step 4 of Algorithm 2, when the feature grid M is determinedt When both endpoints of an edge are feature points, the edge may be included in the group Q. At step 14, in response to the edge not having been previously flipped, an intersection check is performed to determine whether the edge intersects with one or more adjacent edges. In response to the edge not intersecting with one or more adjacent edges, an edge flip operation may be performed on the edge. After the edge flip operation, an isosurface mesh M may be generated. d .

[0079] In the fourth step of mesh extraction, feature denoising can be performed. As mentioned in the third step of mesh extraction, after feature edge restoration based on edge flipping operation, the isosurface mesh M can be obtained. d . Isosurface mesh M d The desired topological and geometric properties can be satisfied. However, the extracted mesh M d Some areas of may include visually unsightly aliasing artifacts, which can also be a typical problem in related examples. For example, Figure 5 Examples of artifacts are shown in FIG (e.g., (506) and (510)). In order to remove the artifacts, a post-feature recognition process may be applied. In the post-feature recognition process, a feature graph may be constructed, wherein an edge is defined as a feature edge only if its dihedral angle is less than a certain angle threshold θ0. The feature graph may provide a feature network comprising nodes and curves connecting these nodes. A feature curve may be marked as valid only if it comprises more than 10 mesh edges (or feature meshes). In addition, only the feature points on the feature curve indicated as valid may be retained, and the remaining feature points may be selected from the isosurface mesh M. d Removed. Figure 5 As shown, the feature points before and after denoising can be shown in the enlarged areas (510) and (514), respectively, where the isosurface mesh M d The noise characteristics on the ear are successfully removed, while the main sharp features are still preserved.

[0080] In mesh extraction, an interior removal process may be performed. As mentioned above, when an unsigned distance function (e.g., equation (1)) is applied, the final MC33 result (e.g., the isosurface mesh M d ) may have completely invisible internal components. Considering the generated mesh M d If it is closed and has no self-intersections, then an in-and-out test can be applied to determine the internal components and further remove the internal components.

[0081] Figure 5 An exemplary process of mesh extraction is shown. Figure 5 As shown, the input grid M can be provided i(502) The unflipped feature grid M can be extracted based on the first and second steps of grid extraction as mentioned above. t (504). Figure 5 As shown, the feature grid M t The enlarged region (506) of the ear shows artifacts (eg, sawtooth artifacts). The unflipped EMC33 feature mesh M can be recovered based on the third step of mesh extraction. t The characteristic edge of the feature to generate the flipped feature mesh (or isosurface mesh) M d (508). d As shown in the enlarged area (510) of (508), M d The noise features on the ear of (508) still exist. After feature denoising, the final isosurface mesh M d The noise features in (512) can be removed, where M d The noise features on the magnified area (514) of (512) are removed. Figure 5 As shown, the mesh extraction process can successfully resolve the jagged shape artifacts at the character's ears to render a smooth shading effect while still maintaining the input mesh M i The main sharp features of (502).

[0082] For example, the detailed process of mesh extraction can be shown in Algorithm 3. As shown in step 1 of Algorithm 3, the input grid M i A plurality of voxels are generated in the bounding box of . For example, the details of voxel generation are provided in Algorithm 1. At step 2, an unsigned distance field can be determined based on equation (1). An isosurface can then be determined based on the unsigned distance field. At step 4, for each cube (or voxel), an EMC 33 template can be determined, and the voxel can be divided into multiple components based on the EMC 33 template. Figure 19 An exemplary EMC 33 template is shown in FIG. At step 6, equivalent points on the cube edge can be determined in each component of the voxel (e.g., (420)). At step 7, a linearly constrained quadratic program can be formed based on the equivalent points according to Equation 2. At step 8, the characteristic points of each component of the voxel can be solved based on the linearly constrained quadratic program. Figure 19 The feature points can be triangulated to generate an isosurface mesh M d At step 11, an edge flipping operation may be performed to restore M d At step 12, feature denoising can be performed to remove noise features. At step 13, Md internal components.

[0083] Grid optimization can be done from the grid M o =M d Start (for example, change M d Assigned to M o As the input mesh for mesh optimization). The mesh can be closed, manifold, feature-preserving and without self-intersections. Iterative mesh optimization methods can be introduced to obtain the final M that meets the desired properties. o , these properties may include: (1) if n F If M is provided as a parameter, o The number of triangles is either as small as possible or equal to n F ; (2) When rendering at the viewing distance so that along M i The number of pixels occupied by the diagonal of the bounding box is less than n p When M o With M i Indistinguishable; (3) M o are topologically and geometrically clean, i.e., closed, manifold, and non-intersecting; and (4) M o Keep M as much as possible i The mesh optimization involves at most N iterations of the following three sequential steps: simplification, flow, and alignment. Algorithm 7 shows the details of the mesh optimization. The iteration may not stop until the Hausdorff distance between the simplified meshes of two consecutive cycles is less than ∈1, or the number of cycles (or iterations) is N, or the target number of faces n is reached. F , where the first condition has the highest priority by default. Each of these three steps can involve only local operations. In order to ensure that the optimization is moving towards generating M with the desired properties o Moving forward, the grid before and after the local operation can be applied (respectively represented by M b and M a ) performs the following checks: (1) Topological consistency: M a It is a manifold and closed, with the same b Same genus and number of components; and (2) No self-intersection: M a No triangles intersect, overlap, or touch.

[0084] The simplification steps aim to achieve M o The first attribute, M o Contains as few triangles as possible. In the example of the simplification step, M oApply edge collapsing operations to all edges of M to reduce as many faces as possible, where the coordinates of the newly generated vertices are determined by the quadratic edge metric (QEM) weighted by the virtual plane for each edge to avoid degeneracy in planar regions. It is important to maintain M during the simplification process by skipping those edge collapsing operations that may violate the above checks. o In addition, to ensure the topological and geometric validity of M o Closer to M i (For example, the isosurface mesh M d ), you can also skip it to increase M o and M i To ensure similar visual appearance, folding operations that result in large Hausdorff distance updates can be skipped, which can be achieved by o Ten points are sampled on the local triangle patch to approximate the Hausdorff.

[0085] Algorithm 4 shows an exemplary simplification process.

[0086] As shown in Algorithm 4, at step 3, M can be taken from a set of edges Q. o In response to the determination at step 4 that the edge is not to be collapsed, a validity check may be performed at step 7. The validity check at step 7 may verify that the edge collapse operation is performed on the edge to form the simplified mesh M. s Afterwards, whether the topological consistency is satisfied. In some embodiments, the edge collapse operation can collapse the edge by removing the edge, merging the adjacent vertices of the edge into one vertex, and reconnecting the adjacent edges to the merged vertex. Figure 7 In the example of , an edge is removed by an edge collapse operation ( 701 ), and a new vertex is created based on the edge collapse operation ( 702 ).

[0087] In response to satisfying the topological consistency, a self-intersection check may be performed at step 10 to verify that M s Is there no self-intersection? s If there is no self-intersection, then at step 15, determine the subgrid M of the input grid sub With the simplified grid M s Subgrid M sub 'Whether the first distance between them is greater than the equal value d. Input subgrid M of the grid sub The faces adjacent to the edge e (e.g., (701)) before the edge collapse operation may be included. s Subgrid M sub' may include faces associated with the edge after the edge collapse operation. For example, Figure 7 As shown, M sub 's faces (eg, (704) and (706)) may be in contact with vertices (eg, (702)) that are determined (or newly formed) when an edge collapse operation is applied to an edge (eg, (701)).

[0088] In response to the first distance dist(M sub , M sub ') is less than the same value, then at step 18, a determination can be made to determine the subgrid of the input grid and the reference grid M i The second distance between dist(M sub , M i ) is less than the third distance dist(M) between the subgrid of the simplified grid and the reference grid sub ', M i ). In some embodiments, the reference grid M i It can be the input grid provided in the grid extraction. In response to the second distance being greater than the third distance, the input grid M can be o The edge collapse operation is performed on the second edge of the mesh M. o When each edge of s .

[0089] The flow step is designed to make M o Geometrically close to M i , to reduce the visual difference in outlines between the two meshes. Since the flow process is purely geometric, the mesh connectivity can be modified without the flow process. Therefore, only a self-intersection check is required. In some embodiments, an iterative flow process can be introduced into the mesh optimization. An exemplary iterative flow process can be provided in Algorithm 7.

[0090] When the grid flow process is actually applied, for M o Each vertex υ in M i Identify the point with the closest Euclidean distance to the vertex υ Furthermore, we can follow the vector Push the vertex υ to In some embodiments, instead of using the entire vector as the gradient, v can be directed toward Deformation, which can provide more movement space for the entire grid and reduce the o Still far away from M i In some embodiments, a simple line search can be applied to the no self-intersection check to find the maximum step size during local deformation. Algorithm 5 shows an example of the mesh flow process. As shown in Algorithm 5, at step 1, a constant value such as 1 may be assigned to the fractional ratio α. i ) to determine the simplified grid M s The nearest vertex of vertex v The nearest vertex to vertex v can be determined The vector d between the vertex υ υ At step 2, the position of vertex υ can be updated to υ+αd v . In addition, it may be determined whether the face of the simplified mesh including the vertex intersects one or more adjacent faces in the simplified mesh. At step 3, in response to the face of the simplified mesh including the vertex intersecting one or more adjacent faces, the fractional ratio α may be reduced, for example, by 50%. At step 5, in response to the face of the simplified mesh including the vertex passing the self-intersection check, the position of the vertex v may be updated to v+0.95αd, for example. v .

[0091] The mesh streaming process can stretch the mesh uniformly (or equally in each dimension of the mesh), which can destroy features and produce dirty input for subsequent mesh simplification and streaming processes. Figure 6 An example of the effect of the mesh flow process is shown in . Therefore, a feature alignment step can be applied after the mesh flow process. In the feature alignment step, for the mesh M that is simplified after the mesh flow process s Each vertex v can be obtained by making the local surface of v before the mesh flow and the optimized position υ * Minimize the shape difference between the local surfaces to determine υ * In some examples, the simplified grid M s The feature alignment step is performed on a subset of vertices of . For example, the optimal position v of vertex v can be determined based on unconstrained quadratic programming (or function) * , as shown in equation (3): As shown in equation (3), n(f) and The shape difference is approximated by the normal inconsistency. n(f) can be the current mesh (e.g., the simplified mesh M after the mesh flow process). s ) is the non-normalized face normal (normal). It can be the mesh before the mesh flow step (for example, the simplified mesh M s ) is the non-normalized face normal. As shown in Algorithm 6, n(f) and It can be calculated by the cross product of any two face edges. The summation range covers all faces within the 1-ring neighborhood of vertex v. The faces within the 1-ring neighborhood of vertex v can be faces that are directly in contact with vertex v. Note that equation (3) is a nonlinear function that can be solved by the classical Newton method. For efficiency, ‖n(f)‖ can be regarded as a constant, which can be equal to the value at the beginning of the feature alignment step, which is expressed as c n Therefore, equation (3) can be solved based on the quadratic approximation shown in equation (4) below.

[0092] By solving the unconstrained quadratic program (or function) shown in equation (4), the corresponding υ that minimizes equation (4) can be determined * Through the self-intersection check based on Algorithm 5, the vertex υ can also be updated to v * , where d v =v * -υ.

[0093] Figure 6 An exemplary effect of the feature alignment process is shown. Figure 6 As shown, a high polygon mesh (602) may be provided as input. A magnified area (604) of the high polygon mesh (602) illustrates a door entrance. After simplification and flow processes, a mesh (606) may be generated. As shown in a magnified area (608) of the mesh (606), a destroyed feature may be shown at the door entrance. After feature alignment, a low polygon mesh (610) may be generated. A magnified area (612) of the low polygon mesh (610) illustrates clear features at the door entrance.

[0094] An exemplary feature alignment process may be shown in Algorithm 6. As shown in Algorithm 6, at step 2, the unnormalized face normal n of face f in the face union N(υ) can be determined: f The face union N(υ) may include faces that are in direct contact with vertices υ of the input mesh after simplification and flow. f is the cross product of the two face edges e0 and e1 of face f. At step 3, the normal constant c n Can be determined as the non-normalized surface normal n f At step 4, the simplified grid M can be determined s The unnormalized face normal of the face corresponding to face f in At step 6, the optimal position v of vertex v can be determined by minimizing equation (4) * .

[0095] The grid optimization process can be shown in Algorithm 7. As shown in step 1 of Algorithm 7, the isosurface M d Assignable to M o As the input grid. In step 2, the reference grid M can be determined i The diagonal length of the bounding box is L. In one example, the reference grid M i It can be a high polygon mesh from which the isosurface M is derived based on mesh extraction d In step 4, M o can be assigned to the intermediate grid M'. At step 5, a grid simplification process can be performed based on, for example, Algorithm 4 to generate a simplified grid M s At step 6, the simplified grid M s Assignable to M o At step 8, the grid M can be determined o The nearest vertex of vertex υ nearest vertex It can be located at the reference grid M i The vertex u in the figure that has the closest distance to the vertex υ. At step 9, the first vector d can be determined v At step 10, M can be calculated based on Algorithm 5. o Execute the flow process. At step 13, for example, M can be o Perform the feature alignment process. Based on the feature alignment process, the optimized position v of the vertex υ can be determined * At step 14, the optimized position v of vertex v can be * The difference between the position of the vertex υ and the position of the vertex υ determines the second vector d v At step 15, based on the second vector d v , for example, based on Algorithm 5, another feature flow process is performed. As shown in Algorithm 7, the grid optimization process can be performed based on an iterative process. When the number of iterations i is greater than the target value N, or the grid M o When the Hausdorff distance between the grid and the middle grid M' is less than a threshold, the iterative process can be terminated. The threshold can be 10 -5 The smaller number between L and 0.1dL. It should be noted that when the iterative process is completed, the grid M o is the final low-polygon output mesh.

[0096] The present disclosure provides accelerated self-intersection checking. Starting with a 3D triangle mesh that has no intersections, the low-polygon remeshing process of the present disclosure may introduce intersections. For example, intersections may be introduced when performing edge flipping in mesh extraction, edge collapsing during the simplification step of mesh optimization, and vertex optimization (e.g., flow and alignment steps) of mesh optimization. Intersections of a mesh may include overlap of any two triangles of the mesh, or contact or penetration of any two non-adjacent triangles of the mesh.

[0097] For vertex v, N i (v) can be expressed as the set of all triangles restricted to the neighborhood of the ith ring of vertex v. For example, Figure 7 As shown, the N of vertex (702) 1 (v) may include triangles (704) and (706). N of vertices (702) 2 (v) may include triangles (708) and (710). N of vertices (702) 3 (υ) may include triangles (712) and (714).

[0098] For edge e and triangle f, N i (v) and N i (f) can be defined as ∪ v∈e N i (v) and ∪ v∈f N i (v). M e It can be defined as a submesh that includes all faces updated after an edge operation (such as edge flipping or edge folding). For example, Figure 7 As shown, for edge flipping, M e = {f1, f2}, where f1 and f2 are two adjacent triangles of e(720). For edge folding, M e =N l v′, where v′ is the newly created vertex (702), and M e Including the faces that are in contact with v′ (e.g., (704) and (706)). For vertex optimization (or vertex update), M e =N l v′, where M e May include triangles (or faces) (e.g., (716) and (718)) that are in contact with the newly created vertex (703). f It can be expressed as e A submesh formed by all faces that share at least one vertex. For example, when edge collapse is applied, M f May include faces (708) and (710). M1=M f ∪M e .. The rest of the grid can be represented as Mr For example, when edge collapsing is applied, M r May include faces (712) and (714).

[0099] Whether the operation introduces self-intersection is equivalent to satisfying the following two conditions: (1) M e Not with M r Intersect, (2) M1 has no self-intersection. Usually, these two conditions can be handled by triangle-triangle intersection check. However, for checking M e Whether with M r intersect, especially when M r When a large number of triangles are involved, triangle-triangle intersection checking is inefficient. e Not with M r Share any vertex or edge, can be checked by BVH-based collision detection M e Whether with M r Intersection. The BVH mesh intersection check can be shown in Algorithm 8. As shown in Algorithm 8, at step 1, a BVH tree type variable may be initialized. At step 2, a grid M may be constructed based on the BVH tree type variable. r At step 4, the closest face of face f can be assigned to f1, where face f belongs to M e , and the nearest surface of surface f belongs to M r At step 5 , a triangle-triangle intersection check may be performed to check whether face f and the nearest face f1 intersect.

[0100] To check whether M1 has no self-intersection, since M e All faces in M f The faces in share at least one vertex, so the BVH-based acceleration is no longer effective. Therefore, |M1|·(|M1|-1) / 2 can be applied to the triangle-triangle intersection check. Although |M1|=|M e |+|M s | is typically small, but edge flipping, edge collapsing, and vertex optimization operations are performed multiple times throughout the remeshing process. Avoiding any unnecessary, computationally expensive triangle-triangle intersection checks can yield significant speedups. Note that by construction, M1 is open-ended, with one boundary ring. To check whether a mesh with a boundary has self-intersections, in a related example, the following sufficient condition can be provided: Let S be a continuous surface bounded by C. S has no self-intersections if there exists a vector vec such that: (1) Surface Normal Test: For each point p, n in S p vec>0, where n p is the surface normal at p. (2) Contour test: The projection of contour C along vec has no self-intersection. In a related example, a discretized version of the triangle mesh can be provided as follows: (1) Surface normal test: The angle of the normal cone formed by all triangular face normals is less than (2) Contour test: The projection of the mesh boundary C along the normal cone axis has no self-intersection. For surface normal testing, a tight normal cone merging algorithm can be applied. For contour testing, a side-sign based non-projective contour test can be applied.

[0101] In the present disclosure, determining only the surface normal test is sufficient to ensure the absence of self-intersections, provided the mesh is always closed. The surface normal test may require only |M1| normal cone extensions. If the surface normal test fails, a triangle-triangle intersection check can be applied. As shown in Tables 2 and 3, applying only the surface normal test can speed up the full normal cone test by approximately 100 times, and the parallel triangle-triangle pair check by 10 times. Furthermore, the normal cone test acceleration can speed up the entire flipping process by 1.6 times and the folding process by 2.6 times.

[0102] An exemplary summary of the speedup of edge flipping operations for some figures in this disclosure is shown in Table 2. The superscripts 't', 'b', 'l', and 'r' in the columns of each figure represent 'top', 'bottom', 'left', and 'right', respectively. Nei Represents the cost of adjacent triangle intersection checking using only surface normal testing. T' Nei and T* Nei Same timing information for full normal cone testing (surface normal + silhouette testing) and parallel triangle pair intersection checking. Speedup r is also reported. s . Table 2. Summary of the acceleration of edge flip operations

[0103] Table 3 shows a summary of the speedup of the edge collapse operation for some graphs of this disclosure. Table 3. Summary of the speedup of edge folding operations

[0104] The disclosed algorithm is implemented in C++, using Eigen for linear algebra routines, CGAL for exact triangle-triangle intersection checking, libigl for basic geometry processing routines, with an embedded fast WindingNumber for internal component identification. A bottom-up BVH traversal algorithm is applied to refit the BVH for self-intersection checking, and Metro for Hausdorff distance calculation. In one example, θ0=120°, l0=4, N=50, The experiments in this paper are performed on a workstation equipped with a 32-core Intel processor (clock frequency 3.7 GHz) and 256 GB of memory, and TBB is used for parallelization.

[0105] The disclosed algorithm was tested on a dataset that is a subset of Thingi10K. 100 models were randomly selected, and models with fewer than 5000 triangles were filtered out. In the dataset, the average number of faces and disconnected components were 120,000 and 10, respectively. The average number of non-manifold edges and self-intersecting triangle pairs were 2197 and 6729, respectively.

[0106] The generated low-polygon mesh output can be evaluated based on the number of triangles it contains, its topological (closed and manifold) and geometric structure (no self-intersections), and its visual preservation of the input.

[0107] Regarding visual preservation metrics, since the present disclosure is based on a visual preservation remeshing algorithm, any geometry preservation metrics (such as Hausdorff distance) may not be suitable for evaluation, especially when many inputs involve internal geometric structures. Internal geometric structures may contribute less to visual perception. Therefore, for visual similarity measurement, the following metrics can be used: (1) Light Field Distance (LFD), which measures the visual similarity between two 3D shapes based on model retrieval. (2) Differences in silhouette and normal for visual similarity comparison. (3) Peak Signal-to-Noise Ratio (PSNR), a well-known metric used as a quality measure between the original and compressed models in image space.

[0108] The proposed method of the present disclosure is comparable to commercial software (e.g. the most advanced commercial solution: Simplygon's mesh reduction (e.g. Simplygon 1 ) modules and remeshing (e.g. Simplygon 2 ) module). Simplygon can automatically generate simplified meshes, which is commonly used by game studios. 1The number of triangles in the output mesh can be flexibly controlled, so by matching the Simplygon 2 The number of triangles in the output is used to compare the visual preservation metric and guarantee.

[0109] The evaluation result of matching the number of triangles of the proposed method with Simplygon can be expressed as Ours S The evaluation results performed without applying the number of target faces as one of the stopping criteria can be denoted as Ours. The compared LFDs are listed in Table 5. Figure 8 The differences between the proposed method and commercial software are highlighted in. Figure 8 A comparison between the proposed algorithm and Simplygon is shown. (·,·) represents (number of faces, light field distance). Note that some input meshes may have inconsistent face orientations, such as the mesh (802) shown in the top row, where some triangles of the mesh are rendered black. Figure 8 As shown, compared with the two algorithms of Simplygon, the proposed method (such as Ours or Ours S ) can ensure that the output is closed and has no self-intersection. In addition, under the same simplification ratio, the proposed method is on average better than Simplygon on the test dataset. 1,2 The visual scores were improved by 63.2% and 10.7% respectively.

[0110] The proposed algorithm is also compared with academic methods. For example, the proposed algorithm is compared with PolyFit. The proposed algorithm is also compared with commonly used low-polygon mesh generation methods such as the QEM module in MeshLab and the Blender decimation modifier. For PolyFit, the uniform sampling filter in MeshLab is applied to sample 1M points on the input high-polygon mesh, and the built-in PolyFit API in CGAL is used (with default parameters) to generate the final mesh. For all these methods, the target number of faces is set to the same as that generated by Simplygon. 2 The number of meshes generated is the same. One thing to note is that PolyFit usually generates meshes with much fewer triangles. Therefore, the proposed algorithm is simplified to match the number of triangles of the output of PolyFit, which can be expressed as Ours P. For QEM, the target number of triangles of QEM can be matched and the topology preservation option can be turned on. If the simplification fails to reduce the number of elements to the desired value, the topology preservation option can be turned off. As shown in Table 5, Polyfit failed to generate results for 46 of the 100 models due to failed planar feature detection. The method of Gao et al. (e.g., Low Polygon Mesh Generation for Constructing Models. In Proceedings of the ACM SIGGRAPH 2022 Conference (Vancouver, British Columbia, Canada) (SIGGRAPH'22). Association for Computing Machinery, New York, NY, USA (Article 3, 9 pages) failed to provide any results for 13 of the 100 models within the 1 hour computational time limit. QEM and Blender produced significantly worse results in terms of topology and geometry guarantees. As shown in Table 4, the method of the present disclosure achieved the best visual similarity score, with LFDs that were 95.0%, 58.6%, 74.5%, and 75.3% smaller than those of PolyFit, QEM, Blender, and Gao et al., respectively. Figure 9 A comparison between the proposed algorithm and academic methods is also shown.

[0111] Table 4 shows the geometric statistics of different methods. In the first three columns (e.g. #V, #F and #Comp), the average number of vertices, faces and components of the output mesh is provided. All methods in Table 4 are simplified to meet the requirements of Simplygon. 2 The output of Simplygon 2 The simplification ratio cannot be controlled. It should be noted that even if a target number is set, some methods still generate fewer faces on average because the first pass of the method (e.g., ftetWild) generates a surface whose number of faces is less than the target number. In the three columns following the first three columns, the self-intersection-free ratio, manifold ratio, and closure ratio are provided, respectively. As shown in Table 4, the proposed method of the present disclosure is the only remeshing method that generates closed and self-free remeshing surfaces. It should be noted that some re-pairing methods (e.g., AlphaWrapping) also guarantee these properties, but the subsequent extraction process may destroy these properties. Table 4 also provides the success rate when the algorithms in Table 4 are applied to generate remeshed surfaces. When the algorithm terminates due to an exception or reaches a timeout threshold (1h), this is considered a failure. For TetWild, fTetWild, ManifoldPlus, and AlphaWrapping, all numbers in brackets are values ​​before QEM is applied. Table 4 Geometric statistics of different methods

[0112] Table 5 shows the visual similarity measurement statistics of different methods. The visual similarity between the input mesh and the output by different methods can be shown. The subscripts ave and SD are abbreviations for average and standard deviation, respectively. PSNR is peak signal-to-noise ratio, LF means light field distance metric, SD and ND are silhouette difference and normal difference, respectively. Among the four metrics, a larger PSNR indicates better performance, while the opposite is true for the other three metrics. As shown in Table 5, the method proposed in the present disclosure achieves better visual similarity on average. Table 5 Visual similarity measurement statistics of different methods

[0113] Figure 9 A comparison with academic and open source solutions is shown, where (·,·) represents (number of faces, light field distance). Inverted faces are rendered black. Note that even after reorientation using MeshLab, inverted faces still appear in the PolyFit result. Furthermore, PolyFit also fails in the second example (902).

[0114] The proposed method is compared with an alternative process. In the alternative method, the input surface is first repaired to obtain a high-quality surface mesh. A mesh simplification step (e.g., QEM) is then applied to remesh the output to a specific face number. The proposed method of the present disclosure is compared with four variants of the two-step process (e.g., TetWild+QEM, fTetWild+QEM, ManifoldPlus+QEM, and AlphaWrapping+QEM). In the comparison, the topology and normal preservation options are first turned on, and the target face number is set to Simplygon. 2 If MeshLab fails to simplify the mesh under these conditions, turn off the topology and normals options and perform the mesh simplification step again (e.g. QEM). Figure 10 The main drawback of the two-step process in the alternative workflow is that the mesh repair method fixes the mesh to different levels, and the subsequent simplification step (such as QEM) can destroy the desired properties, especially when the desired number of elements is small. As shown in Table 4, while MainfoldPlus and AlphaWrapping generate manifold and closed meshes, respectively, the subsequent simplification step (such as QEM) destroys both the manifold and closed meshes.

[0115] Figure 10A comparison between the proposed method and an alternative approach is shown, where the mesh is first repaired and then a classical mesh simplification algorithm (e.g. QEM) is run to obtain a low-polygon remeshed result. Figure 10 As shown in , although some algorithms are effective in the first stage, the second simplification stage will destroy the desired geometric properties. For example, Tetwild and ManifoldPlus are effective in the first stage, but in the second simplification stage, after applying QEM, the geometric properties are destroyed. Still refer to Figure 10 , (·,·,·,·) indicate (number of faces, light field distance, self-intersection-free flag, manifold flag). Note that AlphaWrapping always generates self-free and closed surfaces, but AlphaWrapping cannot capture sharp features in the input mesh (1002), which leads to a larger light field distance after simplification. fTetWild and MainfoldPlus will have inverted face orientations after QEM (e.g., back faces are rendered black).

[0116] Table 6 shows the time statistics for the proposed method and the comparative methods. As shown in Table 6, the proposed method takes an average of approximately 7 minutes to complete, while, with the exception of Gao et al.'s method (which takes over 10 minutes), the other methods take less than 2 minutes. The most time-consuming parts are edge flipping (in isosurface extraction) and edge folding (in mesh optimization), where self-intersection checks are involved in edge flipping and edge folding. Figure 11 It is shown that in the proposed method, edge flipping and edge folding can occupy more than 80% of the entire process, wherein a large number of self-intersection checks are applied in edge flipping and edge folding to ensure the desired non-intersection property.

[0117] Table 6 shows the time statistics of different exemplary methods. For QEM and Blender, the final remeshed results can be generated within one minute. The numbers in parentheses are the time costs of the corresponding mesh repair algorithms (e.g., TetWild). Table 6: Time statistics for various methods of generating low-polygon meshes

[0118] According to the user-specified screen size n p and the corresponding equivalent d (d = l / n p ) for performance analysis. Table 7 shows the performance of n p The average number of faces, time and visual metrics under the three different choices of n. As shown in Table 7, increasing n p This improves the visual similarity between the output mesh and the input high-polygon mesh. p It may take more time and ultimately result in a larger number of faces. Figure 12 Shown p Exemplary impact of Figure 12 The figure shows remeshing results for different user-specified distance tolerances, where L is the diagonal length of the bounding box of the input mesh. (·, ·) represents (number of faces, light field distance, time cost). Smaller tolerances (such as light field distance) produce better remeshing results, but take longer to complete.

[0119] Table 7 shows the statistics for different input distance parameters, where L is the diagonal length of the bounding box of the input mesh. Reducing the distance produces better remeshing results, but results in a larger face count and slower solution speed. Table 7 Statistics of different input distance parameters

[0120] Given a screen size n p , different voxel sizes can produce different results. Figure 13 In this paper, a comparison between the extracted isosurface results using different voxel sizes is provided. Perform a comparison where 1 is the diagonal length of the bounding box and n p =200. Figure 13 As shown, too large a voxel size can result in missing portions of the extracted isosurface (e.g., mesh (1302)), while too small a voxel size can slow down the extraction (e.g., mesh (1304)). Furthermore, setting the diagonal length of the voxel to be equal to the offset distance can provide a trade-off between efficiency and performance.

[0121] Figure 13 Different extracted isosurfaces for a fixed offset distance using different voxel sizes are shown. (·,·) denotes (# genus, time cost). "NA" indicates that the input mesh (1306) is non-manifold. The black bottom of the input mesh (1306) is due to an inverted face orientation (e.g., the bottom of the input mesh is upside down). Figure 13 As shown, when the voxel size (diagonal length) is too large (=4d), a surface with high genus is obtained. As the voxel size decreases, finer details can be obtained, but the time efficiency decreases.

[0122] Figure 14 Different isosurface results based on different choices of feature line length (or feature curve length l0) are shown. Increasing the feature line length can gradually solve the "jaggies" problem of the initial EMC33 surface (such as the mesh (1402)). At the same time, increasing the feature line length can make some sharp features blurred. In practice, l0=4 is a compromise choice. Figure 14As shown, different thresholds for the feature curve length l0 can produce different results. The top and bottom rows present the same model with different renderings, where the bottom row smoothes the vertex normals by averaging adjacent face normals based on vertex angles. Larger thresholds smooth the geometry (e.g., black areas disappear), but at the same time, blur some sharp features. For example, l0 = 4 was found to achieve a compromise between smoothing the geometry and preserving sharp features.

[0123] Figure 15 An exemplary effect of the flow step fraction ratio r is shown. During the mesh flow process, the flow direction is multiplied by the ratio r to allow more room for movement across the mesh and obtain better optimization results. In practice, a smaller step size can be used to optimize the mesh between the output mesh M0 and the input mesh M0. i At the same time, M0 will have a worse simplification ratio, i.e., a larger number of faces. In this disclosure, the ratio r is set to a default value of Because the default value can balance the simplification ratio and the final visual similarity. Figure 15 Figure 2 provides different results using different flow step fraction ratios r. (·,·) represents (# faces, light field distance). In general, decreasing r produces a smaller light field distance, but at the same time, decreasing r produces an output with a higher number of faces.

[0124] The mesh extraction step of the algorithm proposed in this disclosure can be useful on its own, where many competing algorithms have been proposed in the past, as shown in Table 1. The advantages of the proposed mesh extraction algorithm can be shown by comparing the proposed algorithm with: (1) Marching Cubes 33, (2) Extended Marching Cubes, (3) Dual Contours; and (4) the method of Manson and Schaefer. The first three algorithms serve as baselines, and the last algorithm satisfies all the desired properties listed in Table 1. In order to apply these algorithms to any input mesh M i , input grid M i can be converted to an implicit function using equation (1) and the corresponding Hermitian data for the dual profile. The extended marching cubes algorithm can be modified by the implementation of marching cubes 33, using the embedded dual profile function, and choosing the implementation of Manson and Schaefer to generate the corresponding results. Figure 16 The extracted isosurfaces are shown according to different isovalues ​​(L / 50, L / 100, L / 200 and L / 400), where L is the BBox (M i ) is the diagonal length of . Figure 16 In the examples in , in addition to the method of Manson and Schaefer using the default octree settings, the grid resolution is set based on Algorithm 1. One thing to note is that although Figure 16The methods in

[16] produce reasonable results, but the examples may have some drawbacks. For example, marching cubes 33 produces closed manifold surfaces with no self-intersections, but cannot capture sharp features, especially when the mesh resolution is low (e.g., enlarged region (1602) in mesh (1604) and enlarged region (1606) in mesh (1608)). Extended marching cubes and dual contours recover sharp features, but they either lead to self-intersections or fail to guarantee manifold and self-intersection properties. Manson and Schaefer's method can produce isosurfaces with undesirably high genus (e.g., circled region (1610) in mesh (1612)).

[0125] The remeshing scheme of the present disclosure can be easily adapted to generate a cage of the input mesh, and there is no requirement that the cage be manifold, closed, or have no self-intersections. The cage mesh needs to be completely closed with no penetration of the 3D model. In order to make the cage mesh completely closed with no penetration, intersection checks can be added during the mesh optimization step of the present disclosure. For example, each time the vertex position is updated in the flow and alignment steps, Algorithm 5 can be modified by adding one or more intersection checks between the current mesh and the input mesh to reject any edge collapse that would result in intersection with the input mesh. The additional checks can be efficiently handled by classic BVH-based collision detection. Figure 17 1 shows a cage generated by the algorithm of the present disclosure, where in this case, a shell generated for a cartoon octopus. Unlike related automatic cage formation algorithms such as those provided by Sacht (e.g., "Nested Cages", ACM Trans. Graph. 34, 6, Article 170 (November 2015), page 14), the algorithm of the present disclosure does not make assumptions about the input mesh. For example, Figure 17 The input model in has 32 non-manifold edges and 264 pairs of intersecting triangles. To more thoroughly compare with Sacht's related algorithm, both methods were run to generate cages on a dataset containing meshes with clean topology and geometry, which is required by Sacht's related algorithm. Based on the code provided by the author Sacht, cages with E υarap Energy cage. Both methods were run with the number of triangles in the final cage set to 2000 and a time limit of 1 hour. As shown in Table 8, Sacht's related solution returned a runtime error on 20 models and failed to produce any results within the time limit on 5 models. Meanwhile, the method of the present disclosure successfully generated a tighter cage (e.g., a smaller Hausdorff distance). Figure 18 Additional visual comparisons are shown.

[0126] Figure 18, where (·, ·, ·) represents the Hausdorff distance (e.g., from cage to input, from input to cage, or between input and cage). Figure 18 As shown, even if the input mesh (1802) is closed, the Sacht example may ultimately lead to poor cage shapes in the bottom row (e.g., meshes (1804), (1806), and (1808)).

[0127] Table 8 shows the Hausdorff distance statistics. c→i is the Hausdorff distance from the generated cage to the input mesh, d i→c is the distance in the opposite direction, d H is the Hausdorff distance (d H =max(d c→i ,d i→c )). r s is the success rate. The Sacht example failed to generate results for 20 of the 93 models due to runtime errors and failed to generate results for 5 of the 93 models because the time threshold was exceeded. It should be noted that some cages generated by the Sacht example have a large number of severe artifacts, such as Figure 18 The updated statistics after manually removing these models are provided in the last two rows of Table 8. Table 8 Hausdorff distance statistics between the proposed method and Sacht method

[0128] In the present disclosure, a robust method is provided to generate a low-polygon representation of an arbitrary input mesh. The method can be decomposed into two independently useful stages: (1) an isosurface extraction stage, in which any user-specified isosurfaces are extracted that are closed, feature-preserving, and self-intersection-free of the input mesh using any user-specified isosurfaces, and (2) a mesh-flow back stage, in which re-meshing and flowing the extracted surfaces are alternately performed to satisfy the desired properties: low resolution and visually close to the input mesh. Figure 11 As shown, the method of the present disclosure spends most of its time (about 80%) on the simplification and edge flipping steps of the isosurface extraction stage. These steps involve many intersection checks. Any parallel version of the simplification and edge flipping steps can significantly speed up the process.

[0129] Figure 19 The detailed lookup table of the proposed EMC33 algorithm mentioned in the mesh extraction is shown. Figure 19As shown, 33 cases (or templates) of EMC 33 are provided. Additional points can be inserted for each component of the case (e.g., (1906) in Case 5 and (1908) in Case 1). Cube vertices can be positive and negative. For example, in Case 5, cube vertex (1902) is positive and cube vertex (1904) is negative. Surface-cube intersection points on the edges of the cube can be equivalent points, such as the equivalent point (1910) in Case 3.1. Furthermore, Case 12.2 and Case 12.3 are symmetrical, and Case 11 and Case 14 are symmetrical.

[0130] For cases with more than one component (e.g., Case 3.1 and Case 4.1.1), separating planes can be introduced to divide the cube into several non-intersecting convex domains, and feature points can be solved in the corresponding domains, for example, based on equation (2). Figure 20 The detailed separation strategy is shown in .

[0131] like Figure 20 As shown, rows 1 and 2 are cases with two components, where planes (e.g., plane (2002)) can be formed by cube vertices to achieve partitioning. Rows 3 to 5 are cases with three components, where separating polyhedra can be formed based on cube vertices (e.g., (2004) in Case 7.1). For row 6, separating polyhedra can be formed based on cube centers and cube vertices, where the cube centers are additional polyhedron vertices. As shown in Case 13.1, separating polyhedra (2006) can be formed based on cube centers (2008) and cube vertices (e.g., (2010)).

[0132] Figure 21 A flowchart outlining an exemplary process (2100) for generating a low polygon mesh according to some embodiments of the present disclosure is shown.

[0133] like Figure 21 As shown, process (2100) may start from (S2101) and proceed to (S2110). At (S2110), an edge collapse operation is performed on each of a plurality of edges of an input mesh to generate a simplified mesh, wherein the number of faces of the input mesh is reduced by the edge collapse operation.

[0134] At (S2120), a position of at least one vertex of the simplified mesh is updated to generate an updated mesh, wherein a distance between the simplified mesh and the input mesh is reduced.

[0135] At (S2130), a low polygon mesh is generated based on the aligned mesh, wherein positions of vertices of the updated mesh are optimized by minimizing shape differences between the simplified mesh and the updated mesh.

[0136] In one example, the input mesh is an isosurface mesh generated based on a plurality of isosurfaces in a plurality of voxels of the 3D model, wherein the plurality of isosurfaces are determined based on isovalues.

[0137] In one example, an edge collapse operation is performed on a first edge of a plurality of edges of an input mesh to generate a simplified mesh. A determination is made as to whether the simplified mesh satisfies topological consistency based on whether the simplified mesh is manifold and sealed and has the same genus and the same number of components as the input mesh. In response to the simplified mesh satisfying topological consistency, a determination is made as to whether the simplified mesh has no self-intersections. In response to the simplified mesh having no self-intersections, a determination is made as to whether a first distance between a submesh of the input mesh and a submesh of the simplified mesh is greater than an equal value. The submesh of the input mesh includes faces adjacent to the first edge before the edge collapse operation, and the submesh of the simplified mesh includes faces associated with the first edge after the edge collapse operation. In response as to whether the first distance is less than the equal value, a determination is made as to whether a second distance is less than a third distance. A second distance is determined between the submesh of the input mesh and a reference mesh. A third distance is determined between the submesh of the simplified mesh and the reference mesh.

[0138] In some embodiments, a first submesh is determined in a simplified mesh, comprising at least one first face. Each of the at least one first face contacts a vertex determined when an edge collapse operation is applied to the first edge. A second submesh is determined in the simplified mesh. The second submesh comprises a plurality of second faces, wherein each of the plurality of second faces shares at least one vertex of the first submesh. A third submesh is determined in the simplified mesh, wherein the third submesh comprises a plurality of third faces that are not included in the first submesh and the second submesh. A BVH tree data structure is constructed for the third submesh based on a BVH tree type. For each of the one or more first faces of the first submesh, a nearest face of the corresponding first face is determined in the third submesh. A determination is then made as to whether each of the one or more first faces of the first submesh intersects with the nearest face of the corresponding first face.

[0139] In some embodiments, a target vertex is determined in the input mesh, the target vertex being the closest vertex to a first vertex of the simplified mesh. A vector is determined between the target vertex and the first vertex. The vector is equal to the difference between the position of the target vertex and the position of the first vertex divided by a first constant value. The first vertex is updated based on the vector and the position of the first vertex.

[0140] In one example, to update a first vertex, the position of the first vertex is updated to the sum of: (i) the position of the first vertex and (ii) the product of a vector and a second constant value. A determination is made as to whether a first face in the simplified mesh that includes the first vertex intersects at least one adjacent face in the simplified mesh. In response to the first face intersecting the at least one adjacent face, the position of the first vertex is updated to the sum of: (i) the position of the first vertex and (ii) the product of the vector, half of the second constant value, and a third constant value. In response to the first face not intersecting the at least one adjacent face, the position of the first vertex is updated to the sum of: (i) the position of the first vertex and (ii) the product of the vector, half of the second constant value, and a third constant value.

[0141] In some embodiments, the first constant value is 8, the second constant value is 1, and the third constant value is 0.95.

[0142] In some embodiments, a non-normalized face normal of a first face in a face union is determined. The face union includes faces in the updated mesh and contacts a first vertex in the updated mesh. A normal constant is determined based on a modulus of the non-normalized face normal of the first face. Non-normalized face normals of faces corresponding to the first face in the simplified mesh are determined. An optimized position for the first vertex is then determined by minimizing an unconstrained quadratic function.

[0143] In one example, the unnormalized face normal of the first face is determined as a cross product of two face edges of the first face.

[0144] In one example, the unnormalized face normal of the face corresponding to the first face is determined as a cross product of two face edges of the face corresponding to the first face.

[0145] In one example, the unconstrained quadratic function is: c n is the normal constant, N(v) is the face union, n(f) is the unnormalized face normal of the first face, is the unnormalized face normal of the face corresponding to the first face.

[0146] In some embodiments, a vector between the position of the first vertex and the optimized position of the first vertex is determined, and the first vertex is then updated based on the determined vector to generate an aligned mesh.

[0147] In some embodiments, an iterative process is performed to generate a low-polygon mesh. In response to one of: (i) a number of iterations of the iterative process being less than a target value and (ii) a Hausdorff distance between the input mesh and the aligned mesh being less than a threshold, an edge collapse operation is performed on each of a plurality of edges of the aligned mesh to generate another simplified mesh.

[0148] The above techniques may be implemented as computer software using computer-readable instructions and physically stored in one or more computer-readable media. For example, Figure 22 A computer system (2200) suitable for implementing certain embodiments of the disclosed subject matter is shown.

[0149] Computer software may be encoded using any suitable machine code or computer language, which may be subjected to assembly, compilation, linking, or similar mechanisms to create code comprising instructions that may be executed directly by one or more computer central processing units (CPUs), graphics processing units (GPUs), etc., or through interpretation, microcode execution, etc.

[0150] The instructions may be executed on various types of computers or components thereof, including, for example, personal computers, tablet computers, servers, smart phones, gaming devices, IoT devices, and the like.

[0151] Figure 22 The components of the computer system (2200) shown are exemplary in nature and are not intended to suggest any limitation on the scope of use or functionality of computer software implementing embodiments of the present disclosure. Neither should the configuration of the components be interpreted as having any dependency or requirement relating to any one or combination of components shown in the exemplary embodiment of the computer system (2200).

[0152] The computer system (2200) may include certain human interface input devices. Such human interface input devices may be responsive to input from one or more human users through, for example, tactile input (e.g., keystrokes, swipes, data glove movements), audio input (e.g., voice, hand clapping), visual input (e.g., gestures), and olfactory input (not depicted). The human interface devices may also be used to capture certain media that are not necessarily directly related to human conscious input, such as audio (e.g., voice, music, ambient sounds), images (e.g., scanned images, captured images from a still camera), and video (e.g., two-dimensional video, three-dimensional video including stereoscopic video).

[0153] The human-machine interface input device may include one or more of the following (only one of each is shown): keyboard (2201), mouse (2202), touchpad (2203), touch screen (2210), data gloves (not shown), joystick (2205), microphone (2206), scanner (2207), camera (2208).

[0154] The computer system (2200) may also include certain human-computer interface output devices. Such human-computer interface output devices can stimulate one or more human user senses through, for example, tactile output, sound, light, and smell / taste. Such human-computer interface output devices may include tactile output devices (e.g., tactile feedback of a touch screen (2210), a data glove (not shown), or a joystick (2205), but may also be a tactile feedback device that is not an input device), audio output devices (e.g., speakers (2209), headphones (not depicted)), visual output devices (e.g., screens (2210) including CRT screens, LCD screens, plasma screens, OLED screens, each with or without touch screen input capabilities, each with or without tactile feedback capabilities, some of which are capable of outputting two-dimensional visual output or output exceeding three dimensions through devices such as stereoscopic image output, virtual reality glasses (not depicted), holographic displays, and smoke boxes (not depicted)), and printers (not depicted).

[0155] The computer system (2200) may also include human- and machine-accessible storage devices and their associated media, such as optical media including CD / DVD ROM / RW (2220) having CD / DVD and other media (2221), thumb drives (2222), removable hard drives or solid-state drives (2223), traditional magnetic media such as tapes and floppy disks (not depicted), dedicated ROM / ASIC / PLD-based devices such as security software dogs (not depicted), etc.

[0156] Those skilled in the art will also understand that the term "computer-readable medium" used in connection with the presently disclosed subject matter does not encompass transmission media, carrier waves, or other transitory signals.

[0157] The computer system (2200) may also include an interface (2254) to one or more communication networks (2255). The network may be, for example, a wireless network, a wired network, an optical network. The network may further be a local network, a wide area network, a metropolitan area network, a vehicle and industrial network, a real-time network, a delay-tolerant network, etc. Examples of networks include local area networks such as Ethernet, wireless LANs, cellular networks including GSM, 3G, 4G, 5G, LTE, etc., television wired or wireless wide area digital networks including cable television, satellite television, and terrestrial broadcast television, vehicle and industrial networks including CANBus, etc. Some networks typically require an external network interface adapter attached to some common data port or peripheral bus (2249) (e.g., a USB port of the computer system (2200)); other network interfaces are typically integrated into the kernel of the computer system (2200) by attaching to a system bus as described below (e.g., connecting to an Ethernet interface in a PC computer system or connecting to a cellular network interface in a smartphone computer system). The computer system (2200) can use any of these networks to communicate with other entities. Such communications may be one-way receive only (e.g., broadcast television), one-way send only (e.g., a CANBus connected to certain CANBus devices), or bidirectional, for example, using a local area network or wide area network digital network to connect to other computer systems. Certain protocols and protocol stacks may be used on each of those networks and network interfaces as described above.

[0158] The above-mentioned human interface devices, human-accessible storage devices, and network interfaces may be attached to the kernel ( 2240 ) of the computer system ( 2200 ).

[0159] The core (2240) may include one or more central processing units (CPUs) (2241), graphics processing units (GPUs) (2242), specialized programmable processing units in the form of field programmable gate areas (FPGAs) (2243), hardware accelerators (2244) for certain tasks, a graphics adapter (2250), and the like. These devices, as well as read-only memory (ROM) (2245), random access memory (2246), and internal mass storage (2247) such as internal non-user accessible hard drives, SSDs, and the like, may be connected via a system bus (2248). In some computer systems, the system bus (2248) may be accessed in the form of one or more physical plugs to enable expansion with additional CPUs, GPUs, and the like. Peripheral devices may be attached directly to the core's system bus (2248) or to the core's system bus (2248) via a peripheral bus (2249). In one example, a screen (2210) may be connected to a graphics adapter (2250). Peripheral bus architectures include PCI, USB, and the like.

[0160] The CPU (2241), GPU (2242), FPGA (2243), and accelerator (2244) can execute certain instructions, which can be combined to form the computer code mentioned above. The computer code can be stored in ROM (2245) or RAM (2246). Transient data can also be stored in RAM (2246), while permanent data can be stored, for example, in internal mass storage (2247). Fast storage and retrieval to any storage device can be achieved by using a cache, which can be closely associated with the following: one or more CPUs (2241), GPUs (2242), mass storage (2247), ROM (2245), RAM (2246), etc.

[0161] The computer readable medium may have computer code thereon for performing various computer-implemented operations. The medium and computer code may be those specially designed and constructed for the purposes of the present disclosure, or they may be of a type well known and available to those skilled in the art of computer software.

[0162] As an example, and not by way of limitation, a computer system (2200) having an architecture, and in particular a kernel (2240), can provide functionality by virtue of one or more processors (including CPUs, GPUs, FPGAs, accelerators, etc.) executing software embodied in one or more tangible computer-readable media. Such computer-readable media can be media associated with user-accessible mass storage as described above, as well as certain non-transitory kernel (2240) memories, such as kernel internal mass storage (2247) or ROM (2245). Software implementing various embodiments of the present disclosure can be stored in such devices and executed by the kernel (2240). Depending on specific needs, the computer-readable medium may include one or more storage devices or chips. The software can cause the kernel (2240), in particular the processors therein (including CPUs, GPUs, FPGAs, etc.), to perform specific processes described herein or to perform specific parts of specific processes described herein, including defining data structures stored in RAM (2246) and modifying such data structures according to processes defined by the software. Additionally or alternatively, a computer system may provide functionality due to logic hardwired or otherwise embodied in circuitry (e.g., accelerator (2244)) that may operate in place of or in conjunction with software to perform specific processes described herein or specific portions of specific processes described herein. Where appropriate, references to software may include logic and vice versa. Where appropriate, references to computer-readable media may include circuitry (e.g., integrated circuits (ICs)) storing software for execution, circuitry embodying logic for execution, or both. The present disclosure includes any suitable combination of hardware and software.

[0163] Although the present disclosure has described several exemplary embodiments, there are modifications, permutations, and various alternative equivalents that fall within the scope of the present disclosure. Therefore, it will be appreciated that those skilled in the art will be able to devise many systems and methods that, although not explicitly shown or described herein, embody the principles of the present disclosure and, therefore, fall within the spirit and scope of the present disclosure.

Claims

1. A method for generating a low-polygon mesh of a three-dimensional (3D) model, the method comprising: performing an edge collapsing operation on each of a plurality of edges of an input mesh to generate a simplified mesh, wherein a face count of the input mesh is reduced by the edge collapsing operation; updating a position of at least one vertex of the simplified mesh to generate an updated mesh, wherein a distance between the simplified mesh and the input mesh is reduced; and The low polygon mesh is generated based on the aligned mesh, wherein positions of vertices of the updated mesh are optimized by minimizing shape differences between the simplified mesh and the updated mesh.

2. The method according to claim 1, wherein The input mesh is an isosurface mesh generated based on a plurality of isosurfaces in a plurality of voxels of the 3D model, wherein the plurality of isosurfaces are determined based on isovalues.

3. The method according to claim 1, wherein Performing the edge collapse operation further includes: performing the edge collapsing operation on a first edge of a plurality of edges of the input mesh to generate the simplified mesh; determining whether the simplified mesh satisfies topological consistency based on whether the simplified mesh is manifold and sealed and has the same genus and the same number of components as the input mesh; In response to the simplified mesh satisfying the topological consistency, determining whether the simplified mesh has no self-intersections; In response to the simplified mesh having no self-intersections, determining whether a first distance between a submesh of the input mesh and a submesh of the simplified mesh is greater than an equal value, the submesh of the input mesh including faces adjacent to the first edge before the edge-collapse operation and the submesh of the simplified mesh including faces associated with the first edge after the edge-collapse operation; and In response to the first distance being less than the equal value, it is determined whether a second distance between the sub-grid of the input grid and a reference grid is less than a third distance between the sub-grid of the simplified grid and the reference grid.

4. The method according to claim 3, wherein: Determining whether the simplified mesh has no self-intersections further comprises: determining a first sub-mesh of the simplified mesh that includes at least one first face, each of the at least one first face being in contact with a vertex determined when the edge collapse operation is applied to the first edge; determining a second sub-mesh in the simplified mesh, the second sub-mesh comprising a plurality of second faces, each second face of the plurality of second faces sharing at least one vertex of the first sub-mesh; determining a third sub-mesh in the simplified mesh, the third sub-mesh including a plurality of third surfaces, the plurality of third surfaces not included in the first sub-mesh and the second sub-mesh; Constructing a bounding volume hierarchy (BVH) tree data structure of the third sub-mesh based on a BVH tree type; For each of the one or more first surfaces of the first sub-grid, determining a nearest surface to the corresponding first surface in the third sub-grid; and It is verified whether each of the one or more first surfaces of the first sub-mesh intersects with the nearest surface of the corresponding first surface.

5. The method according to claim 1, wherein The update further includes: determining a target vertex in the input mesh, the target vertex being a closest vertex to a first vertex of the simplified mesh; determining a vector between the target vertex and the first vertex, the vector being equal to a difference between a position of the target vertex and a position of the first vertex divided by a first constant value; and The first vertex is updated based on the vector and the position of the first vertex.

6. The method according to claim 5, wherein: Updating the first vertex further includes: updating the position of the first vertex to the sum of: (i) the position of the first vertex and (ii) the product of the vector and a second constant value; determining whether a first face of the simplified mesh including the first vertex intersects at least one adjacent face of the simplified mesh; In response to the first face intersecting the at least one adjacent face, updating the position of the first vertex to be the sum of (i) the position of the first vertex and (ii) the product of the vector, half the second constant value, and a third constant value; and In response to the first face not intersecting the at least one adjacent face, updating the position of the first vertex to the sum of (i) the position of the first vertex and (ii) the product of the vector, the second constant value, and the third constant value.

7. The method according to claim 6, wherein: The first constant value is 8, the second constant value is 1, and the third constant value is 0.

95.

8. The method according to claim 1, wherein The generating further comprises: determining a non-normalized face normal of a first face of a face union comprising faces in the updated mesh and touching a first vertex of the updated mesh; Setting a normal constant based on a modulus of a non-normalized surface normal of the first surface; determining a non-normalized face normal of a face in the simplified mesh corresponding to the first face; and An optimal position of the first vertex that minimizes the unconstrained quadratic function is determined.

9. The method according to claim 8, wherein Determining the non-normalized surface normal of the first surface further includes: A non-normalized face normal of the first face is determined as a cross product of two face edges of the first face.

10. The method according to claim 9, wherein: Determining a non-normalized surface normal of the surface corresponding to the first surface further comprises: A non-normalized face normal of the face corresponding to the first face is determined as a cross product of two face edges of the face corresponding to the first face.

11. The method according to claim 10, wherein: The unconstrained quadratic function includes: c n is the normal constant, N(v) is the face union, n(f) is the unnormalized face normal of the first face, is the unnormalized face normal of the face corresponding to the first face.

12. The method according to claim 8, wherein Generating the low polygon mesh further includes: determining a vector between the position of the first vertex and the optimized position of the first vertex; and The first vertex is updated based on the determined vector to generate the aligned mesh.

13. The method according to claim 12, wherein: Generating the low polygon mesh further includes: Performing an iterative process to generate the low polygon mesh, wherein performing the iterative process further comprises: In response to one of: (i) the number of iterations of the iterative process is less than a target value and (ii) the Hausdorff distance between the input grid and the aligned grid is less than a threshold: An edge collapse operation is performed on each of the plurality of edges of the aligned mesh to generate another simplified mesh.

14. An apparatus for generating a low polygon mesh of a three-dimensional (3D) model, the apparatus comprising: The processing circuit is configured to: performing an edge collapsing operation on each of a plurality of edges of an input mesh to generate a simplified mesh, wherein a face count of the input mesh is reduced by the edge collapsing operation; updating a position of at least one vertex of the simplified mesh to generate an updated mesh, wherein a distance between the simplified mesh and the input mesh is reduced; and The low polygon mesh is generated based on the aligned mesh, wherein positions of vertices of the updated mesh are optimized by minimizing shape differences between the simplified mesh and the updated mesh.

15. The device according to claim 14, wherein The input mesh is an isosurface mesh generated based on a plurality of isosurfaces in a plurality of voxels of the 3D model, wherein the plurality of isosurfaces are determined based on isovalues.

16. The device according to claim 14, wherein The processing circuit is further configured to: performing the edge collapsing operation on a first edge of a plurality of edges of the input mesh to generate the simplified mesh; determining whether the simplified mesh satisfies topological consistency based on whether the simplified mesh is manifold and sealed and has the same genus and the same number of components as the input mesh; In response to the simplified mesh satisfying the topological consistency, determining whether the simplified mesh has no self-intersections; In response to the simplified mesh having no self-intersections, determining whether a first distance between a submesh of the input mesh and a submesh of the simplified mesh is greater than an equal value, the submesh of the input mesh including faces adjacent to the first edge before the edge-collapse operation and the submesh of the simplified mesh including faces associated with the first edge after the edge-collapse operation; and In response to the first distance being less than the equal value, it is determined whether a second distance between the sub-grid of the input grid and a reference grid is less than a third distance between the sub-grid of the simplified grid and the reference grid.

17. The device according to claim 16, wherein The processing circuit is further configured to: determining a first sub-mesh of the simplified mesh that includes at least one first face, each of the at least one first face being in contact with a vertex determined when the edge collapse operation is applied to the first edge; determining a second sub-mesh in the simplified mesh, the second sub-mesh comprising a plurality of second faces, each second face of the plurality of second faces sharing at least one vertex of the first sub-mesh; determining a third sub-mesh in the simplified mesh, the third sub-mesh including a plurality of third surfaces, the plurality of third surfaces not included in the first sub-mesh and the second sub-mesh; Constructing a bounding volume hierarchy (BVH) tree data structure of the third sub-mesh based on a BVH tree type; For each of the one or more first surfaces of the first sub-grid, determining a nearest surface to the corresponding first surface in the third sub-grid; as well as It is verified whether each of the one or more first surfaces of the first sub-mesh intersects with the nearest surface of the corresponding first surface.

18. The device according to claim 14, wherein The processing circuit is further configured to: determining a target vertex in the input mesh, the target vertex being a closest vertex to a first vertex of the simplified mesh; Determine a vector between the target vertex and the first vertex, where the vector is equal to a difference between a position of the target vertex and a position of the first vertex divided by a first constant value; as well as The first vertex is updated based on the vector and the position of the first vertex.

19. The device according to claim 18, wherein The processing circuit is further configured to: updating the position of the first vertex to the sum of: (i) the position of the first vertex and (ii) the product of the vector and a second constant value; determining whether a first face of the simplified mesh including the first vertex intersects at least one adjacent face of the simplified mesh; In response to the first face intersecting the at least one adjacent face, updating the position of the first vertex to the sum of: (i) the position of the first vertex and (ii) the product of the vector, half the second constant value, and a third constant value; as well as In response to the first face not intersecting the at least one adjacent face, updating the position of the first vertex to the sum of (i) the position of the first vertex and (ii) the product of the vector, the second constant value, and the third constant value.

20. The apparatus according to claim 14, wherein The processing circuit is further configured to: determining a non-normalized face normal of a first face of a face union comprising faces in the updated mesh and touching a first vertex of the updated mesh; Setting a normal constant based on a modulus of a non-normalized surface normal of the first surface; determining a non-normalized surface normal of a surface corresponding to the first surface in the simplified mesh; as well as An optimal position of the first vertex that minimizes the unconstrained quadratic function is determined.

Images