camera.h

Go to the documentation of this file.

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

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

 This file is part of the QGLViewer library version 2.6.3.

 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 "keyFrameInterpolator.h"
class QGLViewer;

namespace qglviewer {

class ManipulatedCameraFrame;

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;
        Vec upVector() const;
        Vec viewDirection() const;
        Vec rightVector() const;
        Quaternion orientation() const;

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

public Q_SLOTS:
        void setPosition(const Vec& pos);
        void setOrientation(const Quaternion& q);
        void setOrientation(qreal theta, qreal 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, qreal 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, qreal duration);


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

        qreal fieldOfView() const { return fieldOfView_; }

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

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

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

        virtual qreal zNear() const;
        virtual qreal 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(qreal fov);

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

        void setFOVToFitScene();

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

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


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

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

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


public Q_SLOTS:
        void setPivotPoint(const Vec& point);
        bool setPivotPointFromPixel(const QPoint& pixel);

public:
        Vec pivotPoint() const;

#ifndef DOXYGEN
public Q_SLOTS:
        void setRevolveAroundPoint(const Vec& point);
        bool setRevolveAroundPointFromPixel(const QPoint& pixel);
public:
        Vec revolveAroundPoint() const;
#endif



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


public:
        KeyFrameInterpolator* keyFrameInterpolator(unsigned int i) const;

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

        virtual void addKeyFrameToPath(unsigned int i);
        virtual void playPath(unsigned int i);
        virtual void deletePath(unsigned int i);
        virtual void resetPath(unsigned 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(GLfloat m[16]) const;
        void getProjectionMatrix(GLdouble m[16]) const;

        void getModelViewMatrix(GLfloat m[16]) const;
        void getModelViewMatrix(GLdouble m[16]) const;

        void getModelViewProjectionMatrix(GLfloat m[16]) const;
        void getModelViewProjectionMatrix(GLdouble m[16]) const;


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


public:
        Vec cameraCoordinatesOf(const Vec& src) const;
        Vec worldCoordinatesOf(const Vec& src) const;
        void getCameraCoordinatesOf(const qreal src[3], qreal res[3]) const;
        void getWorldCoordinatesOf(const qreal src[3], qreal 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 qreal src[3], qreal res[3], const Frame* frame=NULL) const;
        void getUnprojectedCoordinatesOf(const qreal src[3], qreal 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:
        qreal flySpeed() const;
public Q_SLOTS:
        void setFlySpeed(qreal speed);


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

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

        qreal physicalScreenWidth() const { return physicalScreenWidth_; }

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

#ifndef DOXYGEN

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

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

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


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


private Q_SLOTS:
        void onFrameModified();

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
        qreal fieldOfView_; // in radians
        Vec sceneCenter_;
        qreal sceneRadius_; // OpenGL units
        qreal zNearCoef_;
        qreal zClippingCoef_;
        qreal orthoCoef_;
        Type type_; // PERSPECTIVE or ORTHOGRAPHIC
        mutable GLdouble modelViewMatrix_[16]; // Buffered model view matrix.
        mutable bool modelViewMatrixIsUpToDate_;
        mutable GLdouble projectionMatrix_[16]; // Buffered projection matrix.
        mutable bool projectionMatrixIsUpToDate_;

        // S t e r e o   p a r a m e t e r s
        qreal IODistance_;                   // inter-ocular distance, in meters
        qreal focusDistance_;        // in scene units
        qreal 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<unsigned int, KeyFrameInterpolator*> kfi_;
        KeyFrameInterpolator* interpolationKfi_;
};

} // namespace qglviewer

#endif // QGLVIEWER_CAMERA_H