camera.h

Go to the documentation of this file.

/****************************************************************************

 Copyright (C) 2002-2013 Gilles Debunne. All rights reserved.

 This file is part of the QGLViewer library version 2.4.0.

 http://www.libqglviewer.com - contact@libqglviewer.com

 This file may be used under the terms of the GNU General Public License 
 versions 2.0 or 3.0 as published by the Free Software Foundation and
 appearing in the LICENSE file included in the packaging of this file.
 In addition, as a special exception, Gilles Debunne gives you certain 
 additional rights, described in the file GPL_EXCEPTION in this package.

 libQGLViewer uses dual licensing. Commercial/proprietary software must
 purchase a libQGLViewer Commercial License.

 This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.

*****************************************************************************/

#ifndef QGLVIEWER_CAMERA_H
#define QGLVIEWER_CAMERA_H

#include "manipulatedCameraFrame.h"
#include "keyFrameInterpolator.h"

namespace qglviewer {
  class QGLVIEWER_EXPORT Camera : public QObject
  {
#ifndef DOXYGEN
    friend class ::QGLViewer;
#endif

    Q_OBJECT

  public:
    Camera();
    virtual ~Camera();

    Camera(const Camera& camera);
    Camera& operator=(const Camera& camera);


    enum Type { PERSPECTIVE, ORTHOGRAPHIC };

  public:
    Vec position() const { return frame()->position(); };

    Vec upVector() const
    {
      return frame()->inverseTransformOf(Vec(0.0, 1.0, 0.0));
    }
    Vec viewDirection() const { return frame()->inverseTransformOf(Vec(0.0, 0.0, -1.0)); };

    Vec rightVector() const
    {
      return frame()->inverseTransformOf(Vec(1.0, 0.0, 0.0));
    }

    Quaternion orientation() const { return frame()->orientation(); };

    void setFromModelViewMatrix(const GLdouble* const modelViewMatrix);
    void setFromProjectionMatrix(const float matrix[12]);

  public Q_SLOTS:
    void setPosition(const Vec& pos) { frame()->setPosition(pos); };
    void setOrientation(const Quaternion& q);
    void setOrientation(float theta, float phi);
    void setUpVector(const Vec& up, bool noMove=true);
    void setViewDirection(const Vec& direction);


  public Q_SLOTS:
    void lookAt(const Vec& target);
    void showEntireScene();
    void fitSphere(const Vec& center, float radius);
    void fitBoundingBox(const Vec& min, const Vec& max);
    void fitScreenRegion(const QRect& rectangle);
    void centerScene();
    void interpolateToZoomOnPixel(const QPoint& pixel);
    void interpolateToFitScene();
    void interpolateTo(const Frame& fr, float duration);


  public:
    Type type() const { return type_; };

    float fieldOfView() const { return fieldOfView_; };

    float horizontalFieldOfView() const { return 2.0 * atan ( tan(fieldOfView()/2.0) * aspectRatio() ); };

    float aspectRatio() const { return static_cast<float>(screenWidth_)/static_cast<float>(screenHeight_); };
    int screenWidth() const { return screenWidth_; };
    int screenHeight() const { return screenHeight_; };
    void getViewport(GLint viewport[4]) const;
    float pixelGLRatio(const Vec& position) const;

    float zNearCoefficient() const { return zNearCoef_; };
    float zClippingCoefficient() const { return zClippingCoef_; }

    virtual float zNear() const;
    virtual float zFar()  const;
    virtual void getOrthoWidthHeight(GLdouble& halfWidth, GLdouble& halfHeight) const;
    void getFrustumPlanesCoefficients(GLdouble coef[6][4]) const;

  public Q_SLOTS:
    void setType(Type type);

    void setFieldOfView(float fov) { fieldOfView_ = fov; setFocusDistance(sceneRadius() / tan(fov/2.0)); };

    void setHorizontalFieldOfView(float hfov) { setFieldOfView( 2.0 * atan (tan(hfov / 2.0) / aspectRatio()) ); };

    void setFOVToFitScene();

    void setAspectRatio(float aspect) { setScreenWidthAndHeight(int(100.0*aspect), 100); };

    void setScreenWidthAndHeight(int width, int height);
    void setZNearCoefficient(float coef) { zNearCoef_ = coef; };
    void setZClippingCoefficient(float coef) { zClippingCoef_ = coef; }


  public:
    float sceneRadius() const { return sceneRadius_; };

    Vec sceneCenter() const { return sceneCenter_; };
    float distanceToSceneCenter() const;

  public Q_SLOTS:
    void setSceneRadius(float radius);
    void setSceneCenter(const Vec& center);
    bool setSceneCenterFromPixel(const QPoint& pixel);
    void setSceneBoundingBox(const Vec& min, const Vec& max);


 public Q_SLOTS:
    void setRevolveAroundPoint(const Vec& rap);
    bool setRevolveAroundPointFromPixel(const QPoint& pixel);

