Simplex Meshes with State

Definitions

A simplexis the simplest bounded object in that dimension. The object is convex in the sense that any point inside itself can be connected to another point inside itself, and the line of points connecting the two points is also inside the object too.

For example a triangle is a 2-simplex in , a tetrahedron is a 3-simplex in .

And you can see that this can be generalized for any dimension. Not that a N-simplex has sides for space. So a line segment is a simplex in 1D.

Simplex Representation

I have implemented the simplexes as an ordered set of points and an ordered set of neighbors. The order of the points defines a fixed orientation.

The neighbors are pointers opposite the vertex of the point with the same local index. The simplex has a property that the sides of boundary of the simplex are in one to one correspondence with the number of points the simplex has.

The points and neighbors have integer indexes as both the points and simplexes are stored in a vector data structure.

The simplex representation is not unique. If the simplex is N dimensional there are N such representations, just shift the point and neighbors along.

For two dimensional space the simplex is a triangle and the order of points is defined to be anti clockwise in direction. For 3 or more dimensions I choose an arbitrary ordering of points. There could be a more general pattern but I have not investigated higher dimensions.

Simplex Operations

These are functions which are defined on the local data structure. For example given the point p, does it belong to the simplex s?

These operations act on an instance of a simplex data structure. The dot operator is also a membership operator, so if x is a simplex the following calls the pi[] operator on x assigning the index to a point to y.

y = x.pi[2]

Programmers will feel very much at home with this notation. It is incredibly concise and very useful.

pi[]

Return an index to a point. The local index argument is anywhere from 0 to N-1 where N is the simplex dimension and the argument is an integer.

piInverse and piInverseHas

These functions are very similar and are essentially the reverse of pi[]. For efficiency piInverse(gpt) assumes that the point exists and returns its local index.

Alternatively piInverseHas(gpt) does not return the local index but queries whether the point is belongs to the data structure and returns a boolean value.

ni[]

Return an index to the simplex that is opposite the point with the same local index. A zero is returned if the simplex has no neighbor.

When two simplexes are connected and share a border they both point to each other. While this is part of the mesh and has nothing to do with the simplex data structure I mentioned it only that you should expect a two way link. However someone could always implement one way links as another type of mesh.

niInverse and niInverseHas

These functions are very similar and are essentially the reverse of ni[]. For efficiency niInverse(nieb) assumes that the neighbor exists and returns its local index.

Alternatively niInverseHas(neib) does not return the local index but queries whether the neighbor is pointed to by this data structure and returns a boolean value.

isnull and setnull

A simplex can become non existent within a mesh. To support this the concept of a zero point and a zero neighbor were introduced to indicate no point or neighbor. It naturally follows that a simplex with all of its point and neighbor fields set to zero is a non existent simplex.

The functions setnull() set all the simplexes fields to zero.

The function isnull() queries whether this simplex exists or not.

isonboundary

A zero neighbor is interpreted as a surface boundary. I use surface loosely to refer to a connected mesh or simplex one dimension less than this simplex. Often we want to identify the surface or boundary and testing whether one of its links is zero does this, provided this simplex exists.

getanticlockwiseface

This function returns a simplex as an ordered series of points opposite a point on this simplex.

For a n dimensional simplex getanticlockwiseface(n-1) returns the same ordering of points which defined this simplex. So you can see that this function really returns valid permutations of this simplex and ties in with what I said earlier in that the way the simplex is defined it is not a unique data structure. The different permutations represent simplex orientations and in this sense it is unique.

changelink

This is a very simple operation. It takes a valid link and points it to somewhere else. While it appears simple it is very useful, here is the definition. For efficiency I assume that the references are valid.

  // Change the link to point to another simplex.
  void changelink( uintc from, uintc to )
    { ni[ niInverse(from) ] = to; }

Mesh Minimization

Simplex Minimization

TODO - vast topic.

Insertion of new Point into a Continuous Convex Mesh

Let a Continuous mesh be one where all the shapes are connected.

Insertion of a Simplex into a Non-Continuous Mesh

