camera.h

Go to the documentation of this file.

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

 This file is part of the QGLViewer library
 Copyright (C) 2002-2004  Gilles Debunne (Gilles.Debunne@imag.fr)
 Version 1.3.5 Release 8. Packaged on Monday December 22, 2003.

 http://www-imagis.imag.fr/Membres/Gilles.Debunne/CODE/QGLViewer

 libQGLViewer is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.

 libQGLViewer is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with libQGLViewer; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

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

#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        // must include this if you use Qt signals/slots
      
  public:
    Camera();
    virtual ~Camera() {};

    enum Type { PERSPECTIVE, ORTHO };

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

    void getPosition(float& x, float& y, float& z) const;
    void getOrientation(float& q0, float& q1, float& q2, float& q3) const;

     public slots:
    void setPosition(const Vec& pos) { frame()->setPosition(pos); };
    void setPosition(float x, float y, float z) { setPosition(Vec(x,y,z)); };

    void setOrientation(const Quaternion& q);
    void setOrientation(float q0, float q1, float q2, float q3) { setOrientation(Quaternion(q0,q1,q2,q3)); };
    void setOrientation(float theta, float phi);

    void setCameraFromProjectionMatrix(const float* const m);

    
  public slots:
    void showEntireScene();

    void fitBoundingBox(const Vec& m, const Vec& M);

    void fitSphere(const Vec& center, float radius);
    void fitSphere(float x, float y, float z, float r) { fitSphere(Vec(x,y,z), r); };

    void lookAt(const Vec& target);
    void lookAt(float x, float y, float z) { lookAt(Vec(x,y,z)); };

    void centerScene();

    void setUpVector(const Vec& up, bool noMove = true);
    void fitScreenRegion(int xa, int ya, int xb, int yb);
    
    void setFOVToFitScene();
  public: // Doxygen thinks it is too smart
    void setUpVector(float x, float y, float z, bool noMove = true) { setUpVector(Vec(x,y,z), noMove); };
    
  public slots:
    void interpolateToZoomOnPixel(int x, int y);
    void interpolateToFitScene();  

    
  public:
    float fieldOfView() const { return fieldOfView_; };

    float flySpeed() const { return frame()->flySpeed(); };

    Type type() const { return type_; };
      
    int mode() const { qWarning("Camera::mode() is obsolete since version 1.3.4, see changeLog"); return -1;};

  public slots:
    void setFieldOfView(float f) { fieldOfView_ = f; setDistanceToZeroParallaxPlane(sceneRadius() / tan(f/2.0)); };

    void setFlySpeed(float s) { frame()->setFlySpeed(s); };
    void setType(Type type);

    void setMode(int) { qWarning("Camera::setMode() is obsolete since version 1.3.4, see changeLog"); };
    void toggleMode() { qWarning("Camera::toggleMode() is obsolete since version 1.3.4, see changeLog"); };

    
  public:
    virtual float zNear() const;
    virtual float zFar()  const;
    float zNearCoef() const { return zNearCoef_; };
    void getOrthoWidthHeight(GLdouble& w, GLdouble& h) const;

    float aspectRatio() const { return static_cast<float>(screenWidth_)/static_cast<float>(screenHeight_); };
    int screenWidth() const { return screenWidth_; };
    int screenHeight() const { return screenHeight_; };
    float pixelGLRatio(const Vec& pos);

    float distanceToSceneCenter() const;
    
    Vec upVector() const;
    void getUpVector(float& x, float& y, float& z) const;

    Vec viewDirection() const { return frame()->inverseTransformOf(Vec(0.0, 0.0, -1.0)); };
    void getViewDirection(float& x, float& y, float& z) const;
    
    Vec pointUnderPixel(const int x, const int y, bool& found);

    bool isManipulated() const { return frame()->isManipulated(); };

    void getViewport(GLint viewport[4]) const;
    
  public slots:
    void setZNearCoef(float coef) { zNearCoef_ = coef; };

    
 public slots:
    void setRevolveAroundPoint(const Vec& rap);
    void setRevolveAroundPoint(float x, float y, float z) { setRevolveAroundPoint(Vec(x,y,z)); };
    bool setRevolveAroundPointFromPixel(int x, int y);
    
  public:    
    Vec revolveAroundPoint() const { return revolveAroundPoint_; };
    void getRevolveAroundPoint(float& x, float& y, float& z) const;

    
   public:
    int nbPaths() const { return nbPaths_; };

    KeyFrameInterpolator* keyFrameInterpolator(unsigned short i) const;

