mitkVolume.h

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

  Program:   3DMed
  Date:      $Date: 2014-02-25 18:30:00 +0800 $
  Version:   $Version: 4.6.0 $
  Copyright: MIPG, Institute of Automation, Chinese Academy of Sciences

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


#ifndef __mitkVolume_h
#define __mitkVolume_h

#include "mitkDataObject.h"

class MITK_COMMON_API mitkVolume : public mitkDataObject
{
public:
    MITK_TYPE(mitkVolume, mitkDataObject)

    virtual void PrintSelf(ostream& os);

    mitkVolume();

    virtual void Initialize();

    virtual int GetDataObjectType() const { return MITK_VOLUME; }

    void SetDimensions(int dims[3])
    {
        m_Dimensions[0] = dims[0];
        m_Dimensions[1] = dims[1];
        m_Dimensions[2] = dims[2];
        this->_computeIncrements();
    }

    void GetDimensions(int dims[3]) const 
    {
        dims[0] = m_Dimensions[0];
        dims[1] = m_Dimensions[1];
        dims[2] = m_Dimensions[2];
    }

    void SetWidth(int w) { m_Dimensions[0] = w; this->_computeIncrements(); }

    int GetWidth() const { return m_Dimensions[0]; }

    void SetHeight(int h) { m_Dimensions[1] = h; this->_computeIncrements(); }

    int GetHeight() const { return m_Dimensions[1]; }

    void SetSliceNum(int s) { m_Dimensions[2] = s; }

    void SetImageNum(int s) { this->SetSliceNum(s); }

    int  GetSliceNum() const { return m_Dimensions[2]; }

    int  GetImageNum() const { return this->GetSliceNum(); }

    int  GetDimensionality() const 
    { 
        if (m_Dimensions[2]==1)
        {
            return 2;
        } 
        else
        {
            return 3;
        }
         
    }

    void SetSpacings(float s[3])
    {
        m_Spacings[0] = s[0];
        m_Spacings[1] = s[1];
        m_Spacings[2] = s[2];
    }

    void GetSpacings(float s[3]) const 
    {
        s[0] = m_Spacings[0];
        s[1] = m_Spacings[1];
        s[2] = m_Spacings[2];
    }

    void SetSpacingX(float px) { m_Spacings[0] = px; }

    float GetSpacingX() const { return m_Spacings[0]; }

    void SetSpacingY(float py) { m_Spacings[1] = py; }

    float GetSpacingY() const { return m_Spacings[1]; }

    void SetSpacingZ(float pz) { m_Spacings[2] = pz; }

    float GetSpacingZ() const { return m_Spacings[2]; }

    void SetChannelNum(int n) { m_NumberOfChannel = n; this->_computeIncrements(); }

    void SetNumberOfChannel(int n) { this->SetChannelNum(n); }

    int GetChannelNum() const { return m_NumberOfChannel; }

    int GetNumberOfChannel() const { return this->GetChannelNum(); }

    void GetIncrements(int incs[3]) const
    {
        incs[0] = m_Increments[0];
        incs[1] = m_Increments[1];
        incs[2] = m_Increments[2];
    }

    int GetIncrementX() const { return m_Increments[0]; }

    int GetIncrementY() const { return m_Increments[1]; }

    int GetIncrementZ() const { return m_Increments[2]; }

    double GetData(int x, int y, int z, int c = 0);

    void GetPointGradient(int i, int j, int k, float g[3]);

    double GetDataTypeMin() const { return m_DataTypeMin; }

    double GetDataTypeMax() const { return m_DataTypeMax; }

    void SetWindowWidth(float wWidth) { m_WindowWidth = wWidth; m_HasWidthCenter = true; }    

    void SetWindowCenter(float wCenter) { m_WindowCenter = wCenter; m_HasWidthCenter = true; }    

    float GetWindowWidth();

    float GetWindowCenter(); 

    void  GetWidthCenter(float &wWidth, float &wCenter);

    bool HasWidthCenter() const {return m_HasWidthCenter;}    

    int GetDataTypeSize() const { return m_DataTypeSize; }