Let a Non-Continuous mesh be a mesh which may have unconnected shapes.

Mesh Operators

simplexdelete

simplexdelete(s) deletes the simplex pointed to by s. If the neighbors are not null then they are transversed and their links to s are set to 0. All the fields in s are set to 0.

simplexswap

This swaps two arbitrary simplexes in the mesh. This requires any simplexes which point to either of s0 or s1 to also be changed. The call to this function looks like this. simplexswap(s0,s1).

Here is the pseudo code for a two n dimensional simplexes to be swapped.

simplexswap( s0, s1)

Copy the old links.
for i=0..n-1
    a_i = vi[s0].ni[i]
    b_i = vi[s1].ni[i]

Update the new links.
for i=0..n-1
    if (a_i 0)
        if (vi[a_i].niInverseHas(s1)==false)
            vi[a_i].changelink(s0,s1);
        else
            Swap the neighbors s0 and s1.
            c = vi[a_i].niInverse(s1)
            vi[a_i].ni[ vi[a_i].niInverse(s0) ] = s1
            vi[a_i].ni[c] = s0
    if (b_i 0)
        if (vi[b_i].niInverseHas(s0)==false)
            vi[b_i].changelink(s1,s0);

Finally swap the simplexes position in the vector vi.
    simplex s = vi[s0];
    vi[s0] = vi[s1];
    vi[s1] = s

This code can be optimized further. For example from treating one of the simplexes the case of neighbors sharing a border between the two simplexes s0 and s1 can be identified and need not be tested a second time for the second simplex. As it is the code is bordering on a reader ignoring it because it already looks too complicated so I did not wish to further screw with the code.

removenullsimplexes

Simplify the mesh by removing dead or null simplexes. The list of simplexes is transversed once and null simplexes are swapped out and deleted.

Remove any null simplexes at the end of vi so the last simplex is non null or there is no tessellation.

Iterate through the simplexes. Swap any null simplexes with the last non null simplex.

Remove any null simplexes at the end of vi so the last simplex is non null or there is no tessellation.

class maxEdgeLength
{
  d3tess & tess;
  vector<d3tri> & vi;
  vector<pt3> & pt;
  double const delta;
public:

  maxEdgeLength(d3tess & _tess, double const _delta)
    : tess(_tess), vi(tess.vi), pt(tess.pt), delta(_delta) {}

  bool const eval(uintc s, uintc j)
  {
    assert(j<3);

    d3tri * x = & vi[s];
    pt3c & A(pt[ x->pi[(j+1)%3] ]);
    pt3c & B(pt[ x->pi[(j+2)%3] ]);
    if ( (A.x-B.x)*(A.x-B.x) + (A.y-B.y)*(A.y-B.y) > delta )
    {
      tess.splitmidpoint1D(s,x->pi[j]);
      return true;
    }

    return false;
  }
};

  // s is the simplex, j is the local index indicating which side 
  //   the point w is on.
  void splitonboundary( uintc s, uintc j, uintc w );

  uintc n0 = vi.size();

  // Neighboring triangle opposite p0
  uintc neib = vi[s].nifrom(p0);

  // If the first splitting point has no neighbor on the given 
  //   boundary then handle this case. 
  if (neib==0)
  {
    split1D(s,p0,w0);
    if ( vi[s].piInverseHas(p1) )
      split1D(n0,w0,w1);
    else
      split1D(s,w0,w1);

    return;
  }

  // The first split will create 4 new triangles and delete two.
  split1D(s,p0,w0);

  //  The second triangle to be split contains the point p0 but
  //    does not contain the point p1 as one of its points.

  uint k[4];
  k[0] = s;
  k[1] = neib;
  k[2] = n0;
  k[3] = n0+1;

  d3tri *t;
  uint ki;
  for ( uint i=0; i<4; ++i )
  {
    ki=k[i];
    t = & vi[ki];
    if ( t->piInverseHas(p1) == true )
      continue;
    if ( t->piInverseHas(p0) == false )
      continue;

    split1D(ki,w0,w1);

    return;
  }