PbRegularCartesianGrid3D.h

Go to the documentation of this file.

/*=======================================================================
 *** THE CONTENT OF THIS WORK IS PROPRIETARY TO FEI S.A.S, (FEI S.A.S.),            ***
 ***              AND IS DISTRIBUTED UNDER A LICENSE AGREEMENT.                     ***
 ***                                                                                ***
 ***  REPRODUCTION, DISCLOSURE,  OR USE,  IN WHOLE OR IN PART,  OTHER THAN AS       ***
 ***  SPECIFIED  IN THE LICENSE ARE  NOT TO BE  UNDERTAKEN  EXCEPT WITH PRIOR       ***
 ***  WRITTEN AUTHORIZATION OF FEI S.A.S.                                           ***
 ***                                                                                ***
 ***                        RESTRICTED RIGHTS LEGEND                                ***
 ***  USE, DUPLICATION, OR DISCLOSURE BY THE GOVERNMENT OF THE CONTENT OF THIS      ***
 ***  WORK OR RELATED DOCUMENTATION IS SUBJECT TO RESTRICTIONS AS SET FORTH IN      ***
 ***  SUBPARAGRAPH (C)(1) OF THE COMMERCIAL COMPUTER SOFTWARE RESTRICTED RIGHT      ***
 ***  CLAUSE  AT FAR 52.227-19  OR SUBPARAGRAPH  (C)(1)(II)  OF  THE RIGHTS IN      ***
 ***  TECHNICAL DATA AND COMPUTER SOFTWARE CLAUSE AT DFARS 52.227-7013.             ***
 ***                                                                                ***
 ***                   COPYRIGHT (C) 1996-2014 BY FEI S.A.S,                        ***
 ***                        BORDEAUX, FRANCE                                        ***
 ***                      ALL RIGHTS RESERVED                                       ***
**=======================================================================*/
/*=======================================================================
** Author      : VSG (MMM YYYY)
**=======================================================================*/
 
#ifndef  _PB_REGULARCARTESIANGRID3D_
#define  _PB_REGULARCARTESIANGRID3D_
 
#include <MeshViz/3Ddata/PbGrid3D.h>
 
class PbVoxelCell;
class  PbRegularCartesianGrid3D : public PbGrid3D {
 
 public:
 
  PbRegularCartesianGrid3D(SbBool isDataDuplicate=TRUE);
 
  PbRegularCartesianGrid3D(const PbRegularCartesianGrid3D &mesh);
 
  PbRegularCartesianGrid3D(int num_x, int num_y, int num_z, 
                           float x_min, float y_min, float z_min, 
                           float x_max, float y_max, float z_max, 
                           SbBool isDataDuplicate = TRUE);
 
  ~PbRegularCartesianGrid3D();
 
  PbRegularCartesianGrid3D& operator=(const PbRegularCartesianGrid3D &mesh);
 
   friend int operator ==(const PbRegularCartesianGrid3D &m1, 
                         const PbRegularCartesianGrid3D &m2);
 
   friend int operator !=(const PbRegularCartesianGrid3D &m1, 
                         const PbRegularCartesianGrid3D &m2)
  { return !(m1 == m2); }
 
  void setGeometry(int num_x, int num_y, int num_z, 
                   float x_min, float y_min, float z_min, 
                   float x_max, float y_max, float z_max);
 
  void getGeometry(int &num_x, int &num_y, int &num_z, 
                   float &x_min, float &y_min, float &z_min, 
                   float &x_max, float &y_max, float &z_max) const;
 
  virtual const PbCell* findContainingCell(const SbVec3f &point, 
                                           float tolerance, 
                                           SbVec3f &pcoord, 
                                           const PbCell *adjacent_cell) const;
 
  virtual const PbCell* findContainingCell(const SbVec3f &point, 
                                           float tolerance, 
                                           SbVec3f &pcoord) const;
 
  virtual const PbCell *getCell(int cell_index) const;
 
  virtual SbVec3f getNodeCoord(int nod_index) const;
 
  virtual SbVec3f getNodeCoord(int i, int j, int k) const
    { return SbVec3f(m_xmin+i*m_dx, m_ymin+j*m_dy, m_zmin+k*m_dz); };
 
  virtual float getVolume() const
    { return fabs((m_xmax-m_xmin)*(m_ymax-m_ymin)*(m_zmax-m_zmin)); }
 
  void setCoordinates(const float *xnod, const float *ynod, const float *znod);
 
  void getCoordinates(const float* &xnod, const float* &ynod, const float* &znod,
                      int &size_xnod, int &size_ynod, int &size_znod) const {
    xnod = m_x;
    ynod = m_y;
    znod = m_z;
    size_xnod = size_ynod = size_znod = 2;
  }
 
  /*----------------------------------------------------------------------------*/
 private:
  void setBounds(float x_min, float y_min, float z_min, 
                 float x_max, float y_max, float z_max);
 
  float getLongestEdgeLength();
  // get the length of the longest edge of the mesh
 
  void meshCrossSection(PoMeshCrossSection *cross_section) const; 
  void meshCrossContour(PoMeshCrossContour *cross_contour) const; 
  void meshSkeleton(PoMeshSkeleton *skeleton, 
                    const float *nod_values, 
                    float *x_cont,
                    float *y_cont, 
                    float *z_cont) const; 
  void mesh3DVec(PoMesh3DVec *mesh_vec) const;
  SbBool isCrossSectionOptimal() const { return TRUE; }
 
  void print(FILE *fp) const;
 
  // get a cell, but this cell has'nt coordinate specified
  virtual const PbCell *getTopoCell(int cell_index) const;
 
 private:
  void constructXYGeometry(float x_min, float y_min, 
                           float x_max, float y_max, 
                           SbBool is_data_duplicate);
  void setXYZGeometry(int num_x, int num_y, int num_z, 
                      const float *x, const float *y, const float *z);
  void getXYZGeometry(const float* &x, const float* &y, const float* &z) const;
  virtual void grid3DSkin(PoMeshSkin *_PoMeshSkin) const;
 
 private:
  float m_x[2], m_y[2], m_z[2];
  float m_xmin, m_xmax, m_dx;
  float m_ymin, m_ymax, m_dy;
  float m_zmin, m_zmax, m_dz;
 
  void updateBoundingBox() const;
  void copy(const PbRegularCartesianGrid3D &mesh);
  void destroy();
 
  mutable PbVoxelCell *m_voxel;
};
 
/*---------------------------------------------------------------------------*/
 
inline void
PbRegularCartesianGrid3D::getGeometry(int &num_x, int &num_y, int &num_z, 
                                      float &x_min, float &y_min, float &z_min, 
                                      float &x_max, float &y_max, float &z_max) const
{
  num_x = numX; x_min = m_xmin; x_max = m_xmax;
  num_y = numY; y_min = m_ymin; y_max = m_ymax;
  num_z = numZ; z_min = m_zmin; z_max = m_zmax;
}
 
#endif /* _PB_REGULARCARTESIANGRID3D_ */