ManipulatedFrame Class Reference

A ManipulatedFrame is a Frame that can be rotated and translated using the mouse. More...

## Signals

void | manipulated ()
void | spun ()
Signals inherited from Frame
void | modified ()
void | interpolated ()

## Public Member Functions

| ManipulatedFrame ()
virtual | ~ManipulatedFrame ()
| ManipulatedFrame (const ManipulatedFrame &mf)
ManipulatedFrame & | operator= (const ManipulatedFrame &mf)
Public Member Functions inherited from Frame
| Frame ()
virtual | ~Frame ()
| Frame (const Frame &frame)
Frame & | operator= (const Frame &frame)
| Frame (const Vec &position, const Quaternion &orientation)
void | setPosition (const Vec &position)
void | setPosition (qreal x, qreal y, qreal z)
void | setPositionWithConstraint (Vec &position)
void | setOrientation (const Quaternion &orientation)
void | setOrientation (qreal q0, qreal q1, qreal q2, qreal q3)
void | setOrientationWithConstraint (Quaternion &orientation)
void | setPositionAndOrientation (const Vec &position, const Quaternion &orientation)
void | setPositionAndOrientationWithConstraint (Vec &position, Quaternion &orientation)
Vec | position () const
Quaternion | orientation () const
void | getPosition (qreal &x, qreal &y, qreal &z) const
void | getOrientation (qreal &q0, qreal &q1, qreal &q2, qreal &q3) const
void | setTranslation (const Vec &translation)
void | setTranslation (qreal x, qreal y, qreal z)
void | setTranslationWithConstraint (Vec &translation)
void | setRotation (const Quaternion &rotation)
void | setRotation (qreal q0, qreal q1, qreal q2, qreal q3)
void | setRotationWithConstraint (Quaternion &rotation)
void | setTranslationAndRotation (const Vec &translation, const Quaternion &rotation)
void | setTranslationAndRotationWithConstraint (Vec &translation, Quaternion &rotation)
Vec | translation () const
Quaternion | rotation () const
void | getTranslation (qreal &x, qreal &y, qreal &z) const
void | getRotation (qreal &q0, qreal &q1, qreal &q2, qreal &q3) const
const Frame * | referenceFrame () const
void | setReferenceFrame (const Frame *const refFrame)
bool | settingAsReferenceFrameWillCreateALoop (const Frame *const frame)
void | translate (Vec &t)
void | translate (const Vec &t)
void | translate (qreal x, qreal y, qreal z)
void | translate (qreal &x, qreal &y, qreal &z)
void | rotate (Quaternion &q)
void | rotate (const Quaternion &q)
void | rotate (qreal q0, qreal q1, qreal q2, qreal q3)
void | rotate (qreal &q0, qreal &q1, qreal &q2, qreal &q3)
void | rotateAroundPoint (Quaternion &rotation, const Vec &point)
void | rotateAroundPoint (const Quaternion &rotation, const Vec &point)
void | alignWithFrame (const Frame *const frame, bool move=false, qreal threshold=0.0)
void | projectOnLine (const Vec &origin, const Vec &direction)
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 *const in) const
Vec | coordinatesOfFrom (const Vec &src, const Frame *const from) const
void | getCoordinatesOf (const qreal src[3], qreal res[3]) const
void | getInverseCoordinatesOf (const qreal src[3], qreal res[3]) const
void | getLocalCoordinatesOf (const qreal src[3], qreal res[3]) const
void | getLocalInverseCoordinatesOf (const qreal src[3], qreal res[3]) const
void | getCoordinatesOfIn (const qreal src[3], qreal res[3], const Frame *const in) const
void | getCoordinatesOfFrom (const qreal src[3], qreal res[3], const Frame *const 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 *const in) const
Vec | transformOfFrom (const Vec &src, const Frame *const from) const
void | getTransformOf (const qreal src[3], qreal res[3]) const
void | getInverseTransformOf (const qreal src[3], qreal res[3]) const
void | getLocalTransformOf (const qreal src[3], qreal res[3]) const
void | getLocalInverseTransformOf (const qreal src[3], qreal res[3]) const
void | getTransformOfIn (const qreal src[3], qreal res[3], const Frame *const in) const
void | getTransformOfFrom (const qreal src[3], qreal res[3], const Frame *const from) const
Constraint * | constraint () const
void | setConstraint (Constraint *const constraint)
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 GLdouble m[4][4])
void | setFromMatrix (const GLdouble m[16])
Frame | inverse () const
Frame | worldInverse () const
Public Member Functions inherited from MouseGrabber
| MouseGrabber ()
virtual | ~MouseGrabber ()
bool | grabsMouse () const
bool | isInMouseGrabberPool () const
void | addInMouseGrabberPool ()
void | removeFromMouseGrabberPool ()
void | clearMouseGrabberPool (bool autoDelete=false)

