u3d_data_cube.hpp

/* u3d_data_cube.hpp */
/* $Id: u3d_data_cube.hpp,v 1.2 2008/09/29 11:15:15 ibadm Exp $ */
#ifndef __u3d_data_cube_hpp
#define __u3d_data_cube_hpp

//#include <vector>
#include <map>
#include <ios>
#include <string.h>

#include "u3d_migr.hpp"
#include <mix/u3d_progress.hpp>

typedef unsigned short ushort;




enum PlaneOrient {PT_X, PT_Y, PT_Z};




//--------------------------------------------------------------------------------
using std::size_t;

//--------------------------------------------------------------------------------
template<class T>
class U3dArray3D {

  // These two inner classes were made for provide classical access style for 3d arrays with operator[]
  class InnerArray;       // Inner class incapsulates linear array;
  class SliceAccessor;    // Inner class that provide access to specified "squair slice"
public:



  U3dArray3D() :
    innerArrayAccessor(0, 0 ,0),
    sliceAccessor(innerArrayAccessor)
  {}
 

  U3dArray3D(size_t width, size_t height, size_t depth) : 
    innerArrayAccessor(width, height, depth),
    sliceAccessor(innerArrayAccessor)
  {}


  U3dArray3D(const U3dArray3D& that) :
    innerArrayAccessor(that.innerArrayAccessor),
    sliceAccessor(innerArrayAccessor)
  {}
  

  U3dArray3D& operator=(const U3dArray3D& that)
  {    
    innerArrayAccessor.~InnerArray();
    new(&innerArrayAccessor) InnerArray(that.innerArrayAccessor);
    sliceAccessor.~SliceAccessor();
    new(&sliceAccessor) SliceAccessor(innerArrayAccessor);
  }


  // Classic style access:
  inline SliceAccessor&        operator[](const size_t& slNdx)       { return sliceAccessor(slNdx); }
  inline const SliceAccessor&  operator[](const size_t& slNdx) const { return sliceAccessor(slNdx); }


  // Not classic style access:
  T&        element(size_t i, size_t j, size_t k) { 
    assert(i<innerArrayAccessor.m_width &&
       j<innerArrayAccessor.m_height &&
       k<innerArrayAccessor.m_depth);
    return innerArrayAccessor.m_array[innerArrayAccessor.m_depth*(i*innerArrayAccessor.m_height + j) + k];
  }
  const T&  element(size_t i, size_t j, size_t k) const { 
    assert(i<innerArrayAccessor.m_width &&
       j<innerArrayAccessor.m_height &&
       k<innerArrayAccessor.m_depth);
    return innerArrayAccessor.m_array[innerArrayAccessor.m_depth*(i*innerArrayAccessor.m_height + j) + k];
  }


  // Set new dimensions of array. Old content will be deleted.
  void setDimensions(size_t width, size_t height, size_t depth) {
    innerArrayAccessor.~InnerArray();
    new(&innerArrayAccessor) InnerArray(width, height, depth);
    sliceAccessor.~SliceAccessor();
    new(&sliceAccessor) SliceAccessor(innerArrayAccessor);
  }


  // Assigns all elements in array to t
  void assign(T t) {
    for (size_t i=0; i<innerArrayAccessor.m_size; innerArrayAccessor.m_array[i++] = t);
  }


  // Return pointer to inner array
  T*       innerArray()       { return innerArrayAccessor.m_array; }
  const T* innerArray() const { return innerArrayAccessor.m_array; }


  // returns width*height*depth
  size_t size()         const { return innerArrayAccessor.m_size;  }


  size_t width()        const { return innerArrayAccessor.m_width; }
  size_t height()       const { return innerArrayAccessor.m_height;}
  size_t depth()        const { return innerArrayAccessor.m_depth; }


  void clear()                { setDimensions(0,0,0); }


private:
  

  class InnerArray {
  public:

    InnerArray(size_t width, size_t height, size_t depth) :
      m_width(width), m_height(height), m_depth(depth),
      m_size(width*height*depth), m_array(new T[m_size])
    {}

    InnerArray(const InnerArray& that) :
      m_width(that.m_width), m_height(that.m_height), m_depth(that.m_depth),
      m_size(that.m_size), m_array(new T[m_size])  
    { 
      std::copy(that.m_array, that.m_array + that.m_size, m_array);
    }

    ~InnerArray()    { delete[] m_array; }

    inline InnerArray&        operator()(const size_t& colNum) { 
      offset = colNum*m_depth;  return *this; 
    }
    inline const InnerArray&  operator()(const size_t& colNum) const { 
      offset = colNum*m_depth;  return *this; 
    }
    inline T&                 operator[](const size_t& depthNdx) { 
      assert(depthNdx < m_depth);
      return m_array[offset+depthNdx]; 
    }
    inline const T&           operator[](const size_t& depthNdx) const { 
      assert(depthNdx < m_depth);
      return m_array[offset+depthNdx]; 
    }

