mitkTrackedBscanData.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 __mitkTrackedBscanData_h
#define __mitkTrackedBscanData_h

#include "mitkRawData.h"
#include "mitkVolume.h"
#include "mitkMatrix.h"


class MITK_RECONSTRUCTION_API mitkTrackedBscanData : public mitkRawData
{
public:
    MITK_TYPE(mitkTrackedBscanData, mitkRawData)

    virtual void PrintSelf(ostream &os);


    virtual void Initialize();

    virtual int GetDataObjectType() const { return MITK_TRACKED_BSCAN_DATA; }

    void SetImageWidth(int w){m_SliceSize[0]=w;}

    int GetImageWidth(){return m_SliceSize[0];}

    void SetImageHeight(int h){m_SliceSize[1]=h;}

    int GetImageHeight(){return m_SliceSize[1];}

    void SetNumberOfSlices(int s);

    int  GetNumberOfSlices(){return m_SliceSize[2];}

    void GetVolumeDimensions(int dims[3])
    {
        dims[0] = m_VolumeSize[0];
        dims[1] = m_VolumeSize[1];
        dims[2] = m_VolumeSize[2];
    }

    void SetVolumeDimensions(int dims[3])
    {
        m_VolumeSize[0] = dims[0];
        m_VolumeSize[1] = dims[1];
        m_VolumeSize[2] = dims[2];
    }

    void GetPixelSpacings(float s[3])
    {
        s[0] = m_PixelSpacings[0];
        s[1] = m_PixelSpacings[1];
        s[2] = m_PixelSpacings[2];
    }

    void SetPixelSpacings(float s[3])
    {
        m_PixelSpacings[0] = s[0];
        m_PixelSpacings[1] = s[1];
        m_PixelSpacings[2] = s[2];
    }


    void GetVoxelSpacings(float s[3])
    {
        s[0] = m_VoxelSpacings[0];
        s[1] = m_VoxelSpacings[1];
        s[2] = m_VoxelSpacings[2];
    }

    void SetVoxelSpacings(float s[3])
    {
        m_VoxelSpacings[0] = s[0];
        m_VoxelSpacings[1] = s[1];
        m_VoxelSpacings[2] = s[2];
    }

    void SetNumberOfChannel(int n){m_NumberOfChannel=n;}

    int GetNumberOfChannel(){return m_NumberOfChannel;}

    virtual void* GetData()=0;

    virtual void* GetSliceData(int sliceIdx)=0;

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

    bool SetRToTMatrix(int sliceIdx, mitkMatrix const *ptor);

    mitkMatrix * GetRToTMatrix(int sliceIdx);

    mitkMatrix * GetRToTMatrix();

    virtual bool Allocate()=0;

    virtual unsigned long long GetActualMemorySize() const=0;

    virtual void ShallowCopy(mitkDataObject *src)=0;

    virtual void DeepCopy(mitkDataObject *src)=0;

    void SetPToRMatrix(mitkMatrix const *ptor) { m_PToR = *ptor; }

    mitkMatrix GetPToRMatrix() { return m_PToR; }

    void SetTToCMatrix(mitkMatrix const *ttoc) { m_TToC = *ttoc; }

    mitkMatrix GetTToCMatrix() { return m_TToC; }

    void SetPredetermined(bool predet) { m_IsPredetermined = predet; }

    bool IsPredetermined() { return m_IsPredetermined; }


protected:
    virtual ~mitkTrackedBscanData();
    mitkTrackedBscanData();


//  mitkVolume *m_Slices;

    // Pointing to the entry address of a group of RToT matrices attached to the slices.
    mitkMatrix *m_Matrices;

    // Calibrated transformation matrix from the B-Scan Plane coordinate system to the 
    // Receiver coordinate system.
    mitkMatrix m_PToR;

    // Predetermined transformation matrix from the Transmitter coordinate system to the 
    // Reconstruction Volume coordinate system.
    mitkMatrix m_TToC;

    int  m_NumberOfChannel;
    int  m_SliceSize[3];
    float m_PixelSpacings[3];

    // Predetermined volume size and voxel size (spacings) of the reconstruction volume.
    int m_VolumeSize[3];
    float m_VoxelSpacings[3];

    // If the m_TToC, volume size and voxel size (spacings) are predetermined, 
    // this flag is true.
    bool m_IsPredetermined;

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

};


//#define DEFINED_mitkTrackedBscanData



#endif

---