manipulatedFrame.cpp

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

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

 This file is part of the QGLViewer library version 2.5.2.

 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.

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

#include "domUtils.h"
#include "manipulatedFrame.h"
#include "manipulatedCameraFrame.h"
#include "qglviewer.h"
#include "camera.h"

#include <cstdlib>

#include <QMouseEvent>

using namespace qglviewer;
using namespace std;

ManipulatedFrame::ManipulatedFrame()
    : action_(QGLViewer::NO_MOUSE_ACTION), keepsGrabbingMouse_(false)
{
    // #CONNECTION# initFromDOMElement and accessor docs
    setRotationSensitivity(1.0f);
    setTranslationSensitivity(1.0f);
    setSpinningSensitivity(0.3f);
    setWheelSensitivity(1.0f);
    setZoomSensitivity(1.0f);

    isSpinning_ = false;
    previousConstraint_ = NULL;

    connect(&spinningTimer_, SIGNAL(timeout()), SLOT(spinUpdate()));
}

ManipulatedFrame& ManipulatedFrame::operator=(const ManipulatedFrame& mf)
{
    Frame::operator=(mf);

    setRotationSensitivity(mf.rotationSensitivity());
    setTranslationSensitivity(mf.translationSensitivity());
    setSpinningSensitivity(mf.spinningSensitivity());
    setWheelSensitivity(mf.wheelSensitivity());
    setZoomSensitivity(mf.zoomSensitivity());

    mouseSpeed_ = 0.0;
    dirIsFixed_ = false;
    keepsGrabbingMouse_ = false;
    action_ = QGLViewer::NO_MOUSE_ACTION;

    return *this;
}

ManipulatedFrame::ManipulatedFrame(const ManipulatedFrame& mf)
    : Frame(mf), MouseGrabber()
{
    (*this)=mf;
}


void ManipulatedFrame::checkIfGrabsMouse(int x, int y, const Camera* const camera)
{
    const int thresold = 10;
    const Vec proj = camera->projectedCoordinatesOf(position());
    setGrabsMouse(keepsGrabbingMouse_ || ((fabs(x-proj.x) < thresold) && (fabs(y-proj.y) < thresold)));
}

//          S t a t e   s a v i n g   a n d   r e s t o r i n g               //

QDomElement ManipulatedFrame::domElement(const QString& name, QDomDocument& document) const
{
    QDomElement e = Frame::domElement(name, document);
    QDomElement mp = document.createElement("ManipulatedParameters");
    mp.setAttribute("rotSens", QString::number(rotationSensitivity()));
    mp.setAttribute("transSens", QString::number(translationSensitivity()));
    mp.setAttribute("spinSens", QString::number(spinningSensitivity()));
    mp.setAttribute("wheelSens", QString::number(wheelSensitivity()));
    mp.setAttribute("zoomSens", QString::number(zoomSensitivity()));
    e.appendChild(mp);
    return e;
}

void ManipulatedFrame::initFromDOMElement(const QDomElement& element)
{
    // Not called since it would set constraint() and referenceFrame() to NULL.
    // *this = ManipulatedFrame();
    Frame::initFromDOMElement(element);

    stopSpinning();

    QDomElement child=element.firstChild().toElement();
    while (!child.isNull())
    {
        if (child.tagName() == "ManipulatedParameters")
        {
            // #CONNECTION# constructor default values and accessor docs
            setRotationSensitivity   (DomUtils::floatFromDom(child, "rotSens",   1.0f));
            setTranslationSensitivity(DomUtils::floatFromDom(child, "transSens", 1.0f));
            setSpinningSensitivity   (DomUtils::floatFromDom(child, "spinSens",  0.3f));
            setWheelSensitivity      (DomUtils::floatFromDom(child, "wheelSens", 1.0f));
            setZoomSensitivity       (DomUtils::floatFromDom(child, "zoomSens", 1.0f));
        }
        child = child.nextSibling().toElement();
    }
}


