Low-poly mesh generation for 3D models

Abstract

In the method, a visual hull is generated based on an intersection of first 3D primitives of a plurality of first silhouettes with a bounding box of the 3D model. The first silhouettes are generated by projecting the 3D model onto a plane perpendicular to several selected view directions of the 3D model. Each of the first 3D primitives is obtained by extruding a connected loop of the respective first silhouette along one of several selected view directions associated with the respective first silhouette. A cutout mesh is generated based on subtraction of a second 3D primitive derived from a positive portion of the 3D model to cut out redundant structures from the visual hull. The positive portion is obtained based on a fitting plane that slices the 3D model. A low-poly mesh sequence is generated based on progressive simplification of the cutout mesh.

Description

[Technical Field]

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS This application claims the benefit of priority to U.S. Patent Application No. 17 / 737,951, "LOW-POLY MESH GENERATION FOR THREE-DIMENSIONAL MODELS," filed May 5, 2022. The entire disclosure of this application is incorporated herein by reference.

[0002] This disclosure describes embodiments generally related to computational methodologies involving mesh geometry models. [Background technology]

[0003] The discussion of the background art provided herein is intended to generally present the context for the present disclosure. To the extent that it is provided in this background art section, the inventors' work described herein, as well as aspects of the description that may not be admitted as prior art at the time of filing, are not admitted expressly or impliedly as prior art to the present disclosure.

[0004] Three-dimensional (3D) models, such as building models, are important assets that constitute the metaverse for virtual reality. Building modelers typically focus on creating a visually appealing appearance rather than other aspects, such as clean topology and connected geometry. Highly detailed building models can have complex topology and geometry characteristics, such as disconnected components, open boundaries, non-manifold edges, and / or self-intersections. However, rendering consistently detailed building models can be expensive, and some devices, such as low-end platforms, may have more limited computational resources that limit the generation of detailed meshes. To improve runtime performance, level-of-detail (LOD) techniques can be used. For example, instead of using highly detailed (or high-poly) 3D models, low-element-count (low-poly) meshes can be rendered in distant views. Therefore, an effective and robust solution for generating low-poly meshes is needed. Summary of the Invention [Problem to be solved by the invention]

[0005] Aspects of the present disclosure include methods, apparatus, and non-transitory computer-readable storage media for computational methodologies. In some examples, an apparatus for generating a mesh geometry model includes a processing circuit. [Means for solving the problem]

[0006] According to one aspect of the present disclosure, a method for generating a low-poly mesh sequence for a three-dimensional (3D) model is provided. In the method, a visual hull can be generated based on an intersection of first 3D primitives of a plurality of first silhouettes with a bounding box of the 3D model. The plurality of first silhouettes can be generated by projecting the 3D model onto a plane perpendicular to several selected view directions of the 3D model. Each of the first 3D primitives can be obtained by extruding a connected loop of each first silhouette along one of several selected view directions associated with the respective first silhouette. A segmentation mesh can be generated based on subtraction of a second 3D primitive derived from a positive portion of the 3D model to segment redundant structures from the visual hull. The positive portion can be obtained based on several fitting planes that slice the 3D model. The low-poly mesh sequence can be generated based on progressive simplification of the segmentation mesh.

[0007] In the method, a plurality of fitting planes may be formed, and each region of the 3D model may be included in a respective fitting plane of the plurality of fitting planes. A plurality of candidate view directions may be determined. Each of the plurality of candidate view directions may be parallel to a respective pair of fitting planes and associated with a respective weight value. Each weight value may be equal to the sum of the areas of the regions of the 3D model included in the respective pair of fitting planes. A number of selected view directions may be determined from the plurality of candidate view directions associated with the top k weight values, where k may be a positive integer.

[0008] In some embodiments, each of the plurality of first silhouettes of the 3D model can be simplified through at least one of 2D simplification or shape size filtering. One or more hollow loops can be extracted from each of the plurality of first silhouettes. One or more connected loops can be generated for each of the plurality of first silhouettes by subtracting the one or more hollow loops from the 2D bounding box of each of the plurality of first silhouettes. A first 3D primitive can be formed by extruding one or more connected loops of the plurality of first silhouettes along several selected view directions.

[0009] In the method, a first virtual volume intersection can be formed by performing a Boolean intersection operation on a first one of the first 3D primitives and a bounding box of the 3D model to form a virtual volume intersection. A first visual disparity improvement can be determined based on the first virtual volume intersection and the 3D model. In response to the visual disparity improvement being greater than a threshold, a second virtual volume intersection can be formed by performing a Boolean intersection operation on a second one of the first 3D primitives and the first virtual volume intersection. A second visual disparity improvement can be determined based on the second virtual volume intersection and the 3D model.

[0010] To determine a first visual disparity improvement based on the first virtual volume intersection and the 3D model, an initial visual disparity can be determined based on an average pixel-by-pixel disparity between a bounding box of the 3D model and the 3D model. The first visual disparity can be determined based on an average pixel-by-pixel disparity between the first virtual volume intersection and the 3D model. The first visual disparity improvement can then be determined by subtracting the first visual disparity from the initial visual disparity.

[0011] In some embodiments, the nth virtual hull intersection may be determined as the virtual hull intersection in response to one of (i) the nth visual disparity improvement being less than a threshold, and (ii) n being equal to an upper limit N. N may be a positive integer. The nth virtual hull intersection may be formed by performing a Boolean intersection operation on the nth one of the first 3D primitives and the (n-1)th virtual hull intersection.

[0012] In some embodiments, the 3D model can be sliced ​​by multiple fitting planes to form the segmented mesh. Each of the multiple fitting planes can slice the 3D model into a positive portion and a negative portion. The positive portion of the 3D model can be located on a positive side of each of the multiple fitting planes. Each of the positive portions of the 3D model can be projected onto a corresponding one of the multiple fitting planes to obtain a respective second silhouette. An enlarged bounding square of each second silhouette can be obtained on the corresponding fitting plane such that the respective second silhouette is contained in the enlarged bounding square. A Boolean subtraction operation can be performed to subtract each second silhouette from the enlarged bounding square to obtain a boundary loop from each second silhouette. One of the second 3D primitives can be formed by extruding the boundary loop of each second silhouette in a normal direction from the positive side of the fitting plane corresponding to the respective second silhouette.

[0013] The method may include forming a first provisional segmented mesh by performing a Boolean subtraction operation on a first one of the second 3D primitives and the visual hull intersection to form the segmented mesh. A first visual disparity improvement may be determined based on the first provisional segmented mesh and the 3D model. In response to the visual disparity improvement being greater than a threshold, a second provisional segmented mesh may be formed by performing a Boolean subtraction operation on a second one of the second 3D primitives and the first provisional segmented mesh. A second visual disparity improvement may be determined based on the second provisional segmented mesh and the 3D model.

[0014] In some embodiments, in response to one of (i) the nth visual difference improvement being less than a threshold, and (ii) n being equal to an upper limit N, the segmentation mesh may be determined as the nth provisional segmentation mesh, where N may be a positive integer, and the nth provisional segmentation mesh may be formed by performing a Boolean intersection operation on the nth one of the second 3D primitives and the (n-1)th provisional segmentation mesh.

[0015] To generate the low-poly mesh sequence, edge erasure and edge reversal operations can be performed progressively on the segmented meshes to generate the low-poly mesh sequence. Each of the low-poly meshes in the low-poly mesh sequence can include a respective number of triangles that is less than a user-selected value T. T can be a positive integer, and the number of triangles in each of the low-poly meshes can be less than the number of triangles in the segmented mesh.

