CGAL均匀曲面网格生成技术咨询：参数关联与均匀性保障

Great questions—let’s tackle them as you work through generating ellipsoid surface meshes with CGAL’s implicit function tools.

1. Relating angular_bound, radius_bound, distance_bound to Vertex/Face Counts #

First, let’s clarify what each parameter does, since their impact on mesh density (and thus vertex/face counts) is indirect but predictable:

• angular_bound: Sets the minimum allowed angle (in degrees) for any triangle in the mesh. Smaller values force more, smaller triangles to avoid sharp angles, which increases vertex/face counts. A typical default is 30 degrees.
• radius_bound: Defines the maximum allowed radius of the circumcircle of any triangle. Reducing this value directly increases the number of triangles (and vertices), as smaller triangles are needed to meet the radius limit.
• distance_bound: Limits how far any triangle’s vertices can be from the implicit surface. Tighter bounds mean more vertices are placed to conform closely to the surface, especially on curved regions, boosting counts.

There’s no exact mathematical formula to map these parameters directly to vertex/face counts—this depends heavily on your implicit surface’s complexity (like the ellipsoid’s aspect ratio). However, you can use an iterative approach to tune them:

• Start with conservative values (e.g., angular_bound=30, radius_bound=0.1*ellipsoid_axis_length, distance_bound=0.01*ellipsoid_axis_length).
• Generate a mesh, count vertices/faces using CGAL’s built-in tools (e.g., vertices(mesh).size() and faces(mesh).size() in C++).
• Adjust parameters incrementally: if you need more vertices, reduce radius_bound or distance_bound; if triangles are too skewed, increase angular_bound.

2. Generating Uniform Surface Meshes (Like Matlab’s DistMesh) #

CGAL’s default implicit surface mesher is adaptive—it creates denser triangles in high-curvature regions. To get a uniform mesh (similar to DistMesh), try these reliable approaches:

Approach 1: Unit Sphere + Affine Transformation #

This is the most consistent method for ellipsoids:

1. Normalize your ellipsoid to a unit sphere: If your ellipsoid equation is (x/a)² + (y/b)² + (z/c)² = 1, apply a coordinate transformation: x' = x/a, y' = y/b, z' = z/c. This converts the ellipsoid to a unit sphere (x'² + y'² + z'² = 1).
2. Generate a uniform unit sphere mesh: Use CGAL’s make_surface_mesh with tight, uniform parameters (e.g., radius_bound=0.1, angular_bound=30, distance_bound=0.01) to create evenly spaced triangles on the sphere.
3. Transform back to the ellipsoid: For each vertex (x', y', z') in the unit sphere mesh, compute the corresponding ellipsoid vertex as (a*x', b*y', c*z'). This preserves the uniform spacing of the original sphere mesh, scaled to fit your ellipsoid’s axes.

Approach 2: Tune Meshing Parameters for Uniformity #

If you want to work directly with the ellipsoid’s implicit function, set uniform bounds across the entire surface:

• Set radius_bound to a fixed value matching your desired mesh density (e.g., 1/20th of the smallest ellipsoid axis length).
• Set distance_bound to a fraction of radius_bound (e.g., 0.1 * radius_bound) to ensure vertices stay close to the surface without over-adapting to curvature.
• Use a moderate angular_bound (30–45 degrees) to avoid overly skewed triangles.

Note: This approach might have slight variations in triangle size on regions with different curvature, but it will be far more uniform than the default adaptive meshing.

内容的提问来源于stack exchange，提问作者shanksk