mirror of
https://github.com/OPM/ResInsight.git
synced 2025-02-25 18:55:39 -06:00
392 lines
14 KiB
C++
392 lines
14 KiB
C++
//##################################################################################################
|
|
//
|
|
// Custom Visualization Core library
|
|
// Copyright (C) 2015 Ceetron Solutions AS
|
|
//
|
|
// This library may be used under the terms of either the GNU General Public License or
|
|
// the GNU Lesser General Public License as follows:
|
|
//
|
|
// GNU General Public License Usage
|
|
// This library 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 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This library 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 at <<http://www.gnu.org/licenses/gpl.html>>
|
|
// for more details.
|
|
//
|
|
// GNU Lesser General Public License Usage
|
|
// This library is free software; you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation; either version 2.1 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This library 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 Lesser General Public License at <<http://www.gnu.org/licenses/lgpl-2.1.html>>
|
|
// for more details.
|
|
//
|
|
//##################################################################################################
|
|
|
|
#include "cafTrackBallBasedNavigation.h"
|
|
|
|
#include "cafViewer.h"
|
|
#include "cvfCamera.h"
|
|
#include "cvfScene.h"
|
|
#include "cvfModel.h"
|
|
#include "cvfViewport.h"
|
|
#include "cvfHitItemCollection.h"
|
|
#include "cvfRay.h"
|
|
#include "cvfManipulatorTrackball.h"
|
|
|
|
#include <QDebug>
|
|
#include <QInputEvent>
|
|
|
|
#include <cmath>
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
caf::TrackBallBasedNavigation::TrackBallBasedNavigation() :
|
|
m_isRotCenterInitialized(false),
|
|
m_isNavigating(false),
|
|
m_hasMovedMouseDuringNavigation(false),
|
|
m_isZooming(false),
|
|
m_lastPosX(0),
|
|
m_lastPosY(0),
|
|
m_lastWheelZoomPosX(-1),
|
|
m_lastWheelZoomPosY(-1),
|
|
m_consumeEvents(false)
|
|
{
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
caf::TrackBallBasedNavigation::~TrackBallBasedNavigation()
|
|
{
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void caf::TrackBallBasedNavigation::init()
|
|
{
|
|
m_trackball = new cvf::ManipulatorTrackball;
|
|
m_trackball->setCamera(m_viewer->mainCamera());
|
|
m_isRotCenterInitialized = false;
|
|
m_isRotationEnabled = true;
|
|
m_hasMovedMouseDuringNavigation = false;
|
|
m_isNavigating = false;
|
|
m_isZooming = false;
|
|
m_lastPosX = 0;
|
|
m_lastPosY = 0;
|
|
m_lastWheelZoomPosX = -1;
|
|
m_lastWheelZoomPosY = -1;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void caf::TrackBallBasedNavigation::initializeRotationCenter()
|
|
{
|
|
if (m_isRotCenterInitialized
|
|
|| m_trackball.isNull()
|
|
|| !m_viewer->currentScene()
|
|
|| !m_viewer->currentScene()->boundingBox().isValid())
|
|
{
|
|
return;
|
|
}
|
|
|
|
cvf::Vec3d pointOfInterest = m_viewer->currentScene()->boundingBox().center();
|
|
|
|
this->setPointOfInterest(pointOfInterest);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
/// Repositions and orients the camera to view the rotation point along the
|
|
/// direction "alongDirection". The distance to the rotation point is maintained.
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void caf::TrackBallBasedNavigation::setView( const cvf::Vec3d& alongDirection, const cvf::Vec3d& upDirection )
|
|
{
|
|
m_trackball->setView(alongDirection, upDirection);
|
|
/*
|
|
if (m_camera.isNull()) return;
|
|
|
|
Vec3d dir = alongDirection;
|
|
if (!dir.normalize()) return;
|
|
Vec3d up = upDirection;
|
|
if(!up.normalize()) up = Vec3d::Z_AXIS;
|
|
|
|
if((up * dir) < 1e-2) up = dir.perpendicularVector();
|
|
|
|
Vec3d cToE = m_camera->position() - m_rotationPoint;
|
|
Vec3d newEye = m_rotationPoint - cToE.length() * dir;
|
|
|
|
m_camera->setFromLookAt(newEye, m_rotationPoint, upDirection);
|
|
*/
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::Vec3d caf::TrackBallBasedNavigation::pointOfInterest()
|
|
{
|
|
initializeRotationCenter();
|
|
return m_pointOfInterest;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void caf::TrackBallBasedNavigation::setPointOfInterest(cvf::Vec3d poi)
|
|
{
|
|
m_pointOfInterest = poi;
|
|
m_trackball->setRotationPoint(poi);
|
|
m_isRotCenterInitialized = true;
|
|
m_viewer->updateParallelProjectionCameraPosFromPointOfInterestMove(m_pointOfInterest);
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void caf::TrackBallBasedNavigation::pickAndSetPointOfInterest(int winPosX, int winPosY)
|
|
{
|
|
cvf::HitItemCollection hic;
|
|
bool hitSomething = m_viewer->rayPick( winPosX, winPosY, &hic);
|
|
|
|
if (hitSomething)
|
|
{
|
|
cvf::Vec3d pointOfInterest = hic.firstItem()->intersectionPoint();
|
|
|
|
if (m_viewer->isMousePosWithinComparisonView( winPosX, winPosY ))
|
|
{
|
|
pointOfInterest -= m_viewer->comparisonViewEyePointOffset();
|
|
}
|
|
|
|
this->setPointOfInterest(pointOfInterest);
|
|
}
|
|
else
|
|
{
|
|
initializeRotationCenter();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void caf::TrackBallBasedNavigation::updatePointOfInterestDuringZoomIfNecessary(int winPosX, int winPosY)
|
|
{
|
|
if (shouldRaytraceForNewPoiDuringWheelZoom(winPosX, winPosY))
|
|
{
|
|
this->pickAndSetPointOfInterest(winPosX, winPosY);
|
|
updateWheelZoomPosition(winPosX, winPosY);
|
|
}
|
|
else
|
|
{
|
|
initializeRotationCenter();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void caf::TrackBallBasedNavigation::forcePointOfInterestUpdateDuringNextWheelZoom()
|
|
{
|
|
m_lastWheelZoomPosX = -1;
|
|
m_lastWheelZoomPosY = -1;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void caf::TrackBallBasedNavigation::zoomAlongRay(cvf::Ray* ray, int delta)
|
|
{
|
|
if (ray && abs(delta) > 0)
|
|
{
|
|
cvf::Vec3d pos, vrp, up;
|
|
m_viewer->mainCamera()->toLookAt(&pos, &vrp, &up);
|
|
|
|
double scale = delta/8.0 * 1.0/150 * (pos - m_pointOfInterest).length();
|
|
cvf::Vec3d trans = scale * ray->direction();
|
|
cvf::Vec3d newPos = pos + trans;
|
|
cvf::Vec3d newVrp = vrp + trans;
|
|
|
|
m_viewer->mainCamera()->setFromLookAt(newPos, newVrp, up );
|
|
m_viewer->updateParallelProjectionHeightFromMoveZoom(m_pointOfInterest);
|
|
m_viewer->updateParallelProjectionCameraPosFromPointOfInterestMove(m_pointOfInterest);
|
|
|
|
// Ceeviz Workaround for #3697:
|
|
// Ceeviz may create a singular projection*view matrix internally. In which case we need to revert.
|
|
cvf::Mat4d projectionMatrix = m_viewer->mainCamera()->projectionMatrix();
|
|
cvf::Mat4d viewMatrix = m_viewer->mainCamera()->viewMatrix();
|
|
cvf::Mat4d multMatrix = projectionMatrix * viewMatrix;
|
|
double determinant = std::fabs(multMatrix.determinant());
|
|
|
|
if (determinant < 1.0e-15)
|
|
{
|
|
m_viewer->mainCamera()->setFromLookAt(pos, vrp, up);
|
|
m_viewer->updateParallelProjectionHeightFromMoveZoom(m_pointOfInterest);
|
|
m_viewer->updateParallelProjectionCameraPosFromPointOfInterestMove(m_pointOfInterest);
|
|
#ifndef NDEBUG
|
|
projectionMatrix = m_viewer->mainCamera()->projectionMatrix();
|
|
viewMatrix = m_viewer->mainCamera()->viewMatrix();
|
|
multMatrix = projectionMatrix * viewMatrix;
|
|
determinant = std::fabs(multMatrix.determinant());
|
|
CVF_ASSERT(determinant > 1.0e-15);
|
|
#endif
|
|
}
|
|
|
|
m_viewer->navigationPolicyUpdate();
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void caf::TrackBallBasedNavigation::cvfEventPos(int qtX, int qtY, int* cvfX, int* cvfY)
|
|
{
|
|
*cvfX = qtX;
|
|
*cvfY = m_viewer->height() - qtY;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
cvf::ref<cvf::Ray> caf::TrackBallBasedNavigation::createZoomRay(int cvfXPos, int cvfYPos)
|
|
{
|
|
cvf::ref<cvf::Ray> ray;
|
|
cvf::Camera* cam = m_viewer->mainCamera();
|
|
ray = cam->rayFromWindowCoordinates(cvfXPos, cvfYPos);
|
|
|
|
if (ray.notNull() && cam->projection() == cvf::Camera::ORTHO)
|
|
{
|
|
cvf::Vec3d camDir = cam->direction();
|
|
cvf::Plane focusPlane;
|
|
focusPlane.setFromPointAndNormal(m_pointOfInterest, -camDir);
|
|
cvf::Vec3d intersectionPoint;
|
|
ray->planeIntersect(focusPlane, &intersectionPoint);
|
|
|
|
cvf::ref<cvf::Ray> orthoZoomRay = new cvf::Ray();
|
|
orthoZoomRay->setOrigin(cam->position());
|
|
orthoZoomRay->setDirection((intersectionPoint - cam->position()).getNormalized());
|
|
ray = orthoZoomRay;
|
|
}
|
|
|
|
return ray;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void caf::TrackBallBasedNavigation::updateWheelZoomPosition(int winPosX, int winPosY)
|
|
{
|
|
m_lastWheelZoomPosX = winPosX;
|
|
m_lastWheelZoomPosY = winPosY;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
bool caf::TrackBallBasedNavigation::shouldRaytraceForNewPoiDuringWheelZoom(int winPosX, int winPosY) const
|
|
{
|
|
// Raytrace if the last zoom position isn't set
|
|
if (m_lastWheelZoomPosX == -1 || m_lastWheelZoomPosY == -1)
|
|
{
|
|
return true;
|
|
}
|
|
int diffX = winPosX - m_lastWheelZoomPosX;
|
|
int diffY = winPosY - m_lastWheelZoomPosY;
|
|
|
|
const int pixelThreshold = 5;
|
|
if (diffX * diffX + diffY * diffY > pixelThreshold * pixelThreshold)
|
|
{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
#include <QMouseEvent>
|
|
|
|
//#include <windows.h>
|
|
//
|
|
//#pragma warning(disable:4996)
|
|
//void openDebugWindow()
|
|
//{
|
|
// AllocConsole();
|
|
// freopen("conin$", "r", stdin);
|
|
// freopen("conout$", "w", stdout);
|
|
// freopen("conout$", "w", stderr);
|
|
//}
|
|
//
|
|
//#include <iostream>
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
void caf::RotationSensitivityCalculator::init(QMouseEvent* eventAtRotationStart)
|
|
{
|
|
m_lastPosX = eventAtRotationStart->x();
|
|
m_lastPosY = eventAtRotationStart->y();
|
|
|
|
#if QT_VERSION >= 0x050000
|
|
m_lastTime = eventAtRotationStart->timestamp();
|
|
#endif
|
|
}
|
|
|
|
//--------------------------------------------------------------------------------------------------
|
|
///
|
|
//--------------------------------------------------------------------------------------------------
|
|
double caf::RotationSensitivityCalculator::calculateSensitivity(QMouseEvent* eventWhenRotating )
|
|
{
|
|
double sensitivity = 1.0;
|
|
|
|
if ( m_isEnabled )
|
|
{
|
|
if ( m_fixedSensitivity == std::numeric_limits<double>::infinity() )
|
|
{
|
|
#if QT_VERSION >= 0x050000
|
|
auto presentTime = eventWhenRotating->timestamp();
|
|
unsigned long timeSinceLast = presentTime - m_lastTime;
|
|
if ( timeSinceLast == 0 ) timeSinceLast = 1; // one millisecond
|
|
|
|
int deltaX = eventWhenRotating->x() - m_lastPosX;
|
|
int deltaY = eventWhenRotating->y() - m_lastPosY;
|
|
|
|
cvf::Vec2d mouseVelocity(deltaX, deltaY);
|
|
mouseVelocity /= 1.0e-3*timeSinceLast;
|
|
|
|
double mouseVelocityLength = mouseVelocity.length();
|
|
double mouseVelocityLengthCorr = 0.1*mouseVelocityLength + 0.9*m_lastMouseVelocityLenght;
|
|
|
|
double slowLimit = 170.0;
|
|
|
|
if ( mouseVelocityLengthCorr < slowLimit ) sensitivity = mouseVelocityLengthCorr*mouseVelocityLengthCorr/(slowLimit*slowLimit);
|
|
|
|
m_lastPosX = eventWhenRotating->x();
|
|
m_lastPosY = eventWhenRotating->y();
|
|
m_lastTime = eventWhenRotating->timestamp();
|
|
m_lastMouseVelocityLenght = 0.8*mouseVelocityLength + 0.2*m_lastMouseVelocityLenght;
|
|
|
|
//openDebugWindow();
|
|
//std::cout << sensitivity << " Speed: Raw: " << mouseVelocityLength << " Smooth: " << mouseVelocityLengthCorr << " \tDelta " << deltaX << ", " << deltaY << " "<< timeSinceLast << std::endl;
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
sensitivity = m_fixedSensitivity;
|
|
}
|
|
}
|
|
|
|
return sensitivity;
|
|
}
|