Python中约束曲面重网格化技术问询：严格固定边界顶点的位置、数量与顺序

针对你的需求——严格保留预定义边界顶点的位置、数量和顺序，同时生成内部均匀分布的流形网格，下面是几个经过验证的解决方案，涵盖主流的几何处理库：

1. CGAL Python Bindings (Recommended) #

CGAL的约束三角化和曲面包裹工具是处理这类问题的黄金标准，它能严格尊重边界约束，生成高质量的流形网格。

核心思路： #

1. 曲面参数化：用LSCM（Least Squares Conformal Maps）将曲面映射到平面，确保边界顶点的相对位置和顺序完全保留。
2. 约束Delaunay三角化：在参数化后的平面上，将输入的边界点作为硬约束插入，然后按目标密度生成均匀的内部点，构建三角化网格。
3. 逆映射回曲面：将平面三角化的结果映射回原始曲面，得到最终的3D网格。

简化代码示例： #

import numpy as np
import pyvista as pv
from CGAL.CGAL_Triangulation_2 import Constrained_Delaunay_triangulation_2
from CGAL.CGAL_Surface_mesh import Surface_mesh
from CGAL.CGAL_Surface_mesh_parameterization import LSCM_parameterizer

# 加载原始PyVista网格
pv_mesh = pv.read("your_mesh.vtk")
# 转换为CGAL Surface_mesh
cgal_mesh = Surface_mesh()
for point in pv_mesh.points:
    cgal_mesh.add_vertex(point)
for face in pv_mesh.faces.reshape(-1, 4)[:, 1:]:
    cgal_mesh.add_face(face[0], face[1], face[2])

# 定义边界约束（输入的前缘、后缘等有序顶点数组）
boundary_vertices = np.concatenate([leading_edge, trailing_edge, root_edge, tip_edge])
# 在CGAL中标记这些顶点为边界约束（通过坐标匹配找到对应索引）
boundary_indices = [cgal_mesh.index_of_vertex(p) for p in boundary_vertices]

# LSCM参数化，保留边界
param = LSCM_parameterizer(cgal_mesh)
param.parameterize()
# 获取参数化后的边界点坐标
boundary_param_coords = [param.uv(cgal_mesh.vertex(idx)) for idx in boundary_indices]

# 构建约束Delaunay三角化
ct = Constrained_Delaunay_triangulation_2()
ct.insert_constraint(boundary_param_coords)
# 生成内部均匀点（按目标总顶点数50000反推密度）
target_internal = 50000 - len(boundary_vertices)
# 这里需实现参数化域内的均匀采样逻辑
internal_param_points = generate_uniform_points_in_param_domain(target_internal)
ct.insert(internal_param_points)

# 将平面网格映射回原始曲面（省略逆映射细节，可通过CGAL参数化工具实现）
final_points = map_param_points_back_to_3d(ct, cgal_mesh, param)
final_faces = extract_triangulation_faces(ct)

# 调整顶点顺序，确保边界点在最前面
final_points = np.vstack([boundary_vertices, internal_points])
# 同步更新面的索引（需构建索引映射表）
index_map = build_index_map(boundary_indices, internal_indices)
final_faces = index_map[final_faces]

# 转换回PyVista PolyData
pv_final = pv.PolyData(final_points, final_faces.flatten())

2. libigl Python Bindings #

libigl的remesh函数支持直接指定约束顶点，能在保留边界的同时调整内部网格密度。

核心思路： #

1. 将PyVista网格转换为libigl的顶点-面格式。
2. 标记输入的边界顶点为constrained，确保重网格化时不移动或合并它们。
3. 定义尺寸场控制内部顶点密度，执行重网格化。
4. 手动调整顶点顺序，确保边界点位于索引0到N-1的位置。

简化代码示例： #

import numpy as np
import pyvista as pv
import igl

# 转换PyVista网格到libigl格式
pv_mesh = pv.read("your_mesh.vtk")
v = pv_mesh.points
f = pv_mesh.faces.reshape(-1, 4)[:, 1:]

# 标记边界顶点索引（通过坐标匹配找到输入边界点在原网格中的对应索引）
boundary_indices = [np.where(np.all(v == p, axis=1))[0][0] for p in boundary_vertices]
constrained = np.zeros(v.shape[0], dtype=bool)
constrained[boundary_indices] = True