    //  private:  // No private! U3dArray3D is my best friend!
    size_t          m_width;
    size_t          m_height;
    size_t          m_depth;
    size_t          m_size;
    T*              m_array;
    mutable size_t  offset;
  };




  class SliceAccessor {
  public:
    SliceAccessor(InnerArray& inArr)  :  colsPerSlice(inArr.m_height), innerArrayAccessor(inArr) {}
    inline SliceAccessor&       operator()(const size_t& slNum) { 
      assert(slNum < innerArrayAccessor.m_width);
      offsetInColumns = slNum*colsPerSlice;  return *this;
    }
    inline const SliceAccessor& operator()(const size_t& slNum) const { 
      assert(slNum < innerArrayAccessor.m_width);
      offsetInColumns = slNum*colsPerSlice;  return *this;
    }
    inline InnerArray&          operator[](const size_t& colNum) { 
      assert(colNum < innerArrayAccessor.m_height);
      return innerArrayAccessor(offsetInColumns + colNum); 
    }
    inline const InnerArray&    operator[](const size_t& colNum) const { 
      assert(colNum < innerArrayAccessor.m_height);
      return innerArrayAccessor(offsetInColumns + colNum); 
    }
    
    //  private:  // No private! U3dArray3D is my best friend also!
    mutable size_t offsetInColumns;
    size_t         colsPerSlice;
    InnerArray& innerArrayAccessor;
  };

  
  InnerArray      innerArrayAccessor;
  SliceAccessor   sliceAccessor;
};








//----------------------------------------------------------------------------------------------------
class U3dDataCube
{
public:


  class badcontent : public std::exception {
  public:
    badcontent();
    badcontent(const char* str) { strncpy(message, str, 127); };
    const char* what() const throw() { return message; };
  private:
    char message[128];
  };



  U3dDataCube();
  
  U3dDataCube(ushort i_size, ushort j_size, ushort k_size, float x_max, float y_max, float z_max);

  U3dDataCube(U3dModel* model, U3D_WAVE_TYPE wt, ushort isize, ushort jsize, ushort ksize, U3dProgress *prg=NULL);
  
  U3dDataCube(const U3dDataCube& other);
  
  /* Allocates memory for amplitudes data, calculates coordinate steps */
  bool     initialize(ushort i_size, ushort j_size, ushort k_size, float x_max, float y_max, float z_max);
  
  void     loadFromFile(const char* fileName) throw(std::ios_base::failure, badcontent);


  void     generate(ushort i_max, ushort j_max, ushort k_max, float x_max, float y_max, float z_max);
  
  void     getDimensions(ushort* widthX, ushort* heightY, ushort* depthZ);
  
  void     getCubeCoordLimits(float &xmax, float &ymax, float &zmax);
    
  void     saveToFile(const char* fname);

  unsigned getImageSize();

  bool     getPlaneFacet(const PlaneOrient& op, const float& coord, float*& images);


  bool     getPlaneAxeSimple(float xn, float yn, float xk, float yk, float*& images, 
             ushort* width, ushort* depth);

  bool     getPlaneAxeIntrpl(float xn, float yn, float xk, float yk, float*& images,
             ushort* width, ushort* depth);


  unsigned size();

  bool     getReady(){ return m_ready; }

  void     setValue(const int& i, const int& j, const int& k, const float& ampl);
  
  void     averageAmpls();
  
  float    getValue(const int& i, const int& j, const int& k) { return m_ampl[i][j][k]; }

  float    getMaxValue() { return m_vmax; }
  float    getMinValue() { return m_vmin; }

  
  
  bool     saveImage(char *OutMod, U3dBox *image_box = NULL);
  
  virtual bool save(char *OutMod) { UMessage::error("Not allowed here."); return false; }
  
  U3dDataCube* interpData(double* factor);
  void     smData(int* epsilon);
  

  // const float*** getInnerAmpls() { return m_ampl; }

  virtual ~U3dDataCube();
  
protected:
  
  virtual U3dDataCube* clone() { return new U3dDataCube(*this); }  
  
  void clean();
  
  bool m_ready;                       
  ushort m_width;                     
  ushort m_height;                    
  ushort m_depth;                     
  U3dArray3D<float> m_ampl;           
  U3dArray3D<ushort> m_ampl_num;      
  float m_stepX;                      
  float m_stepY;                      
  float m_stepZ;                      
  float m_vmax, m_vmin;

};


#endif // __u3d_data_cube_hpp