niftkCMC33.h

Go to the documentation of this file.

/*=============================================================================

  NifTK: A software platform for medical image computing.

  Copyright (c) University College London (UCL). All rights reserved.

  This software is distributed WITHOUT ANY WARRANTY; without even
  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  PURPOSE.

  See LICENSE.txt in the top level directory for details.

=============================================================================*/

//________________________________________________
// ALGORITHM AND SOURCE WAS ADOPTED FROM:
//________________________________________________


#ifndef niftkCMC33_h
#define niftkCMC33_h

#include "niftkCoreExports.h"

#include <vector>

#include "niftkBasicVertex.h"
#include "niftkBasicTriangle.h"

namespace niftk
{

//_____________________________________________________________________________
// types
typedef unsigned char uchar;
typedef   signed char schar;
typedef        float real ;



struct MeshData
{
  std::vector<BasicVertex>      m_Vertices  ;  // vertex buffer
  std::vector<BasicTriangle>    m_Triangles ;  // triangle buffer
  std::vector< std::vector<size_t> >  m_VertexToTriangleIndices; // lookup table vertex-->triangle
  std::vector< std::vector<size_t> >  m_VertexToVertexIndices;   // vertex adjacency list
};



//_____________________________________________________________________________
class NIFTKCORE_EXPORT CMC33
  //-----------------------------------------------------------------------------
{
  // Constructors
public :
  CMC33 ( const int size_x = -1, const int size_y = -1, const int size_z = -1 );
  ~CMC33();

  //-----------------------------------------------------------------------------
  // Accessors
public :
  inline const int nverts() const { return _nverts; }
  inline const int ntrigs() const { return _ntrigs; }

  inline const int size_x() const { return _size_x; }
  inline const int size_y() const { return _size_y; }
  inline const int size_z() const { return _size_z; }

  //inline void set_resolution( const int size_x, const int size_y, const int size_z ) { _size_x = size_x;  _size_y = size_y;  _size_z = size_z; }
  inline void set_method    ( const bool originalMC = false ) { _originalMC = originalMC; }

  inline void set_input_data  ( real *data ) { if( !_ext_data ) delete [] _data;  _ext_data = data != NULL;  if( _ext_data ) _data = data; }

  inline void  set_output_data  (MeshData * meshData) { m_MeshDataExt = meshData; }

  inline void enable_normal_computing(bool value) { _computeNormals = value; }

  // Data initialization
  void init_temps ();
  void init_all   ();
  void clean_temps();
  void clean_all  ();
  void restart();

  //-----------------------------------------------------------------------------
  // Algorithm
public :
  void run( real iso = (real)0.0 );

protected :
  void process_cube ()            ;
  bool test_face    ( schar face );
  bool test_interior( schar s )   ;
  bool modified_test_interior(schar s);
  int interior_ambiguity(int amb_face, int s);
  int interior_ambiguity_verification(int edge);

  bool interior_test_case13();
  bool interior_test_case13_2(float isovalue);

  // Data access
  inline const real get_data  ( const int i, const int j, const int k ) const { return _data[ i + j*_size_x + k*_size_x*_size_y]; }

  //-----------------------------------------------------------------------------
  // Operations
protected :
  void compute_intersection_points( real iso );

  void add_triangle ( const char* trig, char n, int v12 = -1 );

  void test_vertex_addition();
  int add_x_vertex();
  int add_y_vertex();
  int add_z_vertex();
  int add_c_vertex();

  real get_x_grad( const int i, const int j, const int k ) const;
  real get_y_grad( const int i, const int j, const int k ) const;
  real get_z_grad( const int i, const int j, const int k ) const;

  inline int   get_x_vert( const int i, const int j, const int k ) const { return _x_verts[ i + j*_size_x + k*_size_x*_size_y]; }
  inline int   get_y_vert( const int i, const int j, const int k ) const { return _y_verts[ i + j*_size_x + k*_size_x*_size_y]; }
  inline int   get_z_vert( const int i, const int j, const int k ) const { return _z_verts[ i + j*_size_x + k*_size_x*_size_y]; }

  inline void  set_x_vert( const int val, const int i, const int j, const int k ) { _x_verts[ i + j*_size_x + k*_size_x*_size_y] = val; }
  inline void  set_y_vert( const int val, const int i, const int j, const int k ) { _y_verts[ i + j*_size_x + k*_size_x*_size_y] = val; }
  inline void  set_z_vert( const int val, const int i, const int j, const int k ) { _z_verts[ i + j*_size_x + k*_size_x*_size_y] = val; }

  void    print_cube();

  void resizeAndAllocateConnectivity(int index);

  //-----------------------------------------------------------------------------
  // Elements
protected :
  bool      _originalMC;   
  bool      _ext_data  ;   
  bool      _computeNormals; 
  int       _size_x    ;  
  int       _size_y    ;  
  int       _size_z    ;  
  real     *_data      ;  
  int      *_x_verts   ;  
  int      *_y_verts   ;  
  int      *_z_verts   ;  
  int       _nverts    ;  
  int       _ntrigs    ;  
  int       _Nverts    ;  
  int       _Ntrigs    ;  
  MeshData * m_MeshDataExt;  
  int       _i         ;  
  int       _j         ;  
  int       _k         ;  
  real      _cube[8]   ;  
  uchar     _lut_entry ;  
  uchar     _case      ;  
  uchar     _config    ;  
  uchar     _subconfig ;  
};

//_____________________________________________________________________________

}

#endif