d3meshiterrecursive.h

Go to the documentation of this file.

#ifndef D3MESHITERRECURSIVE_H
#define D3MESHITERRECURSIVE_H

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

#include <simplexD2linked.h>
#include <typedefs.h>


/*
  Recursivly process the simplex by applying the binary operator 
  it with its neighbors.  If it or any neighbors
  change they are processed too.

  B - binary operator returns true if the mesh was changed.
 
  The mesh is represented as a vector of simplexes and references are integers
  into this stack.
*/
template < typename B >
class d3meshiterrecursive
{
  vector<uint> process;
public:

  vector<simplexD2linked> & vi; 
  B & op;

  d3meshiterrecursive( vector<simplexD2linked> & _vi, B & _op )
    : vi(_vi), op(_op) {}

  void eval(uintc s0);

  void evallinear();
};

template < typename B >
void d3meshiterrecursive<B>::eval(uintc s0)
{
  assert(s0>0);
  assert( s0<vi.size() );
  
  if (vi[s0].isnull()==true)
    return;

  process.clear();
  process.push_back(s0);

  uint k;
  simplexD2linked * x;
  uint psz;
  uint nb;
  uint visz;
  for (; process.empty()==false; )
  {
    psz = process.size();
    k = process[psz-1];
    process.pop_back();
    x =  & vi[k];
    assert(x->isnull()==false);
    for (uint i=0; i<3; ++i)
    {
      nb = x->ni[i];
      visz = vi.size();
      if (op.eval(k,i))
      {
        if (nb!=0)
          process.push_back(nb);
        process.push_back(k);

        for (uint j=visz; j<vi.size(); ++j)
          process.push_back(j);
        i=10; // kill loop
      }
    }
  }

}

template < typename B >
void d3meshiterrecursive<B>::evallinear()
{
  for ( uint i=1; i<vi.size(); ++i)
    eval(i);
}


#endif