  public:
    Vec revolveAroundPoint() const { return frame()->revolveAroundPoint(); };


  public:
    ManipulatedCameraFrame* frame() const { return frame_; };
  public Q_SLOTS:
    void setFrame(ManipulatedCameraFrame* const mcf);


   public:
    KeyFrameInterpolator* keyFrameInterpolator(int i) const;

public Q_SLOTS:
    void setKeyFrameInterpolator(int i, KeyFrameInterpolator* const kfi);

    virtual void addKeyFrameToPath(int i);
    virtual void playPath(int i);
    virtual void deletePath(int i);
    virtual void resetPath(int i);
    virtual void drawAllPaths();


  public:
    virtual void loadProjectionMatrix(bool reset=true) const;
    virtual void loadModelViewMatrix(bool reset=true) const;
    void computeProjectionMatrix() const;
    void computeModelViewMatrix() const;

    virtual void loadProjectionMatrixStereo(bool leftBuffer=true) const;
    virtual void loadModelViewMatrixStereo(bool leftBuffer=true) const;

    void getProjectionMatrix(GLdouble m[16]) const;
    void getModelViewMatrix(GLdouble m[16]) const;
        void getModelViewProjectionMatrix(GLdouble m[16]) const;

#ifndef DOXYGEN
    // Required for windows which otherwise silently fills
    void getProjectionMatrix(GLfloat m[16]) const;
    void getModelViewMatrix(GLfloat m[16]) const;
#endif


    
#ifndef DOXYGEN
    static void drawCamera(float scale=1.0, float aspectRatio=1.33, float fieldOfView=M_PI/4.0);
#endif
    virtual void draw(bool drawFarPlane=true, float scale=1.0) const;

    
  public:
    Vec cameraCoordinatesOf(const Vec& src) const { return frame()->coordinatesOf(src); };
    Vec worldCoordinatesOf(const Vec& src) const { return frame()->inverseCoordinatesOf(src); };
    void getCameraCoordinatesOf(const float src[3], float res[3]) const;
    void getWorldCoordinatesOf(const float src[3], float res[3]) const;


  public:
    Vec projectedCoordinatesOf(const Vec& src, const Frame* frame=NULL) const;
    Vec unprojectedCoordinatesOf(const Vec& src, const Frame* frame=NULL) const;
    void getProjectedCoordinatesOf(const float src[3], float res[3], const Frame* frame=NULL) const;
    void getUnprojectedCoordinatesOf(const float src[3], float res[3], const Frame* frame=NULL) const;
    void convertClickToLine(const QPoint& pixel, Vec& orig, Vec& dir) const;
    Vec pointUnderPixel(const QPoint& pixel, bool& found) const;


  public:
    float flySpeed() const { return frame()->flySpeed(); };
  public Q_SLOTS:
    void setFlySpeed(float speed) { frame()->setFlySpeed(speed); };


  public:
    float IODistance() const { return IODistance_; };

    float physicalDistanceToScreen() const { return physicalScreenWidth() / 2.0f / tan(horizontalFieldOfView() / 2.0); };

    float physicalScreenWidth() const { return physicalScreenWidth_; };

    float focusDistance() const { return focusDistance_; };
  public Q_SLOTS:
    void setIODistance(float distance) { IODistance_ = distance; };

#ifndef DOXYGEN

        void setPhysicalDistanceToScreen(float distance) { Q_UNUSED(distance); qWarning("setPhysicalDistanceToScreen is deprecated, use setPhysicalScreenWidth instead"); };
#endif

    void setPhysicalScreenWidth(float width) { physicalScreenWidth_ = width; };

    void setFocusDistance(float distance) { focusDistance_ = distance; };


  public:
    virtual QDomElement domElement(const QString& name, QDomDocument& document) const;
  public Q_SLOTS:
    virtual void initFromDOMElement(const QDomElement& element);


  private:
    // F r a m e
    ManipulatedCameraFrame* frame_;

    // C a m e r a   p a r a m e t e r s
    int screenWidth_, screenHeight_;  // size of the window, in pixels
    float fieldOfView_; // in radians
    Vec sceneCenter_;
    float sceneRadius_; // OpenGL units
    float zNearCoef_;
    float zClippingCoef_;
    float orthoCoef_;
    Type type_; // PERSPECTIVE or ORTHOGRAPHIC
    mutable GLdouble modelViewMatrix_[16]; // Buffered model view matrix.
    mutable GLdouble projectionMatrix_[16]; // Buffered projection matrix.

    // S t e r e o   p a r a m e t e r s
    float IODistance_;               // inter-ocular distance, in meters
    float focusDistance_;            // in scene units
    float physicalScreenWidth_;      // in meters

    // P o i n t s   o f   V i e w s   a n d   K e y F r a m e s
    QMap<int, KeyFrameInterpolator*> kfi_;
    KeyFrameInterpolator* interpolationKfi_;
  };

} // namespace qglviewer

#endif // QGLVIEWER_CAMERA_H