Quick-Hull Mesh Generation with Minimization

Splitting 2-Simplex with Points Inside Example

An example in 2D without the mesh being rebalanced.

Splitting 2-Simplex Process

Algorithm

N is the dimension of the space. A simplex is a N-simplex in $R^{N}$ . For example a triangle is a 2-simplex in $R^{2}$ , a tetrahedron is a 3-simplex in $R^{3}$ .

Use the Quick-Hull algorithm to construct simplexes with 0 or more points inside them. Have a Primitive Mesh with State x and a stack cs of simplexes with points inside the simplex.

All simplexes with no points inside them are pushed into x. The simplex becomes one of the meshes primitive shapes. This primitive shape is rebalanced in the mesh insertion which I call simplex minimization. Whenever a new simplex is inserted the mesh is rebalanced.

The other simplexes with their points are put into cs. cs is the current stack and these are further processed.

For each simplex and its list of points in cs do

Pop the simplex and its list of points. Split the simplex about an inside arbitrary point, creating N simplexes and push them onto x and cs depending on whether or they have no points inside them or they do.

while cs is not empty

Generalized Simplex Half-Space

The need to have a balanced mesh is the most difficult part of the algorithm. When a simplex is inserted into the mesh, how is it connected to the mesh in constant time?

The algorithm so far has assumed that this can be done. The following is a development to realize this. A data structure is introduced to have a two layered system of mesh generation. The mesh is the bottom layer. A top layer of Generalized Simplex Half-Spaces covers the mesh and inserts simplexes into the mesh.

gshs data structure
${h, p_{i}, n_{k}, s_{k}}$
$k = 0 .. N$ corresponds with simplex sides,
$h$ is the half space,
$p_{i}$ is the list of points in the half space
$n_{k}$ is the neighboring gshs's,
$s_{k}$ is the simplex inside this gshs and bordering the associated side.

The process of mesh construction is linked to gshs mesh construction. When a new gshs is created it creates more gshs's and moves any points that are visible to these out of its point list and into theirs. So all the gshs structures point lists have points inside their gshs.

The gshs processes its point list and builds a local mesh of connected simplexes. This is done by partitioning an arbitrary point dividing the simplex into N+1 simplexes. The other points are repartitioned into their respective simplexes and the process continues recursively until the local mesh is built.

The gshs maintains pointers to its boundaries. Once it completes its local mesh, it iterates around its border asking neighboring gshs structures if they have completed their local mesh. If so it minimizes their respective boundary simplexes and sets its link to that neighbor to null as the two boundaries are now joined at the mesh level.

From an implementation point of view the gshs structures are expensive so its a good idea for them to be destroyed after they have done their job. Since I use integer indexes for random access these must remain constant. A dequeue with negative indexes could be used as the parent gshs is constructed and destroyed before the child. A special dequeue that adjusts itself so its indexes that it initially gives always refer to the object inserted can be created for this job.

Quick-Hull Mesh Generation with Minimization

Intro

Tessellation

Splitting 2-Simplex with Points Inside Example

Splitting 2-Simplex Process

Algorithm

Generalized Simplex Half-Space