//                 M o u s e    h a n d l i n g                               //

bool ManipulatedFrame::isManipulated() const
{
    return action_ != QGLViewer::NO_MOUSE_ACTION;
}

void ManipulatedFrame::startSpinning(int updateInterval)
{
    isSpinning_ = true;
    spinningTimer_.start(updateInterval);
}

void ManipulatedFrame::spin()
{
    rotate(spinningQuaternion());
}

/* spin() and spinUpdate() differ since spin can be used by itself (for instance by
   QGLViewer::SCREEN_ROTATE) without a spun emission. Much nicer to use the spinningQuaternion() and
   hence spin() for these incremental updates. Nothing special to be done for continuous spinning
   with this design. */
void ManipulatedFrame::spinUpdate()
{
    spin();
    Q_EMIT spun();
}

#ifndef DOXYGEN

void ManipulatedFrame::startAction(int ma, bool withConstraint)
{
    action_ = (QGLViewer::MouseAction)(ma);

    // #CONNECTION# manipulatedFrame::wheelEvent, manipulatedCameraFrame::wheelEvent and mouseReleaseEvent()
    // restore previous constraint
    if (withConstraint)
        previousConstraint_ = NULL;
    else
    {
        previousConstraint_ = constraint();
        setConstraint(NULL);
    }

    switch (action_)
    {
        case QGLViewer::ROTATE:
        case QGLViewer::SCREEN_ROTATE:
            mouseSpeed_ = 0.0;
            stopSpinning();
            break;

        case QGLViewer::SCREEN_TRANSLATE:
            dirIsFixed_ = false;
            break;

        default:
            break;
    }
}

void ManipulatedFrame::computeMouseSpeed(const QMouseEvent* const e)
{
    const QPoint delta = (e->pos() - prevPos_);
    const float dist = sqrt(static_cast<float>(delta.x()*delta.x() + delta.y()*delta.y()));
    delay_ = last_move_time.restart();
    if (delay_ == 0)
        // Less than a millisecond: assume delay = 1ms
        mouseSpeed_ = dist;
    else
        mouseSpeed_ = dist/delay_;
}

int ManipulatedFrame::mouseOriginalDirection(const QMouseEvent* const e)
{
    static bool horiz = true; // Two simultaneous manipulatedFrame require two mice !

    if (!dirIsFixed_)
    {
        const QPoint delta = e->pos() - pressPos_;
        dirIsFixed_ = abs(delta.x()) != abs(delta.y());
        horiz = abs(delta.x()) > abs(delta.y());
    }

    if (dirIsFixed_)
        if (horiz)
            return 1;
        else
            return -1;
    else
        return 0;
}

float ManipulatedFrame::deltaWithPrevPos(QMouseEvent* const event, Camera* const camera) const {
    float dx = float(event->x() - prevPos_.x()) / camera->screenWidth();
    float dy = float(event->y() - prevPos_.y()) / camera->screenHeight();

    float value = fabs(dx) > fabs(dy) ? dx : dy;
    return value * zoomSensitivity();
}

float ManipulatedFrame::wheelDelta(const QWheelEvent* event) const {
    static const float WHEEL_SENSITIVITY_COEF = 8E-4f;
    return event->delta() * wheelSensitivity() * WHEEL_SENSITIVITY_COEF;
}

void ManipulatedFrame::zoom(float delta, const Camera * const camera) {
    Vec trans(0.0, 0.0, (camera->position() - position()).norm() * delta);

    trans = camera->frame()->orientation().rotate(trans);
    if (referenceFrame())
        trans = referenceFrame()->transformOf(trans);
    translate(trans);
}

#endif // DOXYGEN

