halfspaceD3indexed.h

Go to the documentation of this file.

#ifndef HALFSPACED3INDEXED_H
#define HALFSPACED3INDEXED_H

#include <cassert>
using namespace std;

#include <typedefs.h>
#include <partitionspace.h>
#include <mathlib.h>
#include <zero.h>

template< typename PT, typename PD, typename INDX >
class halfspaceD3indexed : public partitionspace<PT>
{
public:

  PT const & p0;  
  PT const & p1;
  PT const & p2;  
  PT normal;  

  INDX i0;
  INDX i1;
  INDX i2;

  halfspaceD3indexed
  (
    PT const * pts,
    INDX i0_,
    INDX i1_,
    INDX i2_
  )
    : p0(pts[i0_]), p1(pts[i1_]), p2(pts[i2_]),
      i0(i0_), i1(i1_), i2(i2_)
    { normalcalculate(); }

  void normalcalculate();

  boolc isInside( PT const & x ) const
    { return 0 < normal.x*(x.x-p0.x)+normal.y*(x.y-p0.y)+normal.z*(x.z-p0.z); }
  boolc isInsideOrOnBoundary( PT const & x ) const
    { return 0 < zero<PD>::val+normal.x*(x.x-p0.x)+normal.y*(x.y-p0.y)+normal.z*(x.z-p0.z); }

  PD const distancefromhalfspace(PT const & w) const
    { 
      PT p;
      p.x=normal.x*normal.x*(p0.x-w.x);
      p.y=normal.y*normal.y*(p0.y-w.y);
      p.z=normal.z*normal.z*(p0.z-w.z);
      return p.x*p.x+p.y*p.y+p.z*p.z;
    }
};


// --------------------------------------------------------- 
// Implementation


template< typename PT, typename PD, typename INDX >
void halfspaceD3indexed<PT,PD,INDX>::normalcalculate()
{
  PT u(p2 - p1);
  PT v(p0 - p1);

  normal.x=u.y*v.z-v.y*u.z;
  normal.y=u.z*v.x-u.x*v.z;
  normal.z=u.x*v.y-u.y*v.x;
}


#endif