mitkCamera.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 __mitkCamera_h
#define __mitkCamera_h

#include "mitkObject.h"
#include "mitkMatrix.h"
#include "mitkVisualizationIncludes.h"

class MITK_VISUALIZATION_API mitkCamera : public mitkObject
{
public:
    MITK_TYPE(mitkCamera,mitkObject)

    virtual void PrintSelf(ostream& os);

    mitkCamera();

    void GetPosition(float &x, float &y, float &z)
    {
        x = m_InverseViewMatrix->ele[12];
        y = m_InverseViewMatrix->ele[13];
        z = m_InverseViewMatrix->ele[14];
    }

    void GetPosition(float a[3])
    {
        a[0] = m_InverseViewMatrix->ele[12];
        a[1] = m_InverseViewMatrix->ele[13];
        a[2] = m_InverseViewMatrix->ele[14];
    }

    void GetFocalPoint(float &x, float &y, float &z)
    {
        x = m_FocalPoint[0];
        y = m_FocalPoint[1];
        z = m_FocalPoint[2];
    }

    void GetFocalPoint(float a[3])
    {
        a[0] = m_FocalPoint[0];
        a[1] = m_FocalPoint[1];
        a[2] = m_FocalPoint[2];     
    }

    float GetThickness()    { return m_Thickness; }

    bool IsParallelProjection() { return m_ParallelProjection; }

    void SetProjectionToParallel() { m_ParallelProjection = true; m_Modified = true; }

    void SetProjectionToPerspective() { m_ParallelProjection = false; m_Modified = true; }

    bool IsModified() { return m_Modified; }    
    
    virtual void LookAt(float eyex, float eyey, float eyez, float centerx, float centery, float centerz, float upx, float upy, float upz);

    virtual void Ortho(float left, float right, float bottom, float top, float zNear, float zFar);

    virtual void Frustum(float left, float right, float bottom, float top, float zNear, float zFar);

    virtual void Perspective(float fovy, float aspect, float zNear, float zFar);    

    void GetViewMatrix(mitkMatrix *m);

    void GetViewMatrix(float m[16]);

    const mitkMatrix* GetViewMatrix() {return m_ViewMatrix;}

    void GetProjectionMatrix(mitkMatrix *m);

    void GetProjectionMatrix(float m[16]);

    const mitkMatrix* GetProjectionMatrix() {return m_ProjectionMatrix;}

    void GetInverseOfProjectionMatrix(mitkMatrix *m);

    void GetInverseOfProjectionMatrix(float m[16]);

    const mitkMatrix* GetInverseOfProjectionMatrix() {return m_InverseProjectionMatrix;}

    void GetInverseOfViewMatrix(mitkMatrix *m);

    void GetInverseOfViewMatrix(float m[16]);

    const mitkMatrix* GetInverseOfViewMatrix() {return m_InverseViewMatrix;}
    
    void WorldToCamera(const float worldPoint[4], float cameraPoint[4]);

    void WorldToView(const float worldPoint[4], float viewPoint[4]);

    void CameraToView(const float cameraPoint[4], float viewPoint[4]);

    void CameraToWorld(const float cameraPoint[4], float worldPoint[4]);

    void ViewToWorld(const float viewPoint[4], float worldPoint[4]);

    void ViewToCamera(const float viewPoint[4], float cameraPoint[4]);  
  
    
protected:  
    virtual ~mitkCamera();

    float m_FocalPoint[3];
    float m_Thickness;

    //Matrix
    mitkMatrix *m_ViewMatrix;
    mitkMatrix *m_ProjectionMatrix; 
    mitkMatrix *m_InverseProjectionMatrix;
    mitkMatrix *m_InverseViewMatrix;

    bool m_ParallelProjection;
    bool m_Modified;

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

};


inline void mitkCamera::WorldToCamera(const float worldPoint[4], float cameraPoint[4])
{
    mitkVector temp(worldPoint);
    temp *= *m_ViewMatrix;
    cameraPoint[0] = temp.ele[0];
    cameraPoint[1] = temp.ele[1];
    cameraPoint[2] = temp.ele[2];
    cameraPoint[3] = temp.ele[3];
}

inline void mitkCamera::WorldToView(const float worldPoint[4], float viewPoint[4])
{
    mitkVector temp(worldPoint);
    temp *= *m_ViewMatrix;
    temp *= *m_ProjectionMatrix;
    viewPoint[0] = temp.ele[0];
    viewPoint[1] = temp.ele[1];
    viewPoint[2] = temp.ele[2];
    viewPoint[3] = temp.ele[3];
    if(!m_ParallelProjection)
    {
        float ftemp = 1.0f / viewPoint[3];
        viewPoint[0] *= ftemp;
        viewPoint[1] *= ftemp;
        viewPoint[2] *= ftemp;
        viewPoint[3] = 1.0f;
    }
}

inline void mitkCamera::CameraToView(const float cameraPoint[4], float viewPoint[4])
{
    mitkVector temp(cameraPoint);
    temp *= *m_ProjectionMatrix;
    viewPoint[0] = temp.ele[0];
    viewPoint[1] = temp.ele[1];
    viewPoint[2] = temp.ele[2];
    viewPoint[3] = temp.ele[3];
    if(!m_ParallelProjection)
    {
        float ftemp = 1.0f / viewPoint[3];
        viewPoint[0] *= ftemp;
        viewPoint[1] *= ftemp;
        viewPoint[2] *= ftemp;
        viewPoint[3] = 1.0f;
    }
}

inline void mitkCamera::CameraToWorld(const float cameraPoint[4], float worldPoint[4])
{
    mitkVector temp(cameraPoint);   
    temp *= *m_InverseViewMatrix;
    worldPoint[0] = temp.ele[0];
    worldPoint[1] = temp.ele[1];
    worldPoint[2] = temp.ele[2];
    worldPoint[3] = temp.ele[3];
}

inline void mitkCamera::ViewToWorld(const float viewPoint[4], float worldPoint[4])
{
    mitkVector temp(viewPoint); 
    temp *= *m_InverseProjectionMatrix;
    if(!m_ParallelProjection)
    {
        float ftemp = 1.0f / temp.ele[3];
        temp.ele[0] *= ftemp;
        temp.ele[1] *= ftemp;
        temp.ele[2] *= ftemp;
        temp.ele[3] = 1.0f;
    }
    temp *= *m_InverseViewMatrix;
    worldPoint[0] = temp.ele[0];
    worldPoint[1] = temp.ele[1];
    worldPoint[2] = temp.ele[2];
    worldPoint[3] = temp.ele[3];
}

inline void mitkCamera::ViewToCamera(const float viewPoint[4], float cameraPoint[4])
{
    mitkVector temp(viewPoint);
    temp *= *m_InverseProjectionMatrix;
    if(!m_ParallelProjection)
    {
        float ftemp = 1.0f / temp.ele[3];
        temp.ele[0] *= ftemp;
        temp.ele[1] *= ftemp;
        temp.ele[2] *= ftemp;
        temp.ele[3] = 1.0f;
    }
    cameraPoint[0] = temp.ele[0];
    cameraPoint[1] = temp.ele[1];
    cameraPoint[2] = temp.ele[2];
    cameraPoint[3] = temp.ele[3];
}


//#define DEFINED_mitkCamera
 


#endif

---