[0016] In this method, the low-poly meshes in the sequence of low-poly meshes can be ranked based on the number of faces and visual differences of the low-poly meshes to generate a Pareto set.

[0017] According to another aspect of the present disclosure, an apparatus is provided, the apparatus having a processing circuit, the processing circuit being configured to perform any one or combination of methods for generating a mesh geometry model.

[0018] Aspects of the present disclosure 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 combination of methods for generating a mesh geometry model.

[0019] Further features, nature and various advantages of the disclosed subject matter may become more apparent from the following detailed description and accompanying drawings. [Brief explanation of the drawings]

[0020] [Figure 1] FIG. 1 illustrates an example of a high-poly mesh and corresponding low-poly counterparts of multiple high-poly meshes. [Figure 2] FIG. 10 shows an example of a comparison of low-poly meshes generated using different methods. [Figure 3] 1A-1C illustrate exemplary outputs at various stages for generating a low-poly mesh. [Figure 4] FIG. 1 illustrates an exemplary view hull intersection. [Figure 5] FIG. 1 illustrates an exemplary silhouette decomposition. [Figure 6] FIG. 10 illustrates an example of primitive generation based on connected loops of an input mesh. [Figure 7] FIG. 1 illustrates an exemplary process for mesh cutting. [Figure 8] FIG. 1 illustrates an exemplary process for forming a segmented mesh. [Figure 9] FIG. 10 illustrates an exemplary Pareto set for ranking low-poly meshes in a sequence of low-poly meshes. [Figure 10]FIG. 10 illustrates an example of the impact of stopping criteria on segmentation mesh detail according to one embodiment. [Figure 11A] 1A-1C illustrate a comparison of different methods for generating a first low-poly mesh according to one embodiment. [Figure 11B] 10A-10C illustrate a comparison of different methods for generating a second low-poly mesh according to one embodiment. [Figure 12A] 10A-10C illustrate a comparison of different methods for generating a third low-poly mesh according to one embodiment. [Figure 12B] FIG. 10 illustrates a comparison of different methods for generating a fourth low-poly mesh according to one embodiment. [Figure 12C] FIG. 10 illustrates a comparison of different methods for generating a fifth low-poly mesh according to one embodiment. [Figure 12D] FIG. 10 illustrates a comparison of different methods for generating a sixth low-poly mesh according to one embodiment. [Figure 13] FIG. 10 illustrates a comparison of different methods for generating a seventh low-poly mesh according to one embodiment. [Figure 14] 1 is a flowchart outlining an exemplary process for generating a low-poly mesh according to some embodiments of the present disclosure. [Figure 15] FIG. 1 is a schematic diagram of a computer system according to one embodiment. DETAILED DESCRIPTION OF THE INVENTION

[0021] 1 illustrates a number of exemplary building models. The building models can be used in a variety of environments, such as virtual reality and gaming applications. As shown in FIG. 1, the number of exemplary building models (e.g., 102 and 106) can have complex topology and geometry characteristics.

[0022] Rendering detailed building models all the time can be expensive, so as mentioned above, LOD techniques can be used extensively to maximize runtime performance. For example, instead of using highly detailed (or high-poly) 3D models, low-element-count (low-poly) meshes can be rendered in the distance. This requires that the low-poly meshes have a reasonably low element count while maintaining as much of the appearance of the high-poly model as possible.

[0023] To create a low-poly mesh from an input high-poly model, different methods can be used, including mesh simplification, reconstructing a simple mesh from a point cloud, voxelizing the high-poly mesh to remove small-scale details, and 3D reconstruction from images using machine learning. However, with the increasing use of applications on low-end platforms such as mobile devices, the above-mentioned methods may not be sufficient. For example, limited computational resources on mobile platforms may limit a building mesh (or building model) to a few thousand triangles, which is already considered a low-poly mesh by traditional LOD generation approaches, but the coarsest LOD budget is only a few hundred elements. None of the related methods for generating low-poly meshes were found to perform well on a sample building model, such as the building model shown in Figure 1. Furthermore, the standard process for creating such low-poly meshes is labor-intensive and involves tedious trial and error in the current gaming industry. For example, it is common practice among game modelers to manually create a low-poly mesh for a given 3D building model to achieve a more ideal balance between a small element count and visual similarity. However, this process can take hours and involve tedious trial and error. Generating low-poly meshes for building models used by mobile applications is therefore a challenging task, and an effective and robust solution for it remains elusive.

[0024] The present disclosure includes a method for effectively generating a low-poly mesh. The low-poly mesh can be used as the coarsest mesh in an LOD hierarchy. A visual metric can first be defined to qualitatively measure the visual difference between the low-poly mesh and a high-poly input mesh. The generation of the low-poly mesh can include three stages:

[0025] In the first stage, a coarse hull intersection can be constructed. In one example, a coarse hull intersection can be constructed by intersecting a small set of greedily selected 3D primitives by minimizing a visual metric. These 3D primitives can be generated by computing the silhouette of the input mesh from several view directions, decomposing the silhouette into 2D solids and holes, and extruding the 2D shapes. The result of the first stage can be represented as a hull intersection. A hull intersection can capture the silhouette of the input mesh, but may miss important concave features of the input mesh.

[0026] The second stage aims to segment a segmentation mesh from the visual hull intersection. In one example, segmentation is performed by subtracting redundant volumes to restore the concave features of the input mesh. A greedy strategy can be deployed to select segmentation primitives by minimizing the visual metric between the segmentation mesh and the input mesh. When all 3D primitives for constructing the visual hull intersection and redundant volumes are watertight and precise arithmetic is employed for the calculation, the generated segmentation mesh can be watertight and self-intersection-free.

[0027] A third stage can generate a mesh sequence from which low-poly meshes are selected. In one example, the mesh sequence is generated by progressively performing edge erasure and / or edge reversal on the segmented meshes.

[0028] In the third stage, high-quality low-poly meshes can occur indefinitely in a mesh sequence. Thus, a history of simplified meshes can be kept, and the simplified meshes can be ordered into a Pareto set. The simplified meshes can be ordered by two objectives: number of triangles and visual closeness to the input mesh. An ideal mesh can be selected from the simplified meshes as the final result. The selection can be made by a user, such as a game modeler, or it can be selected automatically according to one or more criteria.

[0029] The effectiveness and performance of the related methods and low-poly mesh generation disclosed herein were empirically compared based on a dataset containing 100 building models with various styles manually created by artists and used by real-world games. The low-poly mesh generation disclosed herein can show significant improvements, such as achieving a lower element count and / or maintaining a higher visual appearance of the results.

[0030] Aspects of the present disclosure include a method for reducing the number of polygons in a 3D model. The method can be used to automate the formation of low-poly meshes (or low-poly meshes) by converting a high-poly 3D model (e.g., a building model) into a simple, visually-preserving low-poly mesh. The method can include three stages. First, a watertight, self-collision-free visual hull can be generated, e.g., via Boolean intersection 3D extrusion of an input silhouette. Second, significant but redundant structures can be cut out from the visual hull, e.g., by Boolean subtraction of 3D primitives derived from portions of the input. Third, a sequence of progressively simplified low-poly meshes can be generated from the cutout mesh. In some embodiments, a Pareto set can be extracted for user selection.