## Manipulation sensitivity

qreal | rotationSensitivity () const
qreal | translationSensitivity () const
qreal | spinningSensitivity () const
qreal | zoomSensitivity () const
qreal | wheelSensitivity () const
void | setRotationSensitivity (qreal sensitivity)
void | setTranslationSensitivity (qreal sensitivity)
void | setSpinningSensitivity (qreal sensitivity)
void | setWheelSensitivity (qreal sensitivity)
void | setZoomSensitivity (qreal sensitivity)

## Spinning

bool | isSpinning () const
Quaternion | spinningQuaternion () const
void | setSpinningQuaternion (const Quaternion &spinningQuaternion)
virtual void | startSpinning (int updateInterval)
virtual void | stopSpinning ()
virtual void | spin ()

## Mouse event handlers

virtual void | mousePressEvent (QMouseEvent *const event, Camera *const camera)
virtual void | mouseMoveEvent (QMouseEvent *const event, Camera *const camera)
virtual void | mouseReleaseEvent (QMouseEvent *const event, Camera *const camera)
virtual void | mouseDoubleClickEvent (QMouseEvent *const event, Camera *const camera)
virtual void | wheelEvent (QWheelEvent *const event, Camera *const camera)

## Current state

bool | isManipulated () const
QGLViewer::MouseAction | currentMouseAction () const

## MouseGrabber implementation

virtual void | checkIfGrabsMouse (int x, int y, const Camera *const camera)

## XML representation

virtual QDomElement | domElement (const QString &name, QDomDocument &document) const
virtual void | initFromDOMElement (const QDomElement &element)

## Additional Inherited Members

Public Slots inherited from Frame
virtual void | initFromDOMElement (const QDomElement &element)
Static Public Member Functions inherited from MouseGrabber
static const QList< MouseGrabber * > & | MouseGrabberPool ()
Protected Member Functions inherited from MouseGrabber
void | setGrabsMouse (bool grabs)

## Detailed Description

A ManipulatedFrame is a Frame that can be rotated and translated using the mouse.

It converts the mouse motion into a translation and an orientation updates. A ManipulatedFrame is used to move an object in the scene. Combined with object selection, its MouseGrabber properties and a dynamic update of the scene, the ManipulatedFrame introduces a great reactivity in your applications.

A ManipulatedFrame is attached to a QGLViewer using QGLViewer::setManipulatedFrame():

init() { setManipulatedFrame( new ManipulatedFrame() ); }
draw()
{
glPushMatrix();
glMultMatrixd(manipulatedFrame()->matrix());
// draw the manipulated object here
glPopMatrix();
}

See the manipulatedFrame example for a complete application.

Mouse events are normally sent to the QGLViewer::camera(). You have to press the FRAME state key (default is `Control`) to move the QGLViewer::manipulatedFrame() instead. See the mouse page for a description of mouse button bindings.

### Inherited functionalities

A ManipulatedFrame is an overloaded instance of a Frame. The powerful coordinate system transformation functions (Frame::coordinatesOf(), Frame::transformOf(), ...) can hence be applied to a ManipulatedFrame.

A ManipulatedFrame is also a MouseGrabber. If the mouse cursor gets within a distance of 10 pixels from the projected position of the ManipulatedFrame, the ManipulatedFrame becomes the new QGLViewer::mouseGrabber(). It can then be manipulated directly, without any specific state key, object selection or GUI intervention. This is very convenient to directly move some objects in the scene (typically a light). See the mouseGrabber example as an illustration. Note that QWidget::setMouseTracking() needs to be enabled in order to use this feature (see the MouseGrabber documentation).

### Advanced functionalities

A QGLViewer can handle at most one ManipulatedFrame at a time. If you want to move several objects in the scene, you simply have to keep a list of the different ManipulatedFrames, and to activate the right one (using QGLViewer::setManipulatedFrame()) when needed. This can for instance be done according to an object selection: see the luxo example for an illustration.