# 计算内部网格尺寸（目标总顶点数50000）
target_total = 50000
internal_vertex_count = target_total - len(boundary_indices)
edge_length = np.sqrt(pv_mesh.area / (internal_vertex_count * 0.5))  # 三角形网格边长估算
sizing_field = np.full(v.shape[0], edge_length)
sizing_field[boundary_indices] = 0.0  # 固定边界顶点

# 执行约束重网格化
v_remeshed, f_remeshed = igl.remesh(v, f, sizing_field, iterations=5, constrained=constrained)

# 调整顶点顺序，确保边界点在最前面
boundary_points = v_remeshed[boundary_indices]
internal_points = v_remeshed[~constrained]
final_v = np.vstack([boundary_points, internal_points])

# 构建索引映射，更新面的索引
index_map = np.zeros(v_remeshed.shape[0], dtype=int)
for i, idx in enumerate(boundary_indices):
    index_map[idx] = i
internal_idx = len(boundary_indices)
for idx in np.where(~constrained)[0]:
    index_map[idx] = internal_idx
    internal_idx += 1
final_f = index_map[f_remeshed]

# 转换回PyVista格式
final_faces = np.hstack([np.full(len(final_f), 3), final_f.flatten()])
pv_final = pv.PolyData(final_v, final_faces)

3. PyVista + Trimesh (No Library Switch) #

如果你不想引入新的几何库，也可以用Trimesh的重网格化工具结合PyVista的精细控制来解决问题，核心是避免不必要的顶点合并。

核心思路： #

1. 将PyVista网格转换为Trimesh格式。
2. 标记边界顶点为固定点，执行重网格化。
3. 手动调整顶点顺序后，用tolerance=0.0的clean()操作——这样只有完全重合的点才会被合并，而你的边界点位置严格一致，不会被影响。

简化代码示例： #

import numpy as np
import pyvista as pv
import trimesh

# PyVista转Trimesh
pv_mesh = pv.read("your_mesh.vtk")
tri_mesh = trimesh.Trimesh(vertices=pv_mesh.points, faces=pv_mesh.faces.reshape(-1, 4)[:, 1:])

# 标记边界顶点索引（通过坐标匹配找到对应索引）
boundary_indices = [np.where(np.all(tri_mesh.vertices == p, axis=1))[0][0] for p in boundary_vertices]
# 执行约束重网格化（固定边界顶点）
target_total = 50000
edge_length = np.sqrt(tri_mesh.area / (target_total * 0.5))
remeshed_tri = trimesh.remesh.remesh(tri_mesh, edge_length, fixed=boundary_indices)

# 调整顶点顺序，确保边界点在最前面
boundary_points = remeshed_tri.vertices[boundary_indices]
internal_mask = ~np.isin(np.arange(len(remeshed_tri.vertices)), boundary_indices)
internal_points = remeshed_tri.vertices[internal_mask]
final_points = np.vstack([boundary_points, internal_points])

# 更新面的索引
index_map = np.zeros(len(remeshed_tri.vertices), dtype=int)
for i, idx in enumerate(boundary_indices):
    index_map[idx] = i
internal_idx = len(boundary_indices)
for idx in np.where(internal_mask)[0]:
    index_map[idx] = internal_idx
    internal_idx += 1
final_faces = index_map[remeshed_tri.faces].flatten()
final_faces = np.hstack([np.full(len(final_faces)//3, 3), final_faces])

# 转换回PyVista并执行安全clean
pv_final = pv.PolyData(final_points, final_faces)
pv_final = pv_final.clean(tolerance=0.0)  # 仅合并完全重合的点

关键注意事项 #

• 顶点顺序一致性：无论用哪个方案，最后都要手动将边界顶点移到索引0到N-1的位置，这是保证不同变形状态网格兼容性的核心。
• 硬约束标记：必须明确告诉算法哪些顶点是固定约束，否则工具可能会自动合并或移动它们。
• 密度控制：内部顶点数量可以通过目标总顶点数反推边长或尺寸场，确保内部网格均匀分布。

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