    void SetDataType(int data_type);

    int GetDataType() const { return m_DataType; }

    void SetDataTypeToFloat() { this->SetDataType(MITK_FLOAT); }

    void SetDataTypeToDouble() { this->SetDataType(MITK_DOUBLE); }

    void SetDataTypeToInt() { this->SetDataType(MITK_INT); }

    void SetDataTypeToUnsignedInt() { this->SetDataType(MITK_UNSIGNED_INT); }

    void SetDataTypeToLong() { this->SetDataType(MITK_LONG); }

    void SetDataTypeToUnsignedLong() { this->SetDataType(MITK_UNSIGNED_LONG); }

    void SetDataTypeToShort() { this->SetDataType(MITK_SHORT); }

    void SetDataTypeToUnsignedShort() { this->SetDataType(MITK_UNSIGNED_SHORT); }

    void SetDataTypeToUnsignedChar() { this->SetDataType(MITK_UNSIGNED_CHAR); }

    void SetDataTypeToChar() { this->SetDataType(MITK_CHAR); }

    void GetMinMaxValue(int sliceIdx, double &minValue, double &maxValue, bool needRecalculate = false);

    void GetMinMaxValue(double &minValue, double &maxValue, bool needRecalculate = false);
    
    virtual void ShallowCopy(mitkDataObject *src);

    virtual void DeepCopy(mitkDataObject *src);

    virtual void FreezeSlice(int sliceIdx) {}

    virtual void UnFreezeSlice(int sliceIdx) {}

    virtual void const* GetData() const = 0;

    virtual void* GetData() = 0;

    void* GetSliceData(int sliceIdx) { return this->GetSliceForReadWrite(sliceIdx); }

    virtual void const* GetSliceForRead(int sliceIdx) = 0;

    virtual void* GetSliceForWrite(int sliceIdx) = 0;

    virtual void* GetSliceForReadWrite(int sliceIdx) = 0;

    virtual bool ReadSliceData(int sliceIdx, void *dst) = 0;

    virtual bool ReadYZSliceData(int xIdx, void *dst) = 0;

    virtual bool ReadXZSliceData(int yIdx, void *dst) = 0;

    virtual bool GetArbitrarySlice(int w, int h, double o[3], double ux[3], double uy[3], void *dst) = 0;

    virtual bool WriteSliceData(int sliceIdx, void const *src) = 0;

    virtual bool ReadSubVolume(int x, int y, int z, int w, int h, int d, int &tw, int &th, int &td, void *dst) = 0;

    virtual bool ReadSubVolume(int x, int y, int z, int w, int h, int d,
        int dstx, int dsty, int dstz, int dstw, int dsth, int dstd,
        void *dst, bool zeropad=true) = 0;

    virtual bool ReadSubVolume(int x, int y, int z, int w, int h, int d, void *dst, bool zeropad=true) = 0;

    virtual bool WriteSubVolume(int x, int y, int z, int w, int h, int d, int &tw, int &th, int &td, void const *src) = 0;

    virtual bool Allocate() = 0;

    virtual void PrepareSlicesForRead(int startSliceIdx,int sliceNum=1,bool freeze=false){};
    virtual void PrepareSlicesForWrite(int startSliceIdx,int sliceNum=1,bool freeze=false){};

protected:
    virtual ~mitkVolume();    
    void _computeIncrements();
    void _clearMinMaxCache();

    int   m_Dimensions[3];
    int   m_Increments[3];
    float m_Spacings[3];

    int   m_DataType;
    int   m_NumberOfChannel;

    float m_WindowWidth;
    float m_WindowCenter;
    bool  m_HasWidthCenter;
    bool  m_IsFirstWidthCenter;

    double *m_MinArray;
    double *m_MaxArray;
    unsigned char *m_MinMaxFlags;

    int m_DataTypeSize;
    double m_DataTypeMin;
    double m_DataTypeMax;

    //void  *m_Data;

private:
    mitkVolume(const mitkVolume&);
    void operator=(const mitkVolume&);

};

//#define DEFINED_mitkVolume



#endif

---