When the ManipulatedFrame is being manipulated using the mouse (mouse pressed and not yet released), isManipulated() returns `true`. This might be used to trigger a specific action or display (as is done with QGLViewer::fastDraw()).

The ManipulatedFrame also emits a manipulated() signal each time its state is modified by the mouse. This signal is automatically connected to the QGLViewer::update() slot when the ManipulatedFrame is attached to a viewer using QGLViewer::setManipulatedFrame().

You can make the ManipulatedFrame spin() if you release the rotation mouse button while moving the mouse fast enough (see spinningSensitivity()). See also translationSensitivity() and rotationSensitivity() for sensitivity tuning.

## Constructor & Destructor Documentation

## ManipulatedFrame() [1/2]

ManipulatedFrame | ( |  | ) |

Default constructor.

The translation is set to (0,0,0), with an identity rotation (0,0,0,1) (see Frame constructor for details).

The different sensitivities are set to their default values (see rotationSensitivity(), translationSensitivity(), spinningSensitivity() and wheelSensitivity()).

## ~ManipulatedFrame()

virtual ~ManipulatedFrame | ( |  | ) |

virtual

Virtual destructor. Empty.

## ManipulatedFrame() [2/2]

ManipulatedFrame | ( | const ManipulatedFrame & | mf | ) |

Copy constructor. Performs a deep copy of all attributes using operator=().

## Member Function Documentation

## checkIfGrabsMouse()

void checkIfGrabsMouse | ( | int | x,
|  | int | y,
|  | const Camera *const | camera
| ) |  |

virtual

Implementation of the MouseGrabber main method.

The ManipulatedFrame grabsMouse() when the mouse is within a 10 pixels region around its Camera::projectedCoordinatesOf() position().

See the mouseGrabber example for an illustration.

Implements MouseGrabber.

## currentMouseAction()

QGLViewer::MouseAction currentMouseAction | ( |  | ) | const

Returns the `MouseAction` currently applied to this ManipulatedFrame.

Will return NO_MOUSE_ACTION unless a mouse button is being pressed and has been bound to this QGLViewer::MouseHandler.

The binding between mouse buttons and key modifiers and MouseAction is set using QGLViewer::setMouseBinding(Qt::Key key, Qt::KeyboardModifiers modifiers, Qt::MouseButton buttons, MouseHandler handler, MouseAction action, bool withConstraint).

## domElement()

QDomElement domElement | ( | const QString & | name,
|  | QDomDocument & | document
| ) |  | const

virtual

Returns an XML `QDomElement` that represents the ManipulatedFrame.

Adds to the Frame::domElement() the ManipulatedFrame specific informations in a `ManipulatedParameters` child QDomElement.

`name` is the name of the QDomElement tag. `doc` is the `QDomDocument` factory used to create QDomElement.

Use initFromDOMElement() to restore the ManipulatedFrame state from the resulting `QDomElement`.

See Vec::domElement() for a complete example. See also Quaternion::domElement(), Camera::domElement()...

Reimplemented from Frame.

Reimplemented in ManipulatedCameraFrame.

## initFromDOMElement

void initFromDOMElement | ( | const QDomElement & | element | ) |

virtual slot

Restores the ManipulatedFrame state from a `QDomElement` created by domElement().

Fields that are not described in `element` are set to their default values (see ManipulatedFrame()).

First calls Frame::initFromDOMElement() and then initializes ManipulatedFrame specific parameters. Note that constraint() and referenceFrame() are not restored and are left unchanged.

See Vec::initFromDOMElement() for a complete code example.

## isManipulated()

bool isManipulated | ( |  | ) | const

Returns `true` when the ManipulatedFrame is being manipulated with the mouse.

Can be used to change the display of the manipulated object during manipulation.

When Camera::frame() of the QGLViewer::camera() isManipulated(), QGLViewer::fastDraw() is used in place of QGLViewer::draw() for scene rendering. A simplified drawing will then allow for interactive camera displacements.

## isSpinning()

bool isSpinning | ( |  | ) | const

Returns `true` when the ManipulatedFrame is spinning.

During spinning, spin() rotates the ManipulatedFrame by its spinningQuaternion() at a frequency defined when the ManipulatedFrame startSpinning().

Use startSpinning() and stopSpinning() to change this state. Default value is `false`.

