Hey there! Let's work through your VTK ConstrainedDelaunay2D issues one by one, tailored specifically for VTK 8.2 as you specified.

Your intuition about "same point set = same triangulation" makes sense on the surface, but VTK's vtkDelaunay2D with constraints relies heavily on polygon winding order and the right-hand coordinate system rule to distinguish between outer boundaries and inner holes. Here's what's happening:

• When you flip the Y-coordinate, you're effectively reversing the direction of the Y-axis, turning the default right-hand coordinate system into a left-hand one. This flips the normal direction of your boundary polygon as calculated by VTK.
• Reversing the order of point IDs in the boundary polygon does the same thing: it inverts the polygon's winding direction (clockwise ↔ counter-clockwise), which also flips its normal.

VTK uses the polygon's normal direction to decide whether it's an outer boundary (normal pointing +Z, counter-clockwise winding in right-hand XY plane) or an inner hole (normal pointing -Z, clockwise winding). If this interpretation gets flipped, the triangulation will fill the opposite region—hence the different results you're seeing.

Yes, you can get consistent face normals with vtkDelaunay2D plus a small helper filter. Here's the step-by-step solution:

Step 1: Standardize Boundary Polygon Winding Order #

First, make sure your outer boundary uses a counter-clockwise winding order (which produces a +Z normal in the default XY plane). This aligns with VTK's expected behavior for outer constraints. Add this check after creating your boundary polygon:

vtkSmartPointer<vtkPolygon> aPolygon = vtkSmartPointer<vtkPolygon>::New();
// Insert original point IDs first
for (unsigned int i = 0; i < pts.size(); i++) {
    aPolygon->GetPointIds()->InsertNextId(i);
}

// Calculate the polygon's normal to check winding order
double normal[3];
aPolygon->ComputeNormal(points, normal);

// If normal points downward (-Z), reverse the point order to fix winding
if (normal[2] < 0) {
    vtkIdList* reversedIds = vtkSmartPointer<vtkIdList>::New();
    vtkIdList* originalIds = aPolygon->GetPointIds();
    for (int i = originalIds->GetNumberOfIds() - 1; i >= 0; i--) {
        reversedIds->InsertNextId(originalIds->GetId(i));
    }
    aPolygon->SetPointIds(reversedIds);
}

This ensures your boundary is interpreted correctly as an outer constraint, which sets the foundation for consistent normals.

Step 2: Use vtkPolyDataNormals with Consistency Enabled #

Your earlier attempt with vtkPolyDataNormals likely failed because you used SetInputData() instead of connecting the pipeline properly (VTK needs to handle data flow updates in order). The key flag here is ConsistencyOn(), which forces all face normals to align consistently. Update your visualization pipeline like this:

// After setting up the delaunay filter
vtkSmartPointer<vtkPolyDataNormals> normalGenerator = vtkSmartPointer<vtkPolyDataNormals>::New();
normalGenerator->SetInputConnection(delaunay->GetOutputPort()); // Use pipeline port instead of direct output
normalGenerator->ComputePointNormalsOff();
normalGenerator->ComputeCellNormalsOn();
normalGenerator->ConsistencyOn(); // Critical: enforces consistent normals across all faces
normalGenerator->FlipNormalsOff(); // Only enable this if you need to invert all normals after consistency check
normalGenerator->Update();

// Connect the normals filter output to your mapper
vtkSmartPointer<vtkPolyDataMapper> meshMapper = vtkSmartPointer<vtkPolyDataMapper>::New();
meshMapper->SetInputConnection(normalGenerator->GetOutputPort());

This filter will traverse all triangulated faces and adjust any reversed normals to match the majority (or the boundary's normal direction), ensuring uniformity.

Additional VTK 8.2 Notes #

• You don't need to explicitly set VTK_DELAUNAY_XY_PLANE—it's the default projection mode for vtkDelaunay2D in 8.2.
• Once normals are consistent, your BackfaceCulling setting will work as expected, since VTK can reliably distinguish front/back faces.

To recap: You only need vtkDelaunay2D plus vtkPolyDataNormals (with consistency enabled) to get constrained triangulation with uniform face normals. The critical first step is fixing your boundary polygon's winding order to match VTK's coordinate system expectations.

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