[0031] The formation of the low-poly mesh can be driven by a visual metric with the goal of maintaining visual similarity to the input mesh. Furthermore, aspects of the present disclosure were tested based on a dataset containing 100 building models with different styles, most of which are used in popular digital games. The improved robustness and quality of the low-poly meshes are demonstrated through comparison with other low-poly meshing techniques. An exemplary dataset containing 100 building models (or input meshes) and corresponding low-poly meshes generated by the methods described herein is shown in FIG. 1 . For example, a first building model 102 can have a corresponding low-poly mesh 104, and a second building model 106 can have a corresponding low-poly mesh 108.

[0032] Mesh simplification involves a large group of methods that either directly remesh the raw input through progressively error-guided element removal operations, such as edge elimination, or segment the mesh into patches that can later be retriangulated into a simplified mesh. These local remeshing operators are guided by a global, uniform error metric, which works well when processing medium- to high-poly meshes. However, these local operators do not perform well on extremely coarse, low-poly meshes, and overly aggressive local remeshing can result in noticeable and detrimental visual artifacts. Figure 2 shows a mesh with these artifacts generated using edge elimination guided by a quadratic error metric (QEM) or the mesh reduction module within the commercial software Simplygon. As shown in Figure 2, a simplified mesh 204 can be generated by applying QEM to a building model 202. The building model 202 can serve as the input mesh and can be a manifold model with 39,620 triangles and 1,894 separated components. Figure 2 also shows a simplified mesh 206 generated by applying Simplygon to the building model 202. As shown in Figure 2, QEM or Simplygon can apply an overly aggressive remeshing operator that can result in noticeable artifacts with 1000 triangles. Figure 2 also shows a low-poly mesh 208 generated by the method of the present disclosure. The low-poly mesh 208 can more faithfully represent the overall structure of the building model 202 using only 128 triangles.

[0033] Another approach is to voxelize the raw input and then apply feature-guided retriangulation to generate low-poly output by assuming the input mesh is consistently oriented, i.e., has an inherent inside / outside definition. However, building models in games can be non-manifold, non-watertight, and self-intersecting, so face orientation often has unclear inside and outside labeling, even with mesh repair. PolyFit is yet another approach to generating low-poly meshes. Given a point cloud, PolyFit first computes a set of planes, builds a binary tree for all planes to obtain subfaces, and then selects faces for the final output by solving a mixed-integer programming problem. While PolyFit has successfully dealt with many dirty building models, some candidate subfaces can become prohibitively large for models of practical complexity, resulting in an unmanageably large mixed-integer programming problem.

[0034] Visual hulls can be used to generate 3D models. An object has a unique, well-defined visual hull, which is the largest shape that has the same silhouette as the object in any view direction. Visual hulls were originally used for 3D reconstruction from images or videos by considering the image boundaries as silhouettes. The advantage is that visual hulls can reconstruct a watertight, topologically simple mesh from an arbitrarily dirty input (e.g., an input mesh with complex topology and / or geometric properties). In typical applications of visual hulls, users typically prefer more views to capture as much detail as possible. Theoretically, an infinite number of views are required to obtain an accurate visual hull from a general 3D model. To construct an accurate visual hull using the viewpoints inside the convex hull, the computation time is O(n 5 ) silhouettes can be used. Visual hulls also have drawbacks, such as not representing concave features well. To address this issue, visual hulls can be constructed piece by piece via Boolean operations.

[0035] Aspects of the present disclosure further include an overview of a visual metric and an example pipeline (or method) for measuring the quality of a low-poly mesh. An example pipeline of the present disclosure is shown in FIG. 3. FIG. 3 illustrates three stages of low-poly mesh generation. As shown in FIG. 3, given a topologically and geometrically dirty input mesh 302, a greedily selected subset of primitives can be used to construct the hull intersection 304, such that the greedily selected subset of primitives can reduce the visual difference between the hull intersection 304 and the input mesh 302. In such a subset, some concave features may be erroneously flattened. To correct the missing concave feature issue, a segmented mesh 306 can be generated by segmenting the concave features. The segmentation can be performed using a set of segmented primitives. The segmented mesh 306 can be further simplified into a set of final output low-poly mesh candidates, such as low-poly mesh 308.

[0036] Non-orientable, non-watertight high-poly 3D building model M i Given this, one goal is to create a low-poly mesh M that can satisfy three qualitative requirements: o The goal is to generate a mesh M to be used as the coarsest mesh in the LOD hierarchy. o The visual appearance of M from an arbitrary distant viewpoint i The visual appearance of a M should resemble that of a . To maximize the rendering effect, the number of geometric elements (e.g., faces) should be as small as possible. Furthermore, the number of elements can be user-controllable. Finally, M o needs to be watertight to allow automatic downstream mesh editing operations.

[0037] Visual metrics are M i and M o Given a view direction d, we can render the mesh into image space via perspective projection, which is achieved by the operator Rn It can be shown as R n( M, d) can be used to render the three Cartesian components of the surface normal vector into the frame buffer, and the visual difference can be defined as the average per-pixel distance in Equation 1: d n (M i ,M o ,d)=∥R n (M i ,d)-R n (M o ,d)∥ / N Equation (1) where N can be the number of pixels. The visual appearance metric can be further defined as the insignificant visual difference across all directions in Equation 2.

number

[0038] Low Poly Mesh M o To generate M i From the visual volume intersection M v can be computed, which can be topologically consistent and geometrically clean while capturing most of the silhouette information. M i Instead of directly simplifying the mesh itself, M v is friendly to (or compatible with) existing remeshing operators and is geometrically narrower than its convex hull. i The range of M that is important for visual appearance i The silhouette of the object can be maintained. c To obtain M v can be subtracted from M c can enhance the visual appearance with prominent concave features. Finally, the low-poly output M o To generate the mesh M c can be simplified.

[0039] Generating a low-poly mesh can include generating a hull. This stage aims to generate a topologically simple and geometrically clean hull while capturing the visual appearance of salient structures. However, as shown in FIG. 4, generating an accurate hull 404 based on an input mesh 402 can result in many small features and details. Instead, a simplified hull 406 can be generated. A simplified hull can be generated by carefully selecting and limiting the number of views in the hull. For example, a simplified hull can be generated based on Algorithm 1 below. As shown in FIG. 4, for a given input mesh 402, the accurate hull 404 can be approximated by intersecting silhouettes from 13 view directions, resulting in 277k faces. In contrast, the hull 406 generated by Algorithm 1 has only 368 faces obtained by three primitives.

[0040] In Algorithm 1, given M i For a given set of silhouettes, one silhouette can be generated for each of the top k view directions. Unlike related hull intersection construction methods, a self-intersection-free simplification can be performed in 2D space for each silhouette. The hull intersection can then be constructed through the intersection of the extruded silhouettes. Furthermore, each silhouette can be decomposed into connected 2D loops, and the extruded silhouettes can be represented as primitives. Instead of considering a set of extruded silhouettes, a larger set of primitives can allow for finer and more complex control of the hull intersection. Specifically, M v M i can be initialized as the bounding box of M v A greedy algorithm can be applied to iteratively intersect P with the next best primitive P. An example of each step can be written as follows:

[0041] [Table 1]

[0042] Constructing a hull intersection involves initializing a set of primitives. For example, in line 1 of Algorithm 1, we initialize the set of primitives

number

number

[0043] Constructing the view hull can further include determining a set of view directions. For example, in line 2 of Algorithm 1, a set of view directions can be extracted, and the top k view directions are called the view direction set

number

number

number

number

number

number