## manipulated

void manipulated | ( |  | ) |

signal

This signal is emitted when ever the ManipulatedFrame is manipulated (i.e. rotated or translated) using the mouse. Connect this signal to any object that should be notified.

Note that this signal is automatically connected to the QGLViewer::update() slot, when the ManipulatedFrame is attached to a viewer using QGLViewer::setManipulatedFrame(), which is probably all you need.

Use the QGLViewer::QGLViewerPool() if you need to connect this signal to all the viewers.

See also the spun(), modified(), interpolated() and KeyFrameInterpolator::interpolated() signals' documentations.

## mouseDoubleClickEvent()

void mouseDoubleClickEvent | ( | QMouseEvent *const | event,
|  | Camera *const | camera
| ) |  |

protected virtual

Overloading of MouseGrabber::mouseDoubleClickEvent().

Left button double click aligns the ManipulatedFrame with the `camera` axis (see alignWithFrame() and ALIGN_FRAME). Right button projects the ManipulatedFrame on the `camera` view direction.

Reimplemented from MouseGrabber.

## mouseMoveEvent()

void mouseMoveEvent | ( | QMouseEvent *const | event,
|  | Camera *const | camera
| ) |  |

protected virtual

Modifies the ManipulatedFrame according to the mouse motion.

Actual behavior depends on mouse bindings. See the QGLViewer::MouseAction enum and the QGLViewer mouse page for details.

The `camera` is used to fit the mouse motion with the display parameters (see Camera::screenWidth(), Camera::screenHeight(), Camera::fieldOfView()).

Emits the manipulated() signal.

Reimplemented from MouseGrabber.

Reimplemented in ManipulatedCameraFrame.

## mousePressEvent()

void mousePressEvent | ( | QMouseEvent *const | event,
|  | Camera *const | camera
| ) |  |

protected virtual

Initiates the ManipulatedFrame mouse manipulation.

Overloading of MouseGrabber::mousePressEvent(). See also mouseMoveEvent() and mouseReleaseEvent().

The mouse behavior depends on which button is pressed. See the QGLViewer mouse page for details.

Reimplemented from MouseGrabber.

## mouseReleaseEvent()

void mouseReleaseEvent | ( | QMouseEvent *const | event,
|  | Camera *const | camera
| ) |  |

protected virtual

Stops the ManipulatedFrame mouse manipulation.

Overloading of MouseGrabber::mouseReleaseEvent().

If the action was a ROTATE QGLViewer::MouseAction, a continuous spinning is possible if the speed of the mouse cursor is larger than spinningSensitivity() when the button is released. Press the rotate button again to stop spinning. See startSpinning() and isSpinning().

Reimplemented from MouseGrabber.

Reimplemented in ManipulatedCameraFrame.

## operator=()

ManipulatedFrame & operator= | ( | const ManipulatedFrame & | mf | ) |

Equal operator. Calls Frame::operator=() and then copy attributes.

## rotationSensitivity()

qreal rotationSensitivity | ( |  | ) | const

Returns the influence of a mouse displacement on the ManipulatedFrame rotation.

Default value is 1.0. With an identical mouse displacement, a higher value will generate a larger rotation (and inversely for lower values). A 0.0 value will forbid ManipulatedFrame mouse rotation (see also constraint()).

See also setRotationSensitivity(), translationSensitivity(), spinningSensitivity() and wheelSensitivity().

## setRotationSensitivity

void setRotationSensitivity | ( | qreal | sensitivity | ) |

slot

Defines the rotationSensitivity().

## setSpinningQuaternion

void setSpinningQuaternion | ( | const Quaternion & | spinningQuaternion | ) |

slot

Defines the spinningQuaternion(). Its axis is defined in the ManipulatedFrame coordinate system.

## setSpinningSensitivity

void setSpinningSensitivity | ( | qreal | sensitivity | ) |

slot

Defines the spinningSensitivity(), in pixels per milliseconds.

## setTranslationSensitivity

void setTranslationSensitivity | ( | qreal | sensitivity | ) |

slot

Defines the translationSensitivity().

## setWheelSensitivity

void setWheelSensitivity | ( | qreal | sensitivity | ) |

slot

Defines the wheelSensitivity().

## setZoomSensitivity

void setZoomSensitivity | ( | qreal | sensitivity | ) |

slot

