mitkView.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 __mitkView_h
#define __mitkView_h

#include "mitkGLWindow.h"
#include "mitkScene.h"

class MITK_VISUALIZATION_API mitkView : public  mitkObject
{
public:
    MITK_TYPE(mitkView, mitkObject)
        
    virtual void PrintSelf(ostream& os);
    
    mitkView(); 
    
    void* GetWindowId() { return m_Window->GetWindowId();}
    
    void* GetParent() {return m_Window->GetParent();}
    
    void* GetApplicationId() {return m_Window->GetApplicationId();}
    
    void* GetDeviceContext() {return m_Window->GetDeviceContext();}
    
    void* GetRenderContext() {return m_Window->GetRenderContext();}
    
    void SetParent(void *parentId) { m_Window->SetParent(parentId);}
    
    const int *GetPosition() {return m_Window->GetPosition();}
    
    int GetLeft() {return m_Window->GetLeft();}
    
    int GetTop() {return m_Window->GetTop();}
    
    void SetPosition(int leftPos,int topPos) { m_Window->SetPosition(leftPos,topPos);}
    
    void SetPosition(int a[2]) { m_Window->SetPosition(a);}
    
    void SetLeft(int leftPos) { m_Window->SetLeft(leftPos); }
    
    void SetTop(int topPos) { m_Window->SetTop(topPos); }
    
    int GetTitleBar() { return m_Window->GetTitleBar(); }
    
    void SetTitleBar(int titleBar) { m_Window->SetTitleBar(titleBar);}
    
    void SetTitleBarOn() { m_Window->SetTitleBarOn();}
    
    void SetTitleBarOff() { m_Window->SetTitleBarOff();}
    
    const int *GetSize() { return m_Window->GetSize();}
    
    int GetWidth() { return m_Window->GetWidth();}
    
    int GetHeight() { return m_Window->GetHeight();}
    
    void SetSize(int widthSize, int heightSize) { m_Window->SetSize(widthSize,heightSize); }
    
    void SetSize(int a[2]) { m_Window->SetSize(a); }
    
    void SetWidth(int widthSize) { m_Window->SetWidth(widthSize); }
    
    void SetHeight(int heightSize) { m_Window->SetHeight(heightSize); }
    
    const int * GetViewPort() { return m_Scene->GetViewPort(); }
    
    void GetViewPort(int vp[4]) { m_Scene->GetViewPort(vp);}
        
    const char *GetWindowName() { return m_Window->GetWindowName(); }
    
    void SetWindowName(const char * winName) {m_Window->SetWindowName(winName); }
    
    void Show() {  m_Window->Show(); }
    
    void Hide() {  m_Window->Show(); }
    
    void Update() { m_Window->Update(); }
    
    void MakeCurrent() { m_Window->MakeCurrent(); }
    
    void SwapBuffers() { m_Window->SwapBuffers(); }
    
    void SetBackColor(unsigned char rColor, unsigned char gColor, unsigned char bColor)
    {
        m_Scene->SetBackColor(rColor,gColor,bColor);
    }   
    void SetBackColor(float rColor, float gColor, float bColor)
    {
        m_Scene->SetBackColor(rColor,gColor,bColor);
    }   
    void SetBackColor(int rColor, int gColor, int bColor)
    {
        m_Scene->SetBackColor(rColor,gColor,bColor);
    }   
    void GetBackColor(float &rColor, float &gColor, float &bColor)
    {
        m_Scene->GetBackColor(rColor,gColor,bColor);
    }
    void GetBackColor(unsigned char &rColor, unsigned char &gColor, unsigned char &bColor)
    {
        m_Scene->GetBackColor(rColor,gColor,bColor);
    }   
    void GetBackColor(int &rColor, int &gColor, int &bColor)
    {
        m_Scene->GetBackColor(rColor,gColor,bColor);
    }   
    void ResetScene()
    {
        m_Scene->ResetScene();
    }   
    void Translate(float deltX, float deltY, float deltZ)
    {
        m_Scene->Translate(deltX,deltY,deltZ);
    }   
    void Rotate(float deltX, float deltY, float deltZ)
    {
        m_Scene->Rotate(deltX,deltY,deltZ);
    }   
    void Rotate(float ax, float ay, float az, float angle)
    {
        m_Scene->Rotate(ax,ay,az,angle);
    }   
    void Rotate(const mitkQuaternion &q)
    {
        m_Scene->Rotate(q);
    }   
    void SetRotation(float x, float y, float z)
    {
        m_Scene->SetRotation(x,y,z);
    }
    
    void SetRotation(float ax, float ay, float az, float angle)
    {
        m_Scene->SetRotation(ax,ay,az,angle);
    }   
    void SetRotation(const mitkQuaternion &q)
    {
        m_Scene->SetRotation(q);
    }   
    void Scale(float delt)
    {
        m_Scene->Scale(delt);
    }
    
    mitkManipulator* CreateManipulator();
    
    void SetManipulator(mitkManipulator *mani);
    
    void AddModel(mitkModel *model) { m_Scene->AddModel(model);}
    
    void RemoveModel(mitkModel *model) {m_Scene->RemoveModel(model);}
    