number

[0044]

number

number

number

[0045] Constructing the view hull can further include calculating silhouettes. A silhouette can be calculated for each direction in the determined set of view directions. For example, in line 4 of Algorithm 1, a silhouette S along direction d can be generated. To calculate a silhouette from view direction d, M i All faces of can be projected onto a plane perpendicular to the view direction d. Then, a 2D Boolean sum can be used to obtain the corresponding silhouette shape, where the vertex coordinates can be represented by integers for fast and robust computation. The generated silhouette shape can be guaranteed to be free of self-intersections.

[0046] Constructing a hull may further include simplifying one or more of the silhouettes. For example, in line 5 of Algorithm 1, silhouette S may be simplified. Even with fewer view directions, silhouette simplification may be necessary because a hull generated based on a small number of view directions may still contain a large number of small-scale details due to complex silhouettes. Therefore, each silhouette may be simplified through 2D simplification and shape size filtering for further complexity reduction. In other embodiments, one or more silhouettes may be selectively simplified. Selective simplification may be performed based on the number of small-scale details. The 2D simplification of the present disclosure may be a global approach implemented using rational arithmetic to generate self-intersection-free silhouettes. The simplification may be performed using a squared distance criterion.

number

[0047] Constructing the hull can further include generating primitives.

number

[0048] FIG. 6 shows an example of primitives generated from an input mesh. As shown in FIG. 6, multiple loops 604-607 can be extracted from input mesh 602. Furthermore, each of the loops can be extruded along a respective view direction to form a primitive. For example, primitive 616 can be formed based on loop 605, primitive 618 can be formed based on loop 606, primitive 614 can be formed based on loop 607, and primitive 612 can be formed based on loop 605.

[0049] In line 7 of Algorithm 1, we add primitives (e.g., Extrude(L)) formed based on the loops extruded along the view direction to the primitive set

number

[0050] Between lines 9 and 19 of Algorithm 1, we define a stopping criterion (e.g., a user-specified upper bound N or a user-specified threshold ε τ ) until M v Boolean intersection can be performed iteratively to intersect P with the next-best primitive P. As shown in line 9, when n is less than N, i.e., a user-specified upper bound, the next-best visual disparity improvement Δτ best can be assigned an initial value such as 0, and the next best primitive P best can be assigned the empty set in line 10.

[0051] The construction of the hull intersection is a Boolean intersection that can be greedily selected.

number

number

number

[0052] In line 16, the suboptimal visual difference improvement Δτ best is still subject to a user-specified threshold ε τ If it is larger than M, this means there is still room for further improvement. Therefore, in line 17, we select the best tentative mesh intersection (M v ,P best ) to M v can be assigned to the next best primitive P best is a primitive set

number

[0053] In line 18 of Algorithm 1, we can increase the iteration count n by 1, and change the initial visual disparity τ to the suboptimal visual disparity improvement Δτ best can be reduced by M v is the best temporary mesh intersection (M v ,P best ), which is updated by the input mesh M i can have less visual difference than

[0054] Line 19 of Algorithm 1 shows an example of a stopping criterion. Stopping criteria that can be applied to Algorithm 1 for hull intersection construction include a visual dissimilarity threshold and the number of selected primitives. First, the visual dissimilarity improvement Δτ p is the user-specified threshold ε τ If k is less than , this means there is little room for further improvement, and construction stops. Second, construction stops when the number of selected primitives (or iteration count) n reaches a user-specified upper limit N. The parameter k is

number

number

[0055] Algorithm 1 uses d to select a primitive. nNote that we apply a slightly different version of visual difference than Algorithm 1 because it focuses on generating a similar silhouette rather than the interior geometry. In fact, the mesh is flattened to a 2D plane, removing all geometric features inside the silhouette. Therefore, we apply another operator R, which can render the mesh M into a stencil buffer, performing binary masking of occluded pixels, and discarding normal information. s (M, d) can be provided. Correspondingly, the visual silhouette difference d can be calculated in Equation 4 as follows: s We can define the visual silhouette metric τ in Eq. s can be defined.

number

number

[0056] The generation of the low-poly mesh may further include generating a segmentation mesh. The segmentation mesh is a mesh that is generated by the visual hull intersection M v The visual hull intersection M v can be generated, for example, based on Algorithm 1. In some embodiments, the visual hull intersection can inherit the restriction of capturing only silhouettes while ignoring other features. As shown in Figure 7, the input mesh M i The visual hull M generated from 702 v 710 is the input mesh M i To overcome this limitation, we cut out redundant volume blocks and c and M i By further reducing the visual difference between v Cut out the mesh M c can be refined to:

[0057] A segmentation mesh can be generated by progressively subtracting multiple primitives from the visual hull. For example, a segmentation mesh can be generated based on Algorithm 2.

[0058] [Table 2]

[0059] Algorithm 2 can include the following steps: First, in the second line of Algorithm 2, the fitting plane set generated above is

number

number

number

[0060] Next, in line 7 of Algorithm 2, the positive part

number

number

number

[0061] where:

number

number

number

number

number

number

number

number

number

number

number

number

number

[0062] The overall structure of Algorithm 2 can be the same as that of Algorithm 1. The segmented mesh M c is a candidate segmentation primitive.

number

number

