Delaunay 3D Manual

About

A Delaunay triangulation connects a set of points with lines so that a given point is connected to its neighbors. The 3D extension maxon::Delaunay3DInterface allows to fill the space between points with tetrahedrons.

Note
This class is used inside the maxon::Voronoi3DInterface, see Voronoi 3D Manual.

Delaunay3DInterface

The maxon::Delaunay3DInterface collects the given points and computes the tetrahedrons filling the space between these points.

An object is initialized with:

Points are added to the object with:

The calculation of the tetrahedrons is performed with:

The resulting geometry data is accessed with:

The tetrahedron containing a given point can be obtained with:

Miscellaneous functions are:

Tetrahedron

A maxon::Tetrahedron object represents a tetrahedron filling the space between the points of the Delaunay object. The class gives access to the tetrahedron's points and faces:

Further functions are:

Example

// This example fills the space between the given points with
// tetrahedron polygons using the Delaunay triangulation.
// The resulting geometry is copied to PolygonObjects.
// calculate size of the workspace which covers all points
MinMax mm;
for (maxon::Int i = 0; i != points.GetCount(); ++i)
{
mm.AddPoint(points[i]);
}
const maxon::Vector buffer { 100.0, 100.0, 100.0 };
workspace._minValue = mm.GetMin() - buffer;
workspace._maxValue = mm.GetMax() + buffer;
// create Delaunay3DRef and perform tetrahedralization
maxon::Delaunay3DRef delaunay3D = maxon::Delaunay3DRef::Create() iferr_return;
delaunay3D.Init(workspace) iferr_return;
delaunay3D.AddPointsIntoTetrahedralization(points) iferr_return;
delaunay3D.CalculateDelaunayTetrahedralization() iferr_return;
// access resulting geometry
const maxon::BaseArray<maxon::Tetrahedron>& tetrahedrons = delaunay3D.GetTetrahedrons();
const maxon::BaseArray<Vector>& pointsArray = delaunay3D.GetPoints();
maxon::LinearCongruentialRandom<maxon::Float32> randomGen; // random generator for object colors
const maxon::Int tetrahedronPoints = 4;
const maxon::Int tetrahedronFaces = 4;
// for each tetrahedron create a PolygonObject
for (const maxon::Tetrahedron& tetrahedron : tetrahedrons)
{
// ignore tetrahedron that includes "internal" points (0 - 3)
auto CheckTetra = [tetrahedronPoints](const maxon::Tetrahedron& tetra) -> maxon::Bool
{
const maxon::Int internalVertice = 4;
for (maxon::Int i = 0; i < tetrahedronPoints; ++i)
{
if (tetra.points[i] < internalVertice)
return false;
}
return true;
};
// create PolygonObject for the given tetrahedron
if (CheckTetra(tetrahedron))
{
// alloc PolygonObject
PolygonObject* const polyObject = PolygonObject::Alloc(tetrahedronPoints, tetrahedronFaces);
if (polyObject != nullptr)
{
CPolygon* const polygons = polyObject->GetPolygonW();
Vector* const polyPoints = polyObject->GetPointW();
if (polygons && polyPoints)
{
// set vertices
for (maxon::Int i = 0; i < tetrahedronPoints; ++i)
{
const maxon::Int pointIndex = tetrahedron.points[i];
polyPoints[i] = pointsArray[pointIndex];
}
// set polygons
for (maxon::Int32 i = 0; i < tetrahedronFaces; ++i)
{
// get global face points
maxon::IntVector32 tetraPoints;
tetrahedron.GetFacePoints(i, tetraPoints);
// set local points
polygons[i].a = tetrahedron.GetPointIndexOfPoint(tetraPoints.x);
polygons[i].b = tetrahedron.GetPointIndexOfPoint(tetraPoints.y);
polygons[i].c = tetrahedron.GetPointIndexOfPoint(tetraPoints.z);
polygons[i].d = tetrahedron.GetPointIndexOfPoint(tetraPoints.z);
}
}
// update geometry
polyObject->Message(MSG_UPDATE);
// create random color
auto GetRandomColor = [&randomGen]() -> maxon::Vector
{
color.x = (randomGen.Get01() * 0.5) + 0.5;
color.y = (randomGen.Get01() * 0.5) + 0.5;
color.z = (randomGen.Get01() * 0.5) + 0.5;
return color;
};
// set object color
polyObject->SetParameter(ID_BASEOBJECT_COLOR, GetRandomColor(), DESCFLAGS_SET::NONE);
// insert object into the scene
doc->InsertObject(polyObject, nullptr, nullptr);
}
}
}

Further Reading