    void RemoveModel(int i) { m_Scene->RemoveModel(i);}
    
    void RemoveAllModels() { m_Scene->RemoveAllModels();}
    
    void RemoveAllModel() { this->RemoveAllModels(); }
    
    mitkModel* GetModel(int i) { return m_Scene->GetModel(i);}
    
    mitkList*  GetModels() { return m_Scene->GetModels();}
    
    int GetModelCount() { return m_Scene->GetModelCount();}
    
    int GetNumberOfPropsRendered() { return m_Scene->GetNumberOfPropsRendered();}
    
    void SetCamera(mitkCamera *cam) { m_Scene->SetCamera(cam);}
    
    mitkCamera* GetCamera() { return m_Scene->GetCamera();}
    
    void SetDefaultLight(mitkLight *lit) { m_Scene->SetDefaultLight(lit);}
    
    mitkLight* GetDefaultLight() { return m_Scene->GetDefaultLight();}
    
    mitkLight* GetLight() { return this->GetDefaultLight(); }
    
    void AddAdditionalLight(mitkLight *lit) { m_Scene->AddAdditionalLight(lit);}
    
    void RemoveAdditionalLight(int idx) { m_Scene->RemoveAdditionalLight(idx);}
    
    void RemoveAdditionalLight(mitkLight *lit) { m_Scene->RemoveAdditionalLight(lit);}
    
    void RemoveAllAdditionalLights() { m_Scene->RemoveAllAdditionalLights();}
    
    int GetAdditionalLightCount() { return m_Scene->GetAdditionalLightCount();}
    
    mitkLight* GetAdditionalLight(int idx) { return m_Scene->GetAdditionalLight(idx);}
    
    void AlignScene() { m_Scene->AlignScene();}
    
    float* GetZbufferData(int x1, int y1, int x2, int y2) 
    { 
        return m_Scene->GetZbufferData(x1,y1,x2,y2);
    }
    
    void GetZbufferData(int x1, int y1, int x2, int y2, float *buffer) 
    { 
        m_Scene->GetZbufferData(x1,y1,x2,y2,buffer);
    }
    
    unsigned char* GetPixelData(int xOffset, int yOffset, int width, int height)
    {
        return m_Scene->GetPixelData(xOffset,yOffset,width,height);
    }
    
    void GetPixelData(int xOffset, int yOffset, int width, int height, unsigned char *buffer, int packAlignment = 4, bool swapRGB = false)
    { this->GetPixelData24(xOffset, yOffset, width, height, buffer, packAlignment, swapRGB); }
    
    void GetPixelData24(int xOffset, int yOffset, int width, int height, unsigned char *buffer, int packAlignment = 4, bool swapRGB = false)
    {
        m_Scene->GetPixelData24(xOffset,yOffset,width,height,buffer,packAlignment,swapRGB);
    }
    
    void GetPixelData32(int xOffset, int yOffset, int width, int height, unsigned char *buffer, bool swapRGB = false)
    {
        m_Scene->GetPixelData32(xOffset,yOffset,width,height,buffer,swapRGB);
    }
    
    void  SetSelected(bool isSelected) 
    {
        m_Scene->SetSelected(isSelected);
    }
    
    bool  GetSelected() { return m_Scene->GetSelected();}
    
    float GetTranslateSpeed() { return m_Scene->GetTranslateSpeed();}
    
    float GetTranslationX()    { return m_Scene->GetTranslationX();}
    
    float GetTranslationY()    { return m_Scene->GetTranslationY(); }
    
    float GetTranslationZ()    { return m_Scene->GetTranslationZ(); }
    
    void   GetTranslation(float trans[3]) 
    {
        m_Scene->GetTranslation(trans);
    }
    
    const mitkQuaternion& GetRotation() { return m_Scene->GetRotation(); }
    
    float GetScale() { return m_Scene->GetScale(); }
    
    bool HasUnprocessedMouseMessage() { return m_Window->HasUnprocessedMouseMessage(); }
    
    void EnableLoD() { m_Scene->EnableLoD();}
    
    void DisableLoD() { m_Scene->DisableLoD();}
    
    bool IsLoDEnabled() { return m_Scene->IsLoDEnabled();}
    
    double GetFrameSpeed() { return m_Window->GetFrameSpeed(); }

    double GetRenderTime() { return m_Window->GetRenderTime(); }
    
    void EnableCalculateFrameSpeed() { m_Window->EnableCalculateFrameSpeed(); }
        
    void DisableCalculateFrameSpeed() { m_Window->DisableCalculateFrameSpeed(); }
    
    bool IsModelsModified() 
    {
        return m_Scene->IsModelsModified();
    }

    bool IsCameraModified()
    {
        return m_Scene->IsCameraModified();
    }

    bool IsAdditionalLightModified()
    {
        return m_Scene->IsAdditionalLightModified();
    }

    mitkScene* GetScene() {return m_Scene;}

protected:
    virtual ~mitkView();

    mitkRCPtr<mitkGLWindow> m_Window;   
    mitkScene* m_Scene;
    
private:
    mitkView(const mitkView&);
    void operator=(const mitkView&);
};

 
//#define DEFINED_mitkView
 


#endif

---