public slots:
    void setKeyFrameInterpolator(unsigned short i, KeyFrameInterpolator* const kfi);

    virtual void addKeyFrame(unsigned short i);
    virtual void playKeyFramePath(unsigned short i);
    virtual void deleteKeyFramePath(unsigned short i);
    virtual void resetKeyFramePath(unsigned short i);

    virtual void drawAllPaths();

    
  public:
    ManipulatedCameraFrame* frame() const { return frame_; };
  public slots:
    void setFrame(ManipulatedCameraFrame* const f) { if (!f) return; frame_ = f; };
 

  public:
    virtual void loadProjectionMatrix(bool reset=true) const;
    virtual void loadProjectionMatrixStereo(bool leftBuffer=true) const;
    virtual void loadModelViewMatrix(bool reset=true) const;
    virtual void loadModelViewMatrixStereo(bool leftBuffer=true) const;

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

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

    
  public:
    Vec projectedCoordinatesOf(const Vec& src) const;
    void getProjectedCoordinatesOf(const float src[3], float res[3]) const;
    Vec unprojectedCoordinatesOf(const Vec& src) const;
    void getUnprojectedCoordinatesOf(const float src[3], float res[3]) const;
    void convertClickToLine(int x, int y, float orig[3], float dir[3]) const;
    void convertClickToLine(int x, int y, Vec& orig, Vec& dir) const;

        
  public slots:
    void setHorizontalFieldOfView(float hfov) { setFieldOfView( 2.0 * atan (tan(hfov / 2.0) / aspectRatio()) ); };
    
    void setIODist(float iod) { IODist_ = iod; };

    void setDistanceToScreen(float dts) { distanceToScreen_ = dts; };

    void setDistanceToZeroParallaxPlane(float dtz) { distanceToZeroParallaxPlane_ = dtz; };

    void setPhysicalScreenWidth(float sw) { physicalScreenWidth_ = sw; };
  public:
    float horizontalFieldOfView() const { return 2.0 * atan ( tan(fieldOfView()/2.0) * aspectRatio() ); };

    float IODist() const { return IODist_; };

    float distanceToScreen() const { return distanceToScreen_; };

    float distanceToZeroParallaxPlane() const { return distanceToZeroParallaxPlane_; };

    float physicalScreenWidth() const { return physicalScreenWidth_; };

  public:
    virtual QDomElement domElement(const QString& name, QDomDocument& doc) const;
    virtual void initFromDOMElement(const QDomElement& de);


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

    Vec sceneCenter() const { return sceneCenter_; };

    void setSceneRadius(float r);
    void setSceneBoundingBox(const Vec& m, const Vec& M);
    void setSceneCenter(const Vec& sc);
    void setSceneCenter(float x, float y, float z);
    bool setSceneCenterFromPixel(int x, int y);


    
  public:  
    bool cameraPathIsEdited() const { return cameraPathIsEdited_; };

  public slots :
    void editCameraPath(bool edit) { cameraPathIsEdited_ = edit; };

    void setWindowWidthAndHeight(int w, int h);


  private:
    // Copy constructor and opertor= are declared private and undefined
    // Prevents everyone from trying to use them
    Camera(const Camera& v);
    Camera& operator=(const Camera& v);

    // 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_;
    float sceneRadius_;
    float zNearCoef_;
    float orthoCoef_;
    Vec sceneCenter_;
    Vec revolveAroundPoint_;
    Type type_; // PERSPECTIVE or ORTHO
    mutable GLdouble modelViewMatrix_[16]; // Buffered model view matrix.

    bool cameraPathIsEdited_; // camera path edition mode
    
    // S t e r e o   p a r a m e t e r s 
    float IODist_;          // inter-ocular distance
    float distanceToScreen_;        // in meters
    float distanceToZeroParallaxPlane_; // 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 
    enum { nbPaths_ = 12 };
    KeyFrameInterpolator* kfi_[nbPaths_];
    unsigned short lastActivatedKFNumber_; // Prevents two simultaneous path interpolations
  };


// #define __WHERE__ "In file "<<__FILE__<<", line n°"<<__LINE__<< ", use "
// #define orientationAxisAngle(x,y,z,a)    { std::cout << __WHERE__ << "getOrientationAxisAngle()." << std::endl; exit(0); }

} // namespace qglviewer

#endif // QGLVIEWER_CAMERA_H

---