mitkImageModel.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 __mitkImageModel_h
#define __mitkImageModel_h

#include "mitkDataModel.h"
#include "mitkRCPtr.h"
#include "mitkICVolume.h"

class MITK_VISUALIZATION_API mitkImageModel : public mitkDataModel
{
public:
    MITK_TYPE(mitkImageModel,mitkDataModel)
        
    virtual void PrintSelf(ostream& os);
    
    mitkImageModel();   

    enum ViewMode
    {
        VIEW_XY, 
        VIEW_YZ, 
        VIEW_XZ  
    };

    void SetData(mitkVolume *data);

    mitkVolume* GetData();

    virtual int Render(mitkScene *scene);
  
    void SetViewMode(ViewMode viewMode);

    ViewMode GetViewMode() const { return m_ViewMode; }
    
    void SetCurrentSliceNumber(int sliceNo);

    int GetCurrentSliceNumber() const { return m_CurrentSlice; }

    void NextSlice();

    void PrevSlice();

    int GetTotalSliceNumber() const { return m_TotalSlice; }

    int GetWidth() const { return m_TexImageWidth; }

    int GetHeight() const { return m_TexImageHeight; }

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

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

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

    void SetOpacity(float opacity) { m_Opacity = opacity; }

    float GetOpacity() const { return m_Opacity; }

    virtual bool IsOpaque() { return (m_Opacity >= 1.0f); }

    void CleanUp();

    void AdjustWidthCenter(int viewWidth, int viewHeight, float deltX, float deltY);

    float GetWindowWidth() const { return m_WindowWidth; }

    float GetWindowCenter() const { return m_WindowCenter; }

    void SetWindowWidth(float winWidth);

    void SetWindowCenter(float winCenter);

    void ResetWindowWidthCenter();

    void GetDataValueAndCoordinate(float objectX, float objectY, int &vx, int &vy, int &vz, float &rValue, float &gValue, float &bValue) const;

    void GetCoordinate(float objectX, float objectY, int &vx, int &vy, int &vz) const;

    void GetXYCoordinate(float objectX, float objectY, int &vx, int &vy) const;

    void GetXYCoordinate(float objectX, float objectY, float &vx, float &vy) const;

    void GetXYCoordinateDelta(float odx, float ody, float &vdx, float &vdy) const;

    void GetObjectCoordinate(int vx, int vy, float &objX, float &objY);

    void GetObjectCoordinate(int vx, int vy, int vz, float &objX, float &objY);

    float GetActualLength(float opt0[2], float opt1[2]) const;

    float GetActualLength(float x0, float y0, float x1, float y1) const;

    float GetActualXLength(float objXLen) const;

    float GetActualYLength(float objYLen) const;

    unsigned int GetTextureID() const { return m_TexId; }

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

    mitkVolume* GetCurrentSlice();

    void EnablePseudocolor(bool enable = true) { m_EnablePseudocolor = enable; }

    void UpdatePseudocolor(bool rectChanged);

    void SetSliceChanged() { m_CurrentTex = -1; }


protected:
    virtual ~mitkImageModel();
    virtual float* _getBounds();

    mitkRCPtr<mitkVolume> m_Data;

    float m_Opacity;
    ViewMode m_ViewMode;
    unsigned int m_TexId;
    int   m_TexImageWidth, m_TexImageHeight;
    float m_RectLeft, m_RectRight;
    float m_RectTop,  m_RectBottom;

    int  m_CurrentSlice;
    int  m_TotalSlice;

    int  m_CurrentTex;

    float m_Spacings[3];
    int   m_Incs[3];

    int   m_DummyTexWidth;
    int   m_DummyTexHeight;

    float m_WindowCenter;   
    float m_WindowWidth;
    float m_DefaultWindowCenter;    
    float m_DefaultWindowWidth;

    bool  m_NeedSetDummyTexture;
    bool  m_EnablePseudocolor;

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


    bool _loadTexture();    
    void _switchViewMode();
    void _setDummyTexture();
};

inline void mitkImageModel::GetCoordinate(float objectX, float objectY, int &vx, int &vy, int &vz) const
{
//  float volumeX = (objectX - m_RectLeft) * (m_TexImageWidth - 1.0f) / (m_RectRight - m_RectLeft);
//  float volumeY = (objectY - m_RectBottom) * (m_TexImageHeight - 1.0f) / (m_RectTop - m_RectBottom);
    float volumeX = (objectX - m_RectLeft) * (m_TexImageWidth) / (m_RectRight - m_RectLeft);
    float volumeY = (objectY - m_RectBottom) * (m_TexImageHeight) / (m_RectTop - m_RectBottom);

    switch(m_ViewMode)
    {
        case VIEW_XY:
            vx = (int) (volumeX + 0.5f);
            vy = (int) (volumeY + 0.5f);
            vz = m_CurrentSlice;            
        break;

        case VIEW_YZ:
            vx = m_CurrentSlice;
            vy = (int) (volumeX + 0.5f);                
            vz = (int) (volumeY + 0.5f);                    
        break;

        case VIEW_XZ:
            vx = (int) (volumeX + 0.5f);
            vy = m_CurrentSlice;                
            vz = (int) (volumeY + 0.5f);                    
        break;
    }
}

inline void mitkImageModel::GetXYCoordinate(float objectX, float objectY, int &vx, int &vy) const
{
    vx = (int)((objectX - m_RectLeft) * m_TexImageWidth / (m_RectRight - m_RectLeft) + 0.5);
    vy = (int)((objectY - m_RectBottom) * m_TexImageHeight / (m_RectTop - m_RectBottom) + 0.5);
}

inline void mitkImageModel::GetXYCoordinate(float objectX, float objectY, float &vx, float &vy) const
{
    vx = (objectX - m_RectLeft) * (float)m_TexImageWidth / (m_RectRight - m_RectLeft);
    vy = (objectY - m_RectBottom) * (float)m_TexImageHeight / (m_RectTop - m_RectBottom);
}

inline void mitkImageModel::GetXYCoordinateDelta(float odx, float ody, float &vdx, float &vdy) const
{
    vdx = this->GetActualXLength(odx);
    vdy = this->GetActualYLength(ody);
}

inline float mitkImageModel::GetActualXLength(float objXLen) const
{
    return (objXLen * (float)m_TexImageWidth / (m_RectRight - m_RectLeft));
}

inline float mitkImageModel::GetActualYLength(float objYLen) const
{
    return (objYLen * (float)m_TexImageHeight / (m_RectBottom - m_RectTop));
}

inline float mitkImageModel::GetActualLength(float x0, float y0, float x1, float y1) const
{
    float xlen = this->GetActualXLength(x1-x0);
    float ylen = this->GetActualYLength(y1-y0);
    return (sqrtf(xlen*xlen + ylen*ylen));
}

inline float mitkImageModel::GetActualLength(float opt0[2], float opt1[2]) const
{
    return this->GetActualLength(opt0[0], opt0[1], opt1[0], opt1[1]);
}

 
//#define DEFINED_mitkImageModel
 


#endif

---