void ManipulatedFrame::mousePressEvent(QMouseEvent* const event, Camera* const camera)
{
    Q_UNUSED(camera);

    if (grabsMouse())
        keepsGrabbingMouse_ = true;

    // #CONNECTION setMouseBinding
    // action_ should no longer possibly be NO_MOUSE_ACTION since this value is not inserted in mouseBinding_
    //if (action_ == QGLViewer::NO_MOUSE_ACTION)
    //event->ignore();

    prevPos_ = pressPos_ = event->pos();
}

void ManipulatedFrame::mouseMoveEvent(QMouseEvent* const event, Camera* const camera)
{
    switch (action_)
    {
        case QGLViewer::TRANSLATE:
        {
            const QPoint delta = event->pos() - prevPos_;
            Vec trans(static_cast<float>(delta.x()), static_cast<float>(-delta.y()), 0.0);
            // Scale to fit the screen mouse displacement
            switch (camera->type())
            {
                case Camera::PERSPECTIVE :
                    trans *= 2.0 * tan(camera->fieldOfView()/2.0) * fabs((camera->frame()->coordinatesOf(position())).z) / camera->screenHeight();
                    break;
                case Camera::ORTHOGRAPHIC :
                {
                    GLdouble w,h;
                    camera->getOrthoWidthHeight(w, h);
                    trans[0] *= 2.0 * w / camera->screenWidth();
                    trans[1] *= 2.0 * h / camera->screenHeight();
                    break;
                }
            }
            // Transform to world coordinate system.
            trans = camera->frame()->orientation().rotate(translationSensitivity()*trans);
            // And then down to frame
            if (referenceFrame()) trans = referenceFrame()->transformOf(trans);
            translate(trans);
            break;
        }

        case QGLViewer::ZOOM:
        {
            zoom(deltaWithPrevPos(event, camera), camera);
            break;
        }

        case QGLViewer::SCREEN_ROTATE:
        {
            Vec trans = camera->projectedCoordinatesOf(position());

            const double prev_angle = atan2(prevPos_.y()-trans[1], prevPos_.x()-trans[0]);
            const double      angle = atan2(event->y()-trans[1], event->x()-trans[0]);

            const Vec axis = transformOf(camera->frame()->inverseTransformOf(Vec(0.0, 0.0, -1.0)));
            Quaternion rot(axis, angle-prev_angle);
            //#CONNECTION# These two methods should go together (spinning detection and activation)
            computeMouseSpeed(event);
            setSpinningQuaternion(rot);
            spin();
            break;
        }

        case QGLViewer::SCREEN_TRANSLATE:
        {
            Vec trans;
            int dir = mouseOriginalDirection(event);
            if (dir == 1)
                trans.setValue(static_cast<float>(event->x() - prevPos_.x()), 0.0, 0.0);
            else if (dir == -1)
                trans.setValue(0.0, static_cast<float>(prevPos_.y() - event->y()), 0.0);

            switch (camera->type())
            {
                case Camera::PERSPECTIVE :
                    trans *= 2.0 * tan(camera->fieldOfView()/2.0) * fabs((camera->frame()->coordinatesOf(position())).z) / camera->screenHeight();
                    break;
                case Camera::ORTHOGRAPHIC :
                {
                    GLdouble w,h;
                    camera->getOrthoWidthHeight(w, h);
                    trans[0] *= 2.0 * w / camera->screenWidth();
                    trans[1] *= 2.0 * h / camera->screenHeight();
                    break;
                }
            }
            // Transform to world coordinate system.
            trans = camera->frame()->orientation().rotate(translationSensitivity()*trans);
            // And then down to frame
            if (referenceFrame())
                trans = referenceFrame()->transformOf(trans);

            translate(trans);
            break;
        }

        case QGLViewer::ROTATE:
        {
            Vec trans = camera->projectedCoordinatesOf(position());
            Quaternion rot = deformedBallQuaternion(event->x(), event->y(), trans[0], trans[1], camera);
            trans = Vec(-rot[0], -rot[1], -rot[2]);
            trans = camera->frame()->orientation().rotate(trans);
            trans = transformOf(trans);
            rot[0] = trans[0];
            rot[1] = trans[1];
            rot[2] = trans[2];
            //#CONNECTION# These two methods should go together (spinning detection and activation)
            computeMouseSpeed(event);
            setSpinningQuaternion(rot);
            spin();
            break;
        }

        case QGLViewer::MOVE_FORWARD:
        case QGLViewer::MOVE_BACKWARD:
        case QGLViewer::LOOK_AROUND:
        case QGLViewer::ROLL:
        case QGLViewer::DRIVE:
        case QGLViewer::ZOOM_ON_REGION:
            // These MouseAction values make no sense for a manipulatedFrame
            break;

        case QGLViewer::NO_MOUSE_ACTION:
            // Possible when the ManipulatedFrame is a MouseGrabber. This method is then called without startAction
            // because of mouseTracking.
            break;
    }

    if (action_ != QGLViewer::NO_MOUSE_ACTION)
    {
        prevPos_ = event->pos();
        Q_EMIT manipulated();
    }
}

