mitkCoherentVolume.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 __mitkCoherentVolume_h
#define __mitkCoherentVolume_h

#include "mitkDataObject.h"
#include "mitkVisualization2Includes.h"

class mitkICVolume;


class MITK_VISUALIZATION2_API mitkCoherentVolume : public mitkDataObject
{
public:
    class BlockArray;

    MITK_TYPE(mitkCoherentVolume,mitkDataObject)
    mitkCoherentVolume();

    virtual void Initialize();

    virtual int GetDataObjectType() const {return MITK_COHERENT_VOLUME;}

    virtual unsigned long long GetActualMemorySize() const;

    virtual void ShallowCopy(mitkDataObject *src){}
    virtual void DeepCopy(mitkDataObject *src){}

    void SetBlockSize(const int bs[3])
    {
        m_BlockSize[0]=bs[0];
        m_BlockSize[1]=bs[1];
        m_BlockSize[2]=bs[2];
    }
    void GetBlcokSize(int bs[3])
    {
        bs[0]=m_BlockSize[0];
        bs[1]=m_BlockSize[1];
        bs[2]=m_BlockSize[2];
    }

    void SetDimensions(const int dims[3])
    {
        m_Dimensions[0] = dims[0];
        m_Dimensions[1] = dims[1];
        m_Dimensions[2] = dims[2];
        m_BlockNum[0]= (m_Dimensions[0]-1)/m_BlockSize[0]+1;
        m_BlockNum[1]= (m_Dimensions[1]-1)/m_BlockSize[1]+1;
        m_BlockNum[2]= (m_Dimensions[2]-1)/m_BlockSize[2]+1;
    }

    void GetDimensions(int dims[3]) const 
    {
        dims[0] = m_Dimensions[0];
        dims[1] = m_Dimensions[1];
        dims[2] = m_Dimensions[2];
    }
    void SetSpacings(const 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 GetBlockNum(int bn[3]) 
    {
        bn[0]=m_BlockNum[0];
        bn[1]=m_BlockNum[1];
        bn[2]=m_BlockNum[2];
    }

    int GetDataTypeSize() const { return m_DataTypeSize; }

    void SetDataType(int data_type);

    int GetDataType() const { return m_DataType; }

    void AllocateBlocks();

    void SetBlockSlice(void *sliceData,int sliceID,int dimz=-1);

    void SetData(void *data);

    void SetICVolume(mitkICVolume *icv);

    float GetValue(int x,int y,int z);

    void GetMinMaxValue(double &minValue,double &maxValue);

protected:
    virtual ~mitkCoherentVolume();

private:
    mitkCoherentVolume(const mitkCoherentVolume&);
    void operator = (const mitkCoherentVolume&);
    
    BlockArray *m_BlockArray;

    int m_BlockSize[3];
    int m_Dimensions[3];
    float m_Spacings[3];
    int m_BlockNum[3];
    int m_DataType;

    int m_DataTypeSize;
    double m_DataTypeMin;
    double m_DataTypeMax;
};

#endif

---