Defines the zoomSensitivity().

## spin

void spin | ( |  | ) |

protected virtual slot

Rotates the ManipulatedFrame by its spinningQuaternion(). Called by a timer when the ManipulatedFrame isSpinning().

## spinningQuaternion()

Quaternion spinningQuaternion | ( |  | ) | const

Returns the incremental rotation that is applied by spin() to the ManipulatedFrame orientation when it isSpinning().

Default value is a null rotation (identity Quaternion). Use setSpinningQuaternion() to change this value.

The spinningQuaternion() axis is defined in the ManipulatedFrame coordinate system. You can use Frame::transformOfFrom() to convert this axis from an other Frame coordinate system.

## spinningSensitivity()

qreal spinningSensitivity | ( |  | ) | const

Returns the minimum mouse speed required (at button release) to make the ManipulatedFrame spin().

See spin(), spinningQuaternion() and startSpinning() for details.

Mouse speed is expressed in pixels per milliseconds. Default value is 0.3 (300 pixels per second). Use setSpinningSensitivity() to tune this value. A higher value will make spinning more difficult (a value of 100.0 forbids spinning in practice).

See also setSpinningSensitivity(), translationSensitivity(), rotationSensitivity() and wheelSensitivity().

## spun

void spun | ( |  | ) |

signal

This signal is emitted when the ManipulatedFrame isSpinning().

Note that for the QGLViewer::manipulatedFrame(), this signal is automatically connected to the QGLViewer::update() slot.

Connect this signal to any object that should be notified. Use the QGLViewer::QGLViewerPool() if you need to connect this signal to all the viewers.

See also the manipulated(), modified(), interpolated() and KeyFrameInterpolator::interpolated() signals' documentations.

## startSpinning

void startSpinning | ( | int | updateInterval | ) |

virtual slot

Starts the spinning of the ManipulatedFrame.

This method starts a timer that will call spin() every `updateInterval` milliseconds. The ManipulatedFrame isSpinning() until you call stopSpinning().

## stopSpinning

virtual void stopSpinning | ( |  | ) |

virtual slot

Stops the spinning motion started using startSpinning(). isSpinning() will return `false` after this call.

## translationSensitivity()

qreal translationSensitivity | ( |  | ) | const

Returns the influence of a mouse displacement on the ManipulatedFrame translation.

Default value is 1.0. You should not have to modify this value, since with 1.0 the ManipulatedFrame precisely stays under the mouse cursor.

With an identical mouse displacement, a higher value will generate a larger translation (and inversely for lower values). A 0.0 value will forbid ManipulatedFrame mouse translation (see also constraint()).

Note
  When the ManipulatedFrame is used to move a Camera (see the ManipulatedCameraFrame class documentation), after zooming on a small region of your scene, the camera may translate too fast. For a camera, it is the Camera::pivotPoint() that exactly matches the mouse displacement. Hence, instead of changing the translationSensitivity(), solve the problem by (temporarily) setting the Camera::pivotPoint() to a point on the zoomed region (see the RAP_FROM_PIXEL mouse binding in the mouse page).

See also setTranslationSensitivity(), rotationSensitivity(), spinningSensitivity() and wheelSensitivity().

## wheelEvent()

void wheelEvent | ( | QWheelEvent *const | event,
|  | Camera *const | camera
| ) |  |

protected virtual

Overloading of MouseGrabber::wheelEvent().

Using the wheel is equivalent to a ZOOM QGLViewer::MouseAction. See QGLViewer::setWheelBinding(), setWheelSensitivity().

Reimplemented from MouseGrabber.

Reimplemented in ManipulatedCameraFrame.

## wheelSensitivity()

qreal wheelSensitivity | ( |  | ) | const

Returns the mouse wheel sensitivity.

Default value is 1.0. A higher value will make the wheel action more efficient (usually meaning a faster zoom). Use a negative value to invert the zoom in and out directions.

See also setWheelSensitivity(), translationSensitivity(), rotationSensitivity() zoomSensitivity() and spinningSensitivity().

## zoomSensitivity()

qreal zoomSensitivity | ( |  | ) | const

Returns the zoom sensitivity.

Default value is 1.0. A higher value will make the zoom faster. Use a negative value to invert the zoom in and out directions.

See also setZoomSensitivity(), translationSensitivity(), rotationSensitivity() wheelSensitivity() and spinningSensitivity().