simplexD2linked.h

Go to the documentation of this file.

#ifndef SIMPLEXD2LINKED_H
#define SIMPLEXD2LINKED_H

#include <cassert>
#include <iosfwd>
using namespace std;

#include <typedefs.h>


/*
\brief A doubely linked triangle data structure.

This data structure has a mathematical perspective and
 is designed to support operations on the simplex 
 (triangle in 2D).

Operations with Inverse appended are the reverse of the original
 operators.  So pi[piInverse(10)] should yield 10

Winding or order of points was implied on the data structure
 although for most operations the operators are invariant to
 the order.  

There are two coordinate systems - the local ones accessing
 the arrays pi and ni and the global coordinate system which indexes
 points and triangles with integers.
*/
class simplexD2linked
{
public:

  uint pi[3];
  uint ni[3];

  uintc nifrom( uintc gpt ) const
    { return ni[piInverse(gpt)]; }

  uintc piInverse( uintc gpt ) const
  {
    assert(gpt!=0);

    if (pi[0]==gpt) return 0;
    if (pi[1]==gpt) return 1;
    if (pi[2]==gpt) return 2;

    assert(false);
    return 3; // Return crap.
  }
  boolc piInverseHas( uintc gpt ) const
  {
    if (pi[0]==gpt) return true;
    if (pi[1]==gpt) return true;
    if (pi[2]==gpt) return true;

    return false;
  }

  uintc piInverse( bool& res, uintc gpt ) const
  {
    res=true;
    if (pi[0]==gpt) return 0;
    if (pi[1]==gpt) return 1;
    if (pi[2]==gpt) return 2;

    res=false;
    return 3; // Return crap.
  }

  uintc niInverse( uintc neib ) const
  {  
    if (ni[0]==neib) return 0;
    if (ni[1]==neib) return 1;
    if (ni[2]==neib) return 2;

    assert(false);
    return 3; // Return crap.
  }  
  boolc niInverseHas( uintc neib ) const
  {  
    if (ni[0]==neib) return true;
    if (ni[1]==neib) return true;
    if (ni[2]==neib) return true;

    return false; 
  }  
  uintc niInverse( bool& res, uintc neib ) const
  {
    res=true;
    if (ni[0]==neib) return 0;
    if (ni[1]==neib) return 1;
    if (ni[2]==neib) return 2;

    res=false;
    return 3; // Return crap.
  }  



  simplexD2linked();
  simplexD2linked
  (
    uintc a, uintc b, uintc c,
    uintc na=0, uintc nb=0, uintc nc=0
  );
  void construct 
  (
    uintc a, uintc b, uintc c,
    uintc na, uintc nb, uintc nc
  );

  void getanticlockwiseface( uint & a, uint & b, uintc face) const;

  void getclockwiseface( uint & a, uint & b, uintc face) const;

  // Query Functions

  boolc isonboundary() const;
  
  // Is the point a vertex of this triangle?
  //boolc isavertex( uintc gpt ) const;

  void setnull();
  boolc isnull() const;


  // Supportive functions that use the basic operations.

  void changelink( uintc from, uintc to )
    { ni[ niInverse(from) ] = to; }

  // Common operation of getting face from opposite point.
  //uint * niFrompiInverse(uintc gpt);
    //{ return & ni[ piInverse(gpt) ]; }

  boolc operator == (simplexD2linked const & w) const;

  operator string() const;
  void serializeInverse(stringc & s);
  ostream & print(ostream& os) const;
  istream & serializeInverse(istream & is);
};

ostream & operator << (ostream& os, simplexD2linked const & x);

istream & operator >> (istream & is, simplexD2linked & x);





#endif