frame.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_FRAME_H
#define QGLVIEWER_FRAME_H

#include <qobject.h>
#include <qstring.h>

#include "vec.h"
#include "quaternion.h"
#include "constraint.h"
// #include "GL/gl.h" is now included in config.h for ease of configuration


namespace qglviewer {
  class QGLVIEWER_EXPORT Frame : public QObject
  {
    Q_OBJECT

  public:
    Frame();
    
    virtual ~Frame() {};

    Frame& operator=(const Frame& f);

    Frame(const Frame& f);

  signals:
    void modified();

  public:
    explicit Frame(const Vec& pos, const Quaternion& orien);

    void setPosition(const Vec& t);
    void setPosition(const float x, const float y, const float z);
    void setPositionWithConstraint(Vec& t);
    
    void setOrientation(const float x, const float y, const float z, const float a);
    void setOrientation(const Quaternion& q);
    void setOrientationWithConstraint(Quaternion& q);
    void setOrientationAxisAngle(const float x, const float y, const float z, const float a);

    void setPositionAndOrientation(const Vec& t, const Quaternion& q);
    void setPositionAndOrientationWithConstraint(Vec& t, Quaternion& q);
    
    Vec position() const { return inverseCoordinatesOf(Vec(0.0,0.0,0.0)); };
    void getPosition(float& x, float& y, float& z) const;

    Quaternion orientation() const;
    void getOrientation(float& q0, float& q1, float& q2, float& q3) const;

    
  public:
    Frame* referenceFrame() const { return referenceFrame_; };
    void setReferenceFrame(Frame* const fr);

    bool settingAsReferenceFrameWillCreateALoop(Frame* const fr);

    void setTranslation(const float x, const float y, const float z);
    void setTranslation(const Vec& t) { t_ = t; emit modified(); };
    void setTranslationWithConstraint(Vec& t);

    void setRotation(const float x, const float y, const float z, const float a);
    void setRotation(const Quaternion& q) { q_ = q; emit modified(); };
    void setRotationWithConstraint(Quaternion& q);
    void setRotationAxisAngle(const float x, const float y, const float z, const float a);

    void setTranslationAndRotation(const Vec& t, const Quaternion& q);
    void setTranslationAndRotationWithConstraint(Vec& t, Quaternion& q);

    void getTranslation(float& x, float& y, float& z) const;
    Vec translation() const { return t_; };

    void getRotation(float& x, float& y, float& z, float& a) const;
    Quaternion rotation() const { return q_; };

    void translate(Vec& t);
    void translate(const Vec& t);
    void translate(float t[3]);
    void translate(float& x, float& y, float& z);
    void translate(const float x, const float y, const float z);
    
    void rotate(Quaternion& q);
    void rotate(const Quaternion& q);
    void rotate(float q[4]);
    void rotate(float& x, float& y, float& z, float& a);
    void rotate(const float x, const float y, const float z, const float a);

    void rotateAroundPoint(Quaternion& q, const Vec& p);
    void rotateAroundPoint(const Quaternion& q, const Vec& p);


    Vec coordinatesOf(const Vec& src) const;
    Vec inverseCoordinatesOf(const Vec& src) const;
    Vec localCoordinatesOf(const Vec& src) const;
    Vec localInverseCoordinatesOf(const Vec& src) const;
    Vec coordinatesOfIn(const Vec& src, const Frame* in) const;
    Vec coordinatesOfFrom(const Vec& src, const Frame* from) const;
    
    void getCoordinatesOf(const float src[3], float res[3]) const;
    void getInverseCoordinatesOf(const float src[3], float res[3]) const;
    void getLocalCoordinatesOf(const float src[3], float res[3]) const;
    void getLocalInverseCoordinatesOf(const float src[3], float res[3]) const;
    void getCoordinatesOfIn(const float src[3], float res[3], const Frame* in) const;
    void getCoordinatesOfFrom(const float src[3], float res[3], const Frame* from) const;

    Vec transformOf(const Vec& src) const;
    Vec inverseTransformOf(const Vec& src) const;
    Vec localTransformOf(const Vec& src) const;
    Vec localInverseTransformOf(const Vec& src) const;
    Vec transformOfIn(const Vec& src, const Frame* in) const;
    Vec transformOfFrom(const Vec& src, const Frame* from) const;
    
    void getTransformOf(const float src[3], float res[3]) const;
    void getInverseTransformOf(const float src[3], float res[3]) const;
    void getLocalTransformOf(const float src[3], float res[3]) const;
    void getLocalInverseTransformOf(const float src[3], float res[3]) const;
    void getTransformOfIn(const float src[3], float res[3], const Frame* in) const;
    void getTransformOfFrom(const float src[3], float res[3], const Frame* from) const;

    Constraint* constraint() const { return constraint_; }
    void setConstraint(Constraint* c) { constraint_ = c; }

  public:
    const GLdouble* matrix() const;
    void getMatrix(GLdouble m[4][4]) const;
    void getMatrix(GLdouble m[16]) const;
    
    const GLdouble* worldMatrix() const;
    void getWorldMatrix(GLdouble m[4][4]) const;
    void getWorldMatrix(GLdouble m[16]) const;

    void setFromMatrix(const float m[4][4]);
    void alignWithFrame(const Frame* const fr, bool move=false, float threshold=0.85f);
    void projectOnLine(const Vec& origin, const Vec& dir);

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

  private:
    Vec t_;
    Quaternion q_;

    // C o n s t r a i n t s
    Constraint* constraint_;
    
    // F r a m e   c o m p o s i t i o n
    Frame* referenceFrame_;    
  };
  
} // namespace qglviewer

#endif // QGLVIEWER_FRAME_H

---