void ManipulatedFrame::mouseReleaseEvent(QMouseEvent* const event, Camera* const camera)
{
    Q_UNUSED(event);
    Q_UNUSED(camera);

    keepsGrabbingMouse_ = false;

    if (previousConstraint_)
        setConstraint(previousConstraint_);

    if (((action_ == QGLViewer::ROTATE) || (action_ == QGLViewer::SCREEN_ROTATE)) && (mouseSpeed_ >= spinningSensitivity()))
        startSpinning(delay_);

    action_ = QGLViewer::NO_MOUSE_ACTION;
}

void ManipulatedFrame::mouseDoubleClickEvent(QMouseEvent* const event, Camera* const camera)
{
    if (event->modifiers() == Qt::NoModifier)
        switch (event->button())
        {
            case Qt::LeftButton:  alignWithFrame(camera->frame()); break;
            case Qt::RightButton: projectOnLine(camera->position(), camera->viewDirection()); break;
            default: break;
        }
}

void ManipulatedFrame::wheelEvent(QWheelEvent* const event, Camera* const camera)
{
    //#CONNECTION# QGLViewer::setWheelBinding
    if (action_ == QGLViewer::ZOOM)
    {
        zoom(wheelDelta(event), camera);
        Q_EMIT manipulated();
    }

    // #CONNECTION# startAction should always be called before
    if (previousConstraint_)
        setConstraint(previousConstraint_);

    action_ = QGLViewer::NO_MOUSE_ACTION;
}



static float projectOnBall(float x, float y)
{
    // If you change the size value, change angle computation in deformedBallQuaternion().
    const float size       = 1.0f;
    const float size2      = size*size;
    const float size_limit = size2*0.5;

    const float d = x*x + y*y;
    return d < size_limit ? sqrt(size2 - d) : size_limit/sqrt(d);
}

#ifndef DOXYGEN

Quaternion ManipulatedFrame::deformedBallQuaternion(int x, int y, float cx, float cy, const Camera* const camera)
{
    // Points on the deformed ball
    float px = rotationSensitivity() * (prevPos_.x()  - cx) / camera->screenWidth();
    float py = rotationSensitivity() * (cy - prevPos_.y())  / camera->screenHeight();
    float dx = rotationSensitivity() * (x - cx)     / camera->screenWidth();
    float dy = rotationSensitivity() * (cy - y)     / camera->screenHeight();

    const Vec p1(px, py, projectOnBall(px, py));
    const Vec p2(dx, dy, projectOnBall(dx, dy));
    // Approximation of rotation angle
    // Should be divided by the projectOnBall size, but it is 1.0
    const Vec axis = cross(p2,p1);
    const float angle = 5.0 * asin(sqrt(axis.squaredNorm() / p1.squaredNorm() / p2.squaredNorm()));
    return Quaternion(axis, angle);
}
#endif // DOXYGEN