synaps/topology/box3d.h

Go to the documentation of this file.

/*********************************************************************
*      This file is part of the source code of SYNAPS library          *
*   Author(s): L. Deschamps                                          *
*              G. Gatellier                                          *
*              B. Mourrain, GALAAD, INRIA                            *
**********************************************************************/
#ifndef synaps_topology_box3d_H
#define synaps_topology_box3d_H
/*********************************************************************/

#include <synaps/init.h>
#include <synaps/topology/point.h>

#include <iostream>

__BEGIN_NAMESPACE_SYNAPS

namespace topology 
{


template < class C = double >
struct box3d 
{
  typedef C coeff_t;
  
  C x0, x1, y0, y1, z0, z1;

  box3d (): 
    x0( 0 ), x1( 1 ),
    y0( 0 ), y1( 1 ),
    z0( 0 ), z1( 1 ) {}
  
  box3d ( C xMin, C xMax, C yMin, C yMax, C zMin, C zMax ):
    x0( xMin ), x1( xMax ),
    y0( yMin ), y1( yMax ),
    z0( zMin ), z1( zMax ) {}
  
  box3d( const box3d & box ):
    x0( box.x0 ), x1( box.x1 ),
    y0( box.y0 ), y1( box.y1 ),
    z0( box.z0 ), z1( box.z1 ) {}
  
  void set( C xMin, C xMax, C yMin, C yMax, C zMin, C zMax ) 
    {
      x0 = xMin; x1 = xMax;
      y0 = yMin; y1 = yMax;
      z0 = zMin; z1 = zMax;
    }
  
  box3d operator= ( const box3d<C> & box ) 
    {
      x0 = box.x0; x1 = box.x1;
      y0 = box.y0; y1 = box.y1;
      z0 = box.z0; z1 = box.z1;
      
      return *this;
    }
  
};
 
} // end namespace topology

template < class C >
bool operator==( topology::box3d< C > &b0, topology::box3d< C > &b1 )
{
  return ( ( b0.x0 == b1.x0 ) && 
           ( b0.x1 == b1.x1 ) && 
           ( b0.y0 == b1.y0 ) && 
           ( b0.y1 == b1.y1 ) && 
           ( b0.z0 == b1.z0 ) && 
           ( b0.z1 == b1.z1 ) );
}

template < class C >
std::ostream & operator<<( std::ostream & os,
                           const topology::box3d< C > & b ) 
{
  os << "[ [ [" 
     << b.x0 << "," << b.x1 << "] , ["
     << b.y0 << "," << b.y1 << "] , ["
     << b.z0 << "," << b.z1 
     << "] ] ]";
  
  return os;
}

template< class C >
void checkbox3d( topology::box3d<C> box, 
                 bool &minRow, bool &minCol, bool &minHgt,
                 C epsRow ,C epsCol ,C epsHgt ) 
{
  minRow = false;
  minCol = false;
  minHgt = false;

  if ( ( ( box.x1 - box.x0 ) ) <= epsRow ) minRow = true;
  if ( ( ( box.y1 - box.y0 ) ) <= epsCol ) minCol = true;
  if ( ( ( box.z1 - box.z0 ) ) <= epsHgt ) minHgt = true;
}

//--------------------------------------------------------------------
template < class POINTGRAPH, class C>
void build_box(POINTGRAPH& g, const topology::box3d<C>& bx)
{
  typedef C coeff_t;
  typedef topology::point<coeff_t>       point_t;
  typedef typename POINTGRAPH::point_t       gpoint_t;
  int nBIdx;
  point_t l(3u);
  
  // form the graph representing the shape of the cell
  for (int i = 0; i < 8; i++)
    {
      l[0] = ((i&0x1) ? bx.x1:bx.x0);
      l[1] = ((i&0x2) ? bx.y1:bx.y0);
      l[2] = ((i&0x4) ? bx.z1:bx.z0);
      //nBIdx = g.push_back(shared_object(l));
      //nBIdx = g.push_back(intersection_ptr(new intersection_t(l,0,1)));
      nBIdx = g.push_back(l);
    }
  
  nBIdx -= 7;
  
  g.insert(nBIdx,nBIdx+1);
  g.insert(nBIdx,nBIdx+2);
  g.insert(nBIdx+1,nBIdx+3);
  g.insert(nBIdx+2,nBIdx+3);
  
  g.insert(nBIdx+4,nBIdx+5);
  g.insert(nBIdx+4,nBIdx+6);
  g.insert(nBIdx+5,nBIdx+7);
  g.insert(nBIdx+6,nBIdx+7);
  
  g.insert(nBIdx,nBIdx+4);
  g.insert(nBIdx+1,nBIdx+5);
  g.insert(nBIdx+2,nBIdx+6);
  g.insert(nBIdx+3,nBIdx+7);
}


/*********************************************************************/

__END_NAMESPACE_SYNAPS

#endif // synaps_topology_box3d_H