[0063] The generation of the low-poly mesh may further include generating the low-poly mesh based on the segmentation mesh. For example, the low-poly mesh may be generated based on the segmentation mesh M generated according to Algorithm 2. c After generating the hull intersection and segmentation mesh (e.g., M v and M cAfter forming the input mesh M, the resulting mesh may largely maintain the visual appearance of the input, but may have more triangles than desired. The desired number of triangles may be determined, for example, by the user. Thus, given the input mesh M i Low-poly mesh M while maintaining low visual difference from o The segmentation mesh can be simplified to obtain, for example, M c can be progressively re-meshed through edge removal and / or edge reversal operators. Thus, the first low-poly mesh is re-meshed into the segmented mesh M c A second low-poly mesh M can be generated by performing a first edge-erasing and / or edge-reversing operation on the first low-poly mesh. Furthermore, a second low-poly mesh M can be generated by performing a second edge-erasing and / or edge-reversing operation on the first low-poly mesh. Each of the edge-erasing and edge-reversing operators can reduce two triangles. Each of the edge-erasing and edge-reversing operators reduces the respective low-poly mesh M o The operator may be run until no more triangles can be removed. In other embodiments, the operator may be run until a specific number of triangles are removed or remain. Furthermore, only meshes with a number of triangles ≦T may be stored. T may be set to the maximum number of elements a user is willing to accept. Thus, by progressively running the edge-eliminating and edge-reversing operators, a low-poly mesh sequence may be formed. The low-poly mesh sequence may be displayed for user selection. The sequence may be displayed, for example, in a graphical user interface.

[0064] The sequence of low-poly meshes can be further ranked in some embodiments. For example, a Pareto efficiency concept can be applied to rank the low-poly meshes in the sequence of low-poly meshes. The ranking can be based on the number of faces and / or the visual difference τ nIn some embodiments, two metrics can be kept in the Pareto set, as shown in Figure 9. o Since selecting M is often subjective in practice, the meshes in the Pareto set can be visualized through the Pareto set shown in Figure 9. Therefore, a user such as a game modeler can select M as the output. o In other embodiments, the user can manually select M from a low-poly mesh sequence without sorting. o You can also select τ directly. n Note that meshes can also be automatically exported from the Pareto set just prior to the crystallization increase.

[0065] For comparison purposes, we implemented Algorithms 1 and 2 in C++ using GLSL shaders for metric computation, Eigen for linear algebra routines, CGAL for rational number computation, the Clipper library for silhouette computation, and mesh placement encapsulated in libigl for 3D exact Boolean operations.

[0066] In this implementation, a GLSL shader was used to calculate the visual difference between any two meshes. GLSL is a C-like language tailored for use with graphics and includes useful features specifically targeted at vector and matrix manipulation. Given a view direction, the camera is set to be 3l away from the meshes, where l is the maximum length of the bounding boxes of both meshes. Each mesh is rendered into a 128x128 framebuffer and the d is calculated using Equation 4 and Equation 1, respectively. s and d n was calculated. n and τ s is S 2 We evaluated the model by repeating the process for C uniformly distributed view directions. We assumed that the building model always faces upwards, so S 2is a hemisphere. We also evaluated the number of view directions and its effect on the corresponding visual metrics. The metric values ​​converge when C ≥ 250. To be conservative, we set C to 10 in the experiments described below. 3 was set to.

[0067] The third stage of the pipeline (e.g., M o During the remeshing of M c Edge elimination and edge inversion are performed iteratively while maintaining the topology of θ. In edge elimination, QEM is employed to rank all edges and add virtual vertical planes with small weights to each edge to combat coplanar degeneracy, which is a common numerical instability in QEM. If any adjacent triangle of an edge is θ, then π If the dihedral angle of the edge is greater than θ 2π If θ is greater than θ, edge flipping is performed. π is a threshold close to π, and θ 2π is a threshold close to 2π.

[0068] Regarding hyperparameters in the implementation of the present disclosure, the following default parameter settings were used: α=175°, which is the M i β=1°, which is the threshold for two directions to be considered overlapping. k=50 for selecting the set of view directions for hull intersection generation and slicing planes during segmentation mesh generation. θ for edge flipping during low-poly mesh formation. π = 175° and θ 2π = 355°. The stopping criterion ε for silhouette simplification applied during the generation of the volume intersection and segmentation meshes. d was set to 1% of the maximum diagonal length of the bounding square of all silhouettes. The filtering process discards all loops with a surface area less than 1% of the maximum area of ​​the bounding square of all silhouettes.

[0069] ε τ and N are both M v , M c, and thus indirectly M o As shown in Figure 10, a smaller ε τ The stopping criteria for M c where (·,·) is (ε τ ,τ n ) is shown. τ and N may not be very intuitive for end users to adjust. Therefore, empirically, ε τ and N by default to ε τ =1×10 -3 and N = 20. In practice, a single parameter can be exposed to the user, which can be, for example, the maximum number of triangles T in the output low-poly mesh. In all experiments in this disclosure, T = 600.

[0070] It should be noted that although various parameters and settings are described above for an exemplary implementation, other settings and parameters may be utilized.

[0071] For comparison purposes, experiments were conducted based on the implementation described above. The experiments were performed on a workstation with a 32-core Intel processor clocked at 3.5 GHz and 64 Gb of memory, using OpenMP to parallelize silhouette-related calculations and candidate selection during hull intersection and segmentation mesh generation.

[0072] For the dataset, we collected 100 building models with various styles that commonly appear in digital images or environments, such as games. Examples of building models are shown in FIG. 1. The models in the dataset can have complex geometries and topologies, with 39% being non-manifold and 88% being non-watertight. Among these models, the average number of triangles, intersecting face pairs, and separated components is 20k, 35.6k, and 685, respectively. For the manifold models, the average number of genus and holes is 136 and 640, respectively, where genus can indicate the number of holes on the surface. Table 1 provides example statistics for the input models appearing in FIGS. 2, 3, 6, 11A, 11B, 12A, 12B, 12C, 12D, and 13. FIG. 1 shows examples of both building models (input meshes) and low-poly meshes that can be generated based on the methods of the present disclosure for the entire dataset. Further, a comparison of the results generated by related methods with the results generated by the methods of the present disclosure is shown in Figures 10, 11A, 11B, 12A, 12B, 12C, 12D, and 13, as well as Tables 1 and 2.

[0073] [Table 3]

[0074] As shown in Table 1, the number of vertices, N V , face N F , genus N G , intersecting plane pair N S , component N C , and hole N H , and whether it is a manifold or not M an The statistics of the input models shown in Figures 2, 3, 6, 11A, 11B, 12A, 12B, 12C, 12D, and 13 are summarized, including: Note that for non-manifold meshes, the genus and holes are not well-defined.

[0075] To evaluate the effectiveness of mesh cutting in preserving visual appearance, we performed mesh cutting on all 100 models. vand M c For both τ n The average τ n (M v ) and τ n (M c ) are 0.066 and 0.056, which indicates that mesh clipping can reduce the visual difference by 15.2% and is important for preserving the normals (or appearance) of the input.

[0076] We compared our results with commercial software such as InstaLOD and Simplygon, which can automatically generate simplified meshes and are state-of-the-art commercial solutions used by game studios. Results from InstaLOD and Simplygon are shown in Table 2 and Figures 11A and 11B. Results are consistent with the InstaLOD optimization (InstaLOD 1 ), InstaLOD remeshing (InstaLOD 2 ), Simplygon decrease (Simplygon 1 ), and Simplygon remeshing (Simplygon 2 It was generated using various modules provided by InstaLOD and Simplygon, including the number of faces, τ s , τ n The results of the low-poly meshes generated by the disclosed method are compared with those of InstaLOD and Simplygon in terms of the mean and standard deviation of the simplification ratio. By default, a mesh from the Pareto front was manually selected as the final result (or final low-poly mesh). Simplygon 2 Since is the best performing of the four modules provided by both InstaLOD and Simplygon, to be fair, we will use Simplygon 2 The results of our method are obtained from the Pareto front with a face count that matches the number of faces of the mesh by S) were extracted. As shown in Table 2, the disclosed method produces results with a smaller number of elements and better visual appearance preservation. Figures 11A and 11B compare the four methods of the two software with the disclosed method based on two sample models (or input meshes), where ( , ) are the sum of (N F ,τ n ) is shown.

[0077] Furthermore, we compared it with PolyFit, a state-of-the-art open-source polygon mesh reconstruction method. To adopt PolyFit for low-poly meshing, we set the upper limit to 1M point samples and the diagonal length of the bounding box to 1×10. -4 Each 3D model was uniformly sampled into a point cloud using the point cloud library by setting as the sampling interval. A batch process of the dataset was performed using the CGAL implementation of PolyFit with default parameter settings. PolyFit was unable to produce any results for nine models because it could not find enough primitives. The results successfully processed by PolyFit were summarized, and the results of the disclosed method (Ours) were compared by matching the number of faces in the results generated by PolyFit. P ) can be extracted. Figures 12A, 12B, 12C, and 12D show an exemplary comparison between the results of the disclosed method and PolyFit, where ( , ) are the number of faces (τ n As shown in Table 2 and Figures 12A, 12B, 12C, and 12D, the results of the disclosed method can maintain much more visual appearance than PolyFit with the same number of faces.

[0078] Additionally, a comparison was made with an alternative pipeline. To handle models with many open boundaries, an alternative pipeline for generating a simplified mesh is to first apply mesh repair and then run a remeshing algorithm. The results of the disclosed method were further compared with results generated by, for example, a two-stage alternative pipeline, where a watertight mesh was first generated and then QEM-guided mesh simplification was applied using meshlab. Figure 13 shows the comparison results for the watertight mesh, mesh simplification without topology preservation, mesh simplification with topology preservation, and the results of the disclosed method, where (·,·) is the number of faces (τ n ) As demonstrated in Fig. 13, although the mesh repair approach can repair the mesh to some extent, it is still difficult for the local remeshing operator to produce satisfactory results when the desired number of elements is small.

[0079] [Table 4]

[0080] As shown in Table 2, the percentage of watertight results, W, and the average number of faces

number

number

number

number

number

number

number

[0081] This disclosure provides an approach for generating low-poly representations of commonly used 3D models. This approach can be applied to digital games, including building models, for example. A feature of this disclosure is its reliance on hull intersections to generate topology-simple proxy meshes. An exemplary algorithm is provided for constructing and segmenting hull intersections using primitives selected for structural simplicity. However, in other embodiments, modifications to one or more of the algorithms can be made. For example, planar slicing during the subtraction step can produce unsatisfactory results for models with smooth concave features. In this case, other proxy representations, such as voxelization, can be used if the input involves consistent interior / exterior labeling. When the desired number of triangles in the low-poly mesh is greater than 1K, traditional remeshing methods, such as QEM-guided edge removal and commercially available solutions, may already be satisfactory. In some embodiments, the method of this disclosure can be designed to generate the coarsest level of detail.

[0082] FIG. 14 shows a flowchart outlining an example process (1400) for generating a low-poly mesh sequence according to some embodiments of the present disclosure.

[0083] As shown in FIG. 14, process 1400 may start at step S1401 and proceed to step S1410. At step S1410, a visual hull intersection may be generated. The visual hull intersection may be generated based on an intersection of first 3D primitives of a plurality of first silhouettes with a bounding box of the 3D model. The plurality of first silhouettes may be generated by projecting the 3D model onto a plane perpendicular to several selected view directions of the 3D model. Each of the first 3D primitives may be obtained by extruding a connected loop of the respective first silhouette along one of several selected view directions associated with the respective first silhouette.

[0084] In (S1420), a segmentation mesh can be generated. The segmentation mesh can be generated based on subtraction of a second 3D primitive derived from a positive portion of the 3D model to segment redundant structures from the visual hull. The positive portion can be obtained based on multiple fitting planes that slice the 3D model.

[0085] In (S1430), a low-poly mesh sequence can be generated. The low-poly mesh sequence can be generated based on a progressive simplification of the segmented mesh.

[0086] In the process (1400), a plurality of fitting planes can be formed, and each region of the 3D model can be included in a respective fitting plane of the plurality of fitting planes. A plurality of candidate view directions can be determined. Each of the plurality of candidate view directions can be parallel to a respective pair of fitting planes and associated with a respective weight value. The respective weight value can be equal to the sum of the areas of the regions of the 3D model included in the respective pair of fitting planes. A number of selected view directions can be determined from the plurality of candidate view directions associated with the top k weight values, where k can be a positive integer.

[0087] In some embodiments, each of the plurality of first silhouettes of the 3D model can be simplified through at least one of 2D simplification or shape size filtering. One or more hollow loops can be extracted from each of the plurality of first silhouettes. One or more connected loops can be generated for each of the plurality of first silhouettes by subtracting the one or more hollow loops from the 2D bounding box of each of the plurality of first silhouettes. A first 3D primitive can be formed by extruding one or more connected loops of the plurality of first silhouettes along several selected view directions.

[0088] In the process (1400), a first virtual volume intersection may be formed by performing a Boolean intersection operation on a first one of the first 3D primitives and a bounding box of the 3D model to form a visual volume intersection. A first visual disparity improvement may be determined based on the first virtual volume intersection and the 3D model. In response to the visual disparity improvement being greater than a threshold, a second virtual volume intersection may be formed by performing a Boolean intersection operation on a second one of the first 3D primitives and the first virtual volume intersection. A second visual disparity improvement may be determined based on the second virtual volume intersection and the 3D model.

[0089] To determine a first visual disparity improvement based on the first virtual volume intersection and the 3D model, an initial visual disparity can be determined based on an average pixel-by-pixel disparity between a bounding box of the 3D model and the 3D model. The first visual disparity can be determined based on an average pixel-by-pixel disparity between the first virtual volume intersection and the 3D model. The first visual disparity improvement can then be determined by subtracting the first visual disparity from the initial visual disparity.

[0090] In some embodiments, the nth virtual hull intersection may be determined as the virtual hull intersection in response to one of (i) the nth visual disparity improvement being less than a threshold, and (ii) n being equal to an upper limit N. N may be a positive integer. The nth virtual hull intersection may be formed by performing a Boolean intersection operation on the nth one of the first 3D primitives and the (n-1)th virtual hull intersection.

[0091] In some embodiments, the 3D model can be sliced ​​by multiple fitting planes to form the segmented mesh. Each of the multiple fitting planes can slice the 3D model into a positive portion and a negative portion. The positive portion of the 3D model can be located on a positive side of each of the multiple fitting planes. Each of the positive portions of the 3D model can be projected onto a corresponding one of the multiple fitting planes to obtain a respective second silhouette. An enlarged bounding square of each second silhouette can be obtained on the corresponding fitting plane such that the respective second silhouette is contained in the enlarged bounding square. A Boolean subtraction operation can be performed to subtract each second silhouette from the enlarged bounding square to obtain a boundary loop from each second silhouette. One of the second 3D primitives can be formed by extruding the boundary loop of each second silhouette in a normal direction from the positive side of the fitting plane corresponding to the respective second silhouette.

[0092] The process (1400) may form a first provisional segmentation mesh by performing a Boolean subtraction operation on a first one of the second 3D primitives and the visual hull intersection to form the segmentation mesh. A first visual disparity improvement may be determined based on the first provisional segmentation mesh and the 3D model. In response to the visual disparity improvement being greater than a threshold, a second provisional segmentation mesh may be formed by performing a Boolean subtraction operation on a second one of the second 3D primitives and the first provisional segmentation mesh. A second visual disparity improvement may be determined based on the second provisional segmentation mesh and the 3D model.

[0093] In some embodiments, in response to one of (i) the nth visual difference improvement being less than a threshold, and (ii) n being equal to an upper limit N, the segmentation mesh may be determined as the nth provisional segmentation mesh, where N may be a positive integer, and the nth provisional segmentation mesh may be formed by performing a Boolean intersection operation on the nth one of the second 3D primitives and the (n-1)th provisional segmentation mesh.

[0094] To generate the low-poly mesh sequence, edge erasure and edge reversal operations can be performed progressively on the segmented meshes to generate the low-poly mesh sequence. Each of the low-poly meshes in the low-poly mesh sequence can include a respective number of triangles that is less than a user-selected value T. T can be a positive integer, and the number of triangles in each of the low-poly meshes can be less than the number of triangles in the segmented mesh.

[0095] In the process (1400), the low-poly meshes in the sequence of low-poly meshes can be ranked based on the number of faces and visual differences of the low-poly meshes to generate a Pareto set.

[0096] The techniques described above can be implemented as computer software using computer-readable instructions and physically stored on one or more computer-readable media. For example, Figure 15 illustrates a computer system (1500) suitable for implementing certain embodiments of the disclosed subject matter.

[0097] Computer software may be coded using any suitable machine or computer language, which may be processed by assembly, compilation, linking, or similar mechanisms to generate code comprising instructions that may be executed directly, interpreted, executed by microcode, or otherwise executed by one or more computer central processing units (CPUs), graphics processing units (GPUs), or other processing circuitry.

[0098] The instructions may be executed on various types of computers or computer components including, for example, personal computers, tablet computers, servers, smartphones, gaming consoles, Internet of Things devices, and the like.

[0099] 15 for computer system (1500) are exemplary in nature and are not intended to suggest any limitation as to the scope of use or functionality of the computer software implementing embodiments of the present disclosure. The arrangement of components should not be interpreted as having any dependency or requirement regarding any one or combination of components illustrated in the exemplary embodiment of computer system (1500).

[0100] The computer system (1500) may include certain human interface input devices. Such human interface input devices may respond to input by one or more human users, for example, via tactile input (e.g., keystrokes, swipes, data glove movements), audio input (e.g., voice, clapping), visual input (e.g., gestures), or olfactory input (not shown). The human interface devices may also be used to capture certain media not necessarily directly associated with conscious human input, such as audio (e.g., voice, music, ambient sounds), images (e.g., scanned images, photographic images, still image images obtained from a camera, etc.), and video (e.g., two-dimensional video, three-dimensional video including stereoscopic video, etc.).

[0101] The input human interface devices may include one or more of a keyboard (1501), a mouse (1502), a trackpad (1503), a touchscreen (1510), a data glove (not shown), a joystick (1505), a microphone (1506), a scanner (1507), a camera (1508), etc. (only one of each is shown).

[0102] The computer system (1500) may also include certain human interface output devices. Such human interface output devices may stimulate one or more of the human user's senses, for example, through tactile output, sound, light, and smell / taste. Such human interface output devices may include haptic output devices (e.g., haptic feedback via a touchscreen (1510), data gloves (not shown), or joystick (1505), although some haptic feedback devices may not function as input devices), audio output devices (such as speakers (1509), headphones (not shown)), visual output devices (such as screens (1510), including CRT screens, LCD screens, plasma screens, and OLED screens, each with or without touchscreen input capability and each with or without haptic feedback capability, some of which may be capable of outputting two-dimensional visual output or output in more than three dimensions by means of stereoscopic output, such as virtual reality glasses (not shown), holographic displays, and smoke tanks (not shown)), and printers (not shown).

[0103] The computer system (1500) may also include human-accessible storage devices and associated media for storage devices such as optical media including CD / DVD ROM / RW (1520) with CD / DVD or similar media (1521), thumb drives (1522), removable hard drives or solid state drives (1523), legacy magnetic media such as tape or floppy disks (not shown), dedicated ROM / ASIC / PLD-based devices (not shown) such as security dongles, etc.

[0104] Those skilled in the art should also understand that the term "computer-readable medium" as used in connection with the subject matter of this disclosure does not encompass transmission media, carrier waves, or other transitory signals.

[0105] The computer system (1500) may also include an interface (1554) to one or more communication networks (1555). The networks may be, for example, wireless, wired, or optical. The networks may further be local, wide-area, metropolitan, vehicular, industrial, real-time, delay-tolerant, etc. Examples of networks include local area networks such as Ethernet and wireless LAN; cellular networks including GSM, 3G, 4G, 5G, LTE, etc.; TV wired or wireless wide-area digital networks including cable TV, satellite TV, and terrestrial broadcast TV; and vehicular and industrial networks including CAN Bus. Certain networks generally require an external network interface adapter attached to a particular general-purpose data port (e.g., a USB port on the computer system (1500)) or peripheral bus (1549), while other networks are generally integrated into the core of the computer system (1500) by connection to a system bus (e.g., an Ethernet interface to a PC computer system or a cellular network interface to a smartphone computer system). Using any of these networks, the computer system (1500) can communicate with other entities. Such communications may be unidirectional, receive only (e.g., television broadcast), unidirectional transmit only (e.g., CANbus to a particular CANbus device), or bidirectional, e.g., to other computer systems using local-area or wide-area digital networks. Specific protocols and protocol stacks may be used with each of these networks and network interfaces, as described above.

[0106] The aforementioned human interface devices, human-accessible storage devices, and network interfaces may be connected to the core (1540) of the computer system (1500).

[0107] The core (1540) may include processing circuitry such as one or more central processing units (CPUs) (1541), graphics processing units (GPUs) (1542), dedicated programmable processing units in the form of field programmable gate arrays (FPGAs) (1543), task-specific hardware accelerators (1544), and graphics adapters (1550). These devices may be connected via a system bus (1548) along with read-only memory (ROM) (1545), random access memory (1546), internal mass storage (1547) such as a non-user-accessible internal hard drive or SSD, and the like. In some computer systems, the system bus (1548) may be accessible in the form of one or more physical plugs to allow expansion with additional CPUs, GPUs, and the like. Peripheral devices may be connected directly to the core's system bus (1548) or via a peripheral bus (1549). In one example, a screen (1510) may be connected to the graphics adapter (1550). Architectures for peripheral buses include PCI, USB, and the like.

[0108] The CPU (1541), GPU (1542), FPGA (1543), and accelerator (1544) can execute specific instructions that, in combination, can constitute the aforementioned computer code. This computer code can be stored in ROM (1545) or RAM (1546). Transient data can also be stored in RAM (1546), while permanent data can be stored, for example, in internal mass storage (1547). Fast storage and retrieval from any of the memory devices can be enabled through the use of cache memory, which can be closely associated with one or more of the CPU (1541), GPU (1542), mass storage (1547), ROM (1545), RAM (1546), etc.

[0109] The computer-readable medium may bear computer code 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 the kind well known and available to those skilled in the computer software arts.

[0110] By way of example and not limitation, a computer system (1500) having an architecture, and specifically a core (1540), can provide functionality as a result of processor(s) (including a CPU, GPU, FPGA, accelerator, etc.) executing software embodied in one or more tangible computer-readable media. Such computer-readable media can be user-accessible mass storage, as described above, as well as media associated with specific storage of the core (1540) that is non-transitory in nature, such as the core's internal mass storage (1547) or ROM (1545). Software implementing various embodiments of the present disclosure can be stored on such devices and executed by the core (1540). The computer-readable media can include one or more memory devices or chips, depending on particular needs. The software can cause the core (1540), and specifically the processors (including a CPU, GPU, FPGA, etc.) therein, to perform particular processes or particular portions of particular processes described herein, including defining data structures stored in RAM (1546) and modifying such data structures according to software-defined processes. Additionally, or alternatively, a computer system may provide functionality as a result of logic hardwired or otherwise embodied in circuitry (e.g., accelerator (1544)) that can operate in place of or in conjunction with software to perform particular processes or portions of particular processes described herein. References to software can encompass logic, where appropriate, and vice versa. References to computer-readable media can encompass circuitry (such as an integrated circuit (IC)) that stores software for execution, circuitry that embodies logic for execution, or both, where appropriate. The present disclosure encompasses any suitable combination of hardware and software.

[0111] While this disclosure describes several exemplary embodiments, there are alterations, permutations, and various substitute equivalents that fall within the scope of this disclosure. It will thus be appreciated that those skilled in the art will be able to devise numerous systems and methods that, although not explicitly shown or described herein, embody the principles of the present disclosure and are therefore within the spirit and scope of the present disclosure. [Explanation of symbols]

[0112] 102 First Building Model 104, 108, 208, 308 low poly meshes 106 Second Building Model 202 Building Model 204, 206 Simplified mesh 302, 402, 602, 702 input meshes 304, 404, 406, 710, 802 Volume Intersection 306, 712 Cutout mesh 502 silhouettes 506, 508 cw loop 604~607 Loop 612, 614, 616, 618, 708 Primitives 804 First temporary cut mesh 806 Second temporary cut mesh 808 Final cutout mesh 810 First Primitive 812 Second Primitive 814 The Third Primitive 1500 Computer Systems 1501 keyboard 1502 Mouse 1503 Trackpad 1505 Joystick 1506 Mike 1507 Scanner 1508 Camera 1509 Speaker 1510 Touchscreen 1520 CD / DVD ROM / RW 1521 CD / DVD or similar media 1522 thumb drive 1523 Removable Hard Drive or Solid State Drive 1540 cores 1541 Central Processing Unit (CPU) 1542 Graphics Processing Unit (GPU) 1543 Field Programmable Gate Area (FPGA) 1544 Hardware Accelerator 1545 Read-Only Memory (ROM) 1546 Random Access Memory 1547 Internal Mass Storage 1548 System Bus 1549 Peripheral Bus 1550 graphics adapter 1554 interface 1555 Communication Network

Claims

1. 1. A method for generating a low-poly mesh sequence for a three-dimensional (3D) model, the method comprising: generating a visual volume intersection based on an intersection of first 3D primitives of a plurality of first silhouettes with a bounding box of the 3D model, the plurality of first silhouettes being generated by projecting the 3D model onto a plane perpendicular to several selected view directions of the 3D model, and each of the first 3D primitives being obtained by extruding a connected loop of the respective first silhouette along one of the several selected view directions associated with the respective first silhouette; forming a segmentation mesh based on subtraction of second 3D primitives derived from a positive portion of the 3D model to segment redundant structures from the visual hull, the positive portion being obtained based on a plurality of fitting planes slicing the 3D model; generating the low-poly mesh sequence based on progressive simplification of the segmented meshes; A method comprising:

2. The step of generating the visual hull comprises: forming a plurality of fitting planes, each region of the 3D model being included in a respective one of the plurality of fitting planes; determining a plurality of candidate view directions, each of the plurality of candidate view directions being parallel to a respective pair of fitting planes and associated with a respective weight value, the respective weight value being equal to a sum of areas of the regions of the 3D model that are contained in the respective pair of fitting planes; determining the number of selected view directions from the plurality of candidate view directions associated with top k weight values, where k is a positive integer; The method of claim 1 further comprising:

3. The step of generating the visual hull comprises: simplifying each of the plurality of first silhouettes of the 3D model through at least one of 2D simplification or shape size filtering; extracting one or more hollow loops from each of the plurality of first silhouettes; generating one or more connected loops for each of the plurality of first silhouettes by subtracting the one or more hollow loops from a 2D bounding box of each of the plurality of first silhouettes; forming the first 3D primitive by extruding the one or more connected loops of the plurality of first silhouettes along the selected view directions; The method of claim 1 further comprising:

4. The step of generating the visual hull comprises: forming a first virtual volume intersection by performing a Boolean intersection operation on a first one of the first 3D primitives and the bounding box of the 3D model; determining a first visual disparity improvement based on the first virtual volume intersection and the 3D model; forming a second virtual volume intersection by performing the Boolean intersection operation on a second one of the first 3D primitives and the first virtual volume intersection in response to the visual disparity improvement being greater than a threshold; determining a second visual disparity improvement based on the second virtual volume intersection and the 3D model; The method of claim 1 further comprising:

5. determining the first visual disparity improvement based on the first virtual volume intersection and the 3D model; determining an initial visual disparity based on an average pixel-by-pixel disparity between the bounding box of the 3D model and the 3D model; determining a first visual disparity based on an average pixel-by-pixel disparity between the first virtual volume intersection and the 3D model; determining the first visual difference improvement by subtracting the first visual difference from the initial visual difference; 5. The method of claim 4, further comprising:

6. The step of generating the visual hull comprises: determining an nth virtual hull intersection as the virtual hull intersection in response to one of (i) the nth visual disparity improvement being less than the threshold, and (ii) the nth visual disparity improvement being equal to an upper limit N, where N is a positive integer, and the nth virtual hull intersection is formed by performing the Boolean intersection operation on the nth one of the first 3D primitives and an (n-1)th virtual hull intersection.

5. The method of claim 4, further comprising:

7. The step of forming a segmented mesh comprises: slicing the 3D model with the plurality of fitting planes, each of the plurality of fitting planes slicing the 3D model into a positive portion and a negative portion, the positive portion of the 3D model being located on the positive side of the respective one of the plurality of fitting planes; projecting each of the positive portions of the 3D model onto a corresponding one of the plurality of fitting planes to obtain a respective second silhouette; obtaining an expanded bounding square of each second silhouette on the corresponding fitting plane such that the second silhouette is contained within the expanded bounding square; performing a Boolean subtraction operation to subtract each second silhouette from the augmented bounding square to obtain a bounding loop from each second silhouette; forming a second 3D primitive of one of the second 3D primitives by extruding the boundary loop of the respective second silhouette in a normal direction from the positive side of the fitting plane corresponding to the respective second silhouette; The method of claim 1 further comprising:

8. The step of forming the segmented mesh comprises: forming a first provisional segmented mesh by performing a Boolean subtraction operation on a first one of the second 3D primitives and the visual hull intersection; determining a first visual disparity improvement based on the first provisional segmented mesh and the 3D model; responsive to the visual disparity improvement being greater than a threshold, forming a second provisional segmented mesh by performing the Boolean subtraction operation on a second one of the second 3D primitives and the first provisional segmented mesh; determining a second visual disparity improvement based on the second provisional segmented mesh and the 3D model; The method of claim 1 further comprising:

9. The step of forming the segmented mesh comprises: determining, in response to one of (i) the nth visual disparity improvement being less than the threshold, and (ii) the nth visual disparity improvement being equal to an upper limit N, that the segmentation mesh is an nth provisional segmentation mesh, where N is a positive integer, and the nth provisional segmentation mesh is formed by performing a Boolean intersection operation on the nth one of the second 3D primitives and the (n-1)th provisional segmentation mesh.

9. The method of claim 8, further comprising:

10. The step of generating the low-poly mesh sequence comprises: progressively performing edge erasure and edge reversal operations on the segmented meshes to generate the sequence of low-poly meshes, each of the low-poly meshes in the sequence of low-poly meshes containing a respective number of triangles that is less than a user-selected value T, where T is a positive integer, and the number of triangles in each of the low-poly meshes is less than the number of triangles in the segmented meshes; The method of claim 1 further comprising:

11. ranking the low-poly meshes in the sequence of low-poly meshes based on the number of faces and visual differences of the low-poly meshes to generate a Pareto set; The method of claim 1 further comprising:

12. A method for generating a low-poly mesh sequence for a three-dimensional (3D) model, the method comprising: generating a visual hull of the input building 3D model by projecting the input building 3D model onto a plane perpendicular to a plurality of selected view directions of the input building 3D model to generate a plurality of first silhouettes, and constructing the visual hull based on the intersection of the generated first silhouettes; forming segmented meshes by removing concave features from the volume based on a plurality of fitting planes that slice the input building 3D model, and generating the low-poly mesh sequence based on progressive simplification of the segmented meshes; A method comprising:

13. An apparatus configured to perform the method of any one of claims 1 to 12.

14. A computer program for causing a computer to execute the method according to any one of claims 1 to 12.

Images