OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-25 18:55:39 -06:00
Code Issues Packages Projects Releases Wiki Activity
22abc52e7a
ResInsight/ApplicationCode/Commands/WellPathCommands/PointTangentManipulator/RicPointTangentManipulator.cpp

915 lines
32 KiB
C++
Raw Blame History

/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2013- Statoil ASA
// Copyright (C) 2013- Ceetron Solutions AS
//
// ResInsight 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.
//
// ResInsight 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.
//
/////////////////////////////////////////////////////////////////////////////////
#include "RicPointTangentManipulator.h"
#include "cafViewer.h"
#include "cvfCamera.h"
#include "cvfDrawableGeo.h"
#include "cvfHitItemCollection.h"
#include "cvfModelBasicList.h"
#include "cvfPart.h"
#include "cvfRay.h"
#include <QDebug>
#include <QMouseEvent>
#include "RivPartPriority.h"
#include "cafPdmUiCommandSystemProxy.h"
#include "RimModeledWellPath.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicPointTangentManipulator::RicPointTangentManipulator(caf::Viewer* viewer)
: m_viewer(viewer)
{
m_partManager = new RicPointTangentManipulatorPartMgr;
m_viewer->installEventFilter(this);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicPointTangentManipulator::~RicPointTangentManipulator()
{
if (m_viewer) m_viewer->removeEventFilter(this);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulator::setOrigin(const cvf::Vec3d& origin)
{
m_partManager->setOrigin(origin);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulator::setTangent(const cvf::Vec3d& tangent)
{
m_partManager->setTangent(tangent);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulator::setHandleSize(double handleSize)
{
m_partManager->setHandleSize(handleSize);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulator::appendPartsToModel(cvf::ModelBasicList* model)
{
m_partManager->appendPartsToModel(model);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicPointTangentManipulator::eventFilter(QObject *obj, QEvent* inputEvent)
{
if (inputEvent->type() == QEvent::MouseButtonPress)
{
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(inputEvent);
if (mouseEvent->button() == Qt::LeftButton)
{
cvf::HitItemCollection hitItems;
if (m_viewer->rayPick(mouseEvent->x(), mouseEvent->y(), &hitItems))
{
m_partManager->tryToActivateManipulator(hitItems.firstItem());
if(m_partManager->isManipulatorActive())
{
emit notifySelected();
return true;
}
}
}
}
else if (inputEvent->type() == QEvent::MouseMove)
{
if (m_partManager->isManipulatorActive())
{
QMouseEvent* mouseEvent = static_cast<QMouseEvent*>(inputEvent);
//qDebug() << "Inside mouse move";
//qDebug() << mouseEvent->pos();
int translatedMousePosX = mouseEvent->pos().x();
int translatedMousePosY = m_viewer->height() - mouseEvent->pos().y();
cvf::ref<cvf::Ray> ray = m_viewer->mainCamera()->rayFromWindowCoordinates(translatedMousePosX, translatedMousePosY);
if (!ray.isNull())
{
m_partManager->updateManipulatorFromRay(ray.p());
cvf::Vec3d origin;
cvf::Vec3d tangent;
m_partManager->originAndTangent(&origin, &tangent);
emit notifyUpdate(origin, tangent);
return true;
}
}
}
else if (inputEvent->type() == QEvent::MouseButtonRelease)
{
if (m_partManager->isManipulatorActive())
{
m_partManager->endManipulator();
cvf::Vec3d origin;
cvf::Vec3d tangent;
m_partManager->originAndTangent(&origin, &tangent);
emit notifyUpdate(origin, tangent);
emit notifyDragFinished();
return true;
}
}
return false;
}
//==================================================================================================
///
///
//==================================================================================================
#include "RicPointTangentManipulator.h"
#include "cafBoxManipulatorGeometryGenerator.h"
#include "cafEffectGenerator.h"
#include "cafLine.h"
#include "cafSelectionManager.h"
#include "cvfBoxGenerator.h"
#include "cvfDrawableGeo.h"
#include "cvfGeometryBuilderFaceList.h"
#include "cvfModelBasicList.h"
#include "cvfPart.h"
#include "cvfPrimitiveSetIndexedUInt.h"
#include "cvfPrimitiveSetIndexedUShort.h"
#include "cvfRay.h"
#include "cvfPrimitiveSetDirect.h"
#include "cvfHitItem.h"
#include <QDebug>
#include "cvfGeometryBuilderTriangles.h"
#include "cvfGeometryUtils.h"
//
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicPointTangentManipulatorPartMgr::RicPointTangentManipulatorPartMgr()
: m_tangentOnStartManipulation(cvf::Vec3d::UNDEFINED),
m_originOnStartManipulation(cvf::Vec3d::UNDEFINED),
m_currentHandleIndex(cvf::UNDEFINED_SIZE_T),
m_handleSize(1.0)
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicPointTangentManipulatorPartMgr::~RicPointTangentManipulatorPartMgr()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::setOrigin(const cvf::Vec3d& origin)
{
if (isManipulatorActive()) return;
m_origin = origin;
if (m_originOnStartManipulation.isUndefined()) m_originOnStartManipulation = origin;
clearAllGeometryAndParts();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::setTangent(const cvf::Vec3d& tangent)
{
if(isManipulatorActive()) return;
m_tangent = tangent;
if (m_tangentOnStartManipulation.isUndefined()) m_tangentOnStartManipulation = m_tangent;
clearAllGeometryAndParts();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::setHandleSize(double handleSize)
{
m_handleSize = handleSize;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::originAndTangent(cvf::Vec3d* origin, cvf::Vec3d* tangent)
{
*origin = m_origin;
*tangent = m_tangent;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicPointTangentManipulatorPartMgr::isManipulatorActive() const
{
return m_currentHandleIndex != cvf::UNDEFINED_SIZE_T;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::appendPartsToModel(cvf::ModelBasicList* model)
{
if (!m_handleParts.size())
{
recreateAllGeometryAndParts();
}
for (size_t i = 0; i < m_handleParts.size(); i++)
{
model->addPart(m_handleParts.at(i));
}
for (auto activeModePart: m_activeDragModeParts)
{
model->addPart(activeModePart.p());
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::tryToActivateManipulator(const cvf::HitItem* hitItem)
{
endManipulator();
if (!hitItem) return;
const cvf::Part* pickedPart = hitItem->part();
const cvf::Vec3d intersectionPoint = hitItem->intersectionPoint();
if (!pickedPart) return;
for (size_t i = 0; i < m_handleParts.size(); i++)
{
if (pickedPart == m_handleParts.at(i))
{
m_initialPickPoint = intersectionPoint;
m_tangentOnStartManipulation = m_tangent;
m_originOnStartManipulation = m_origin;
m_currentHandleIndex = i;
}
}
}
//--------------------------------------------------------------------------------------------------
/// Calculate new origin and tangent based on the new ray position
/// Clear geometry to trigger regeneration
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::updateManipulatorFromRay(const cvf::Ray* newMouseRay)
{
if (!isManipulatorActive()) return;
if ( m_handleIds[m_currentHandleIndex] == HORIZONTAL_PLANE )
{
cvf::Plane plane;
plane.setFromPointAndNormal(m_origin, cvf::Vec3d::Z_AXIS);
cvf::Vec3d newIntersection;
newMouseRay->planeIntersect(plane, &newIntersection);
cvf::Vec3d newOrigin = m_originOnStartManipulation + (newIntersection - m_initialPickPoint);
m_origin = newOrigin;
}
else if ( m_handleIds[m_currentHandleIndex] == VERTICAL_AXIS )
{
cvf::Plane plane;
cvf::Vec3d planeNormal = (newMouseRay->direction() ^ cvf::Vec3d::Z_AXIS) ^ cvf::Vec3d::Z_AXIS;
double length = planeNormal.length();
if (length < 1e-5) return;
planeNormal /= length;
plane.setFromPointAndNormal(m_initialPickPoint, planeNormal );
cvf::Vec3d newIntersection;
newMouseRay->planeIntersect(plane, &newIntersection);
cvf::Vec3d newOrigin = m_originOnStartManipulation;
newOrigin.z() += (newIntersection.z() - m_initialPickPoint.z());
m_origin = newOrigin;
}
//m_tangent = newTangent;
clearAllGeometryAndParts();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::endManipulator()
{
m_currentHandleIndex = cvf::UNDEFINED_SIZE_T;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::clearAllGeometryAndParts()
{
m_handleIds.clear();
m_handleParts.clear();
m_activeDragModeParts.clear();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::recreateAllGeometryAndParts()
{
createAllHandleParts();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::createAllHandleParts()
{
createHorizontalPlaneHandle();
createVerticalAxisHandle();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::createHorizontalPlaneHandle()
{
using namespace cvf;
cvf::ref<cvf::Vec3fArray> vertexArray = new cvf::Vec3fArray(6);
vertexArray->set(0, {-1, -1, 0} );
vertexArray->set(1, { 1, -1, 0});
vertexArray->set(2, { 1, 1, 0});
vertexArray->set(3, {-1, -1, 0});
vertexArray->set(4, { 1, 1, 0});
vertexArray->set(5, {-1, 1, 0});
Vec3f origin(m_origin);
for (cvf::Vec3f& vx: *vertexArray)
{
vx *= 0.5*m_handleSize;
vx += origin;
}
ref<DrawableGeo> geo = createTriangelDrawableGeo(vertexArray.p());
HandleType handleId = HORIZONTAL_PLANE;
cvf::Color4f color = cvf::Color4f(1.0f, 0.0f, 1.0f, 0.5f);
cvf::String partName("PointTangentManipulator Horizontal Plane Handle");
addHandlePart(geo.p(), color, handleId, partName);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::createVerticalAxisHandle()
{
using namespace cvf;
cvf::ref< cvf::GeometryBuilderTriangles> geomBuilder = new cvf::GeometryBuilderTriangles;
cvf::GeometryUtils::createBox({-0.3f, -0.3f, -1.0f}, { 0.3f, 0.3f, 1.0f}, geomBuilder.p());
cvf::ref<cvf::Vec3fArray> vertexArray = geomBuilder->vertices();
cvf::ref<cvf::UIntArray> indexArray = geomBuilder->triangles();
Vec3f origin(m_origin);
for (cvf::Vec3f& vx: *vertexArray)
{
vx *= 0.5*m_handleSize;
vx += origin;
}
ref<DrawableGeo> geo = createIndexedTriangelDrawableGeo(vertexArray.p(), indexArray.p());
HandleType handleId = VERTICAL_AXIS;
cvf::Color4f color = cvf::Color4f(0.0f, 0.2f, 0.8f, 0.5f);
cvf::String partName("PointTangentManipulator Vertical Axis Handle");
addHandlePart(geo.p(), color, handleId, partName);
}
#if 0
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::createAzimuthHandle()
{
using namespace cvf;
cvf::ref< cvf::GeometryBuilderTriangles> geomBuilder = new cvf::GeometryBuilderTriangles;
cvf::GeometryUtils::createDisc(1.3, 1.1, 16, geomBuilder.p());
cvf::ref<cvf::Vec3fArray> vertexArray = geomBuilder->vertices();
cvf::ref<cvf::UIntArray> indexArray = geomBuilder->triangles();
Vec3f origin(m_origin);
for (cvf::Vec3f& vx: *vertexArray)
{
vx *= 0.5*m_handleSize;
vx += origin;
}
ref<DrawableGeo> geo = createIndexedTriangelDrawableGeo(vertexArray.p(), indexArray.p());
HandleType handleId = AZIMUTH;
cvf::Color4f color = cvf::Color4f(0.0f, 0.2f, 0.8f, 0.5f);
cvf::String partName("PointTangentManipulator Azimuth Handle");
addHandlePart(geo.p(), color, handleId, partName);
}
#endif
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::DrawableGeo> RicPointTangentManipulatorPartMgr::createIndexedTriangelDrawableGeo(cvf::Vec3fArray* triangleVertexArray,
cvf::UIntArray* triangleIndices)
{
using namespace cvf;
ref<DrawableGeo> geo = new DrawableGeo;
ref<PrimitiveSetIndexedUInt> primSet = new PrimitiveSetIndexedUInt(PT_TRIANGLES, triangleIndices);
geo->setVertexArray(triangleVertexArray);
geo->addPrimitiveSet(primSet.p());
geo->computeNormals();
return geo;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::DrawableGeo> RicPointTangentManipulatorPartMgr::createTriangelDrawableGeo(cvf::Vec3fArray* triangleVertexArray)
{
using namespace cvf;
ref<DrawableGeo> geo = new DrawableGeo;
geo->setVertexArray(triangleVertexArray);
ref<cvf::PrimitiveSetDirect> primSet = new cvf::PrimitiveSetDirect(cvf::PT_TRIANGLES);
primSet->setIndexCount(triangleVertexArray->size());
geo->addPrimitiveSet(primSet.p());
geo->computeNormals();
return geo;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::addHandlePart(cvf::DrawableGeo* geo,
const cvf::Color4f& color,
HandleType handleId,
const cvf::String& partName)
{
cvf::ref<cvf::Part> handlePart = createPart(geo, color, partName);
m_handleParts.push_back(handlePart.p());
m_handleIds.push_back(handleId);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicPointTangentManipulatorPartMgr::addActiveModePart(cvf::DrawableGeo* geo,
const cvf::Color4f& color,
HandleType handleId,
const cvf::String& partName)
{
cvf::ref<cvf::Part> handlePart = createPart(geo, color, partName);
m_activeDragModeParts.push_back(handlePart.p());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::Part> RicPointTangentManipulatorPartMgr::createPart(cvf::DrawableGeo* geo,
const cvf::Color4f& color,
const cvf::String& partName)
{
cvf::ref<cvf::Part> part = new cvf::Part;
part->setName(partName);
part->setDrawable(geo);
part->updateBoundingBox();
caf::SurfaceEffectGenerator surfaceGen(color, caf::PO_1);
cvf::ref<cvf::Effect> eff = surfaceGen.generateCachedEffect();
part->setEffect(eff.p());
if (color.a() < 1.0) part->setPriority(RivPartPriority::Transparent);
return part;
}
//==================================================================================================
///
///
///
//==================================================================================================
namespace caf
{
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
PdmUi3dObjectEditorHandle::PdmUi3dObjectEditorHandle()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
PdmUi3dObjectEditorHandle::~PdmUi3dObjectEditorHandle()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void PdmUi3dObjectEditorHandle::setViewer(caf::Viewer* ownerViewer)
{
// Not allowed to change viewer. Should be constructor argument, but makes factory stuff difficult.
CAF_ASSERT(m_ownerViewer.isNull());
m_ownerViewer = ownerViewer;
}
}
//==================================================================================================
///
///
///
//==================================================================================================
#include "cafSelectionManager.h"
#include "RimWellPathGeometryDef.h"
namespace caf
{
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
PdmUiSelectionVisualizer3d::PdmUiSelectionVisualizer3d(caf::Viewer* ownerViewer)
: m_ownerViewer(ownerViewer)
{
this->setParent(ownerViewer); // Makes this owned by the viewer.
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
PdmUiSelectionVisualizer3d::~PdmUiSelectionVisualizer3d()
{
for (auto editor: m_active3DEditors)
{
delete editor;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void PdmUiSelectionVisualizer3d::updateVisibleEditors()
{
for (auto editor: m_active3DEditors)
{
if (editor) editor->updateUi();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void PdmUiSelectionVisualizer3d::onSelectionManagerSelectionChanged( const std::set<int>& changedSelectionLevels )
{
if (!changedSelectionLevels.count(0)) return;
for (auto editor: m_active3DEditors)
{
delete editor;
}
m_active3DEditors.clear();
if (!m_ownerViewer) return;
// Todo: How do we deduce the editor from the selected object ?
// Alt 1: Register the rim object type name as key in the factory as well
// Alt 2: Set the editor type name as PdmUiItem::setUiEditorTypeName
// Alt 3: Use a specific config-name in alt 2.
// Alt 4: Introduce a PdmUiItem::editorTypeName3d
std::vector<RimWellPathGeometryDef*> wellPathGeomDefs;
caf::SelectionManager::instance()->objectsByType(&wellPathGeomDefs);
for (auto geomDef: wellPathGeomDefs)
{
auto editor = new RicWellPathGeometry3dEditor();
editor->setViewer(m_ownerViewer);
editor->setPdmObject(geomDef);
m_active3DEditors.push_back(editor);
editor->updateUi();
}
m_ownerViewer->update();
}
} // caf
//==================================================================================================
///
///
///
//==================================================================================================
#include "RimWellPathTarget.h"
CAF_PDM_UI_3D_OBJECT_EDITOR_SOURCE_INIT(RicWellPathGeometry3dEditor);
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicWellPathGeometry3dEditor::RicWellPathGeometry3dEditor()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicWellPathGeometry3dEditor::~RicWellPathGeometry3dEditor()
{
for (auto targetEditor: m_targetEditors)
{
delete targetEditor;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicWellPathGeometry3dEditor::configureAndUpdateUi(const QString& uiConfigName)
{
RimWellPathGeometryDef* geomDef = dynamic_cast<RimWellPathGeometryDef*>(this->pdmObject());
for (auto targetEditor: m_targetEditors)
{
delete targetEditor;
}
m_targetEditors.clear();
if (!geomDef) return;
std::vector<RimWellPathTarget*> targets = geomDef->activeWellTargets();
for (auto target: targets)
{
auto targetEditor = new RicWellTarget3dEditor;
targetEditor->setViewer(m_ownerViewer);
targetEditor->setPdmObject(target);
m_targetEditors.push_back(targetEditor);
targetEditor->updateUi();
}
}
//==================================================================================================
///
///
///
//==================================================================================================
#include "RimWellPathTarget.h"
#include "RiuViewer.h"
#include "cafDisplayCoordTransform.h"
#include "Rim3dView.h"
#include "RimCase.h"
CAF_PDM_UI_3D_OBJECT_EDITOR_SOURCE_INIT(RicWellTarget3dEditor);
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicWellTarget3dEditor::RicWellTarget3dEditor()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicWellTarget3dEditor::~RicWellTarget3dEditor()
{
if (m_cvfModel.notNull() && m_ownerViewer)
{
// Could result in some circularities ....
m_ownerViewer->removeStaticModel(m_cvfModel.p());
}
RimWellPathTarget* oldTarget = dynamic_cast<RimWellPathTarget*>(this->pdmObject());
if (oldTarget)
{
oldTarget->m_targetType.uiCapability()->removeFieldEditor(this);
oldTarget->m_targetPoint.uiCapability()->removeFieldEditor(this);
oldTarget->m_azimuth.uiCapability()->removeFieldEditor(this);
oldTarget->m_inclination.uiCapability()->removeFieldEditor(this);
}
delete m_manipulator;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicWellTarget3dEditor::configureAndUpdateUi(const QString& uiConfigName)
{
RimWellPathTarget* target = dynamic_cast<RimWellPathTarget*>(this->pdmObject());
if ( !target || !target->isEnabled())
{
m_cvfModel->removeAllParts();
return;
}
RimWellPathGeometryDef* geomDef;
target->firstAncestorOrThisOfTypeAsserted(geomDef);
target->m_targetType.uiCapability()->addFieldEditor(this);
target->m_targetPoint.uiCapability()->addFieldEditor(this);
target->m_azimuth.uiCapability()->addFieldEditor(this);
target->m_inclination.uiCapability()->addFieldEditor(this);
if (m_manipulator.isNull())
{
m_manipulator = new RicPointTangentManipulator(m_ownerViewer);
QObject::connect(m_manipulator,
SIGNAL( notifyUpdate(const cvf::Vec3d& , const cvf::Vec3d& ) ),
this,
SLOT( slotUpdated(const cvf::Vec3d& , const cvf::Vec3d& ) ) );
QObject::connect(m_manipulator,
SIGNAL( notifySelected() ),
this,
SLOT( slotSelectedIn3D() ) );
QObject::connect(m_manipulator,
SIGNAL( notifyDragFinished() ),
this,
SLOT( slotDragFinished() ) );
m_cvfModel = new cvf::ModelBasicList;
m_ownerViewer->addStaticModelOnce(m_cvfModel.p());
}
cvf::ref<caf::DisplayCoordTransform> dispXf;
double handleSize = 1.0;
{
RiuViewer* viewer = dynamic_cast<RiuViewer*>(m_ownerViewer.data());
dispXf = viewer->ownerReservoirView()->displayCoordTransform();
Rim3dView* view = dynamic_cast<Rim3dView*>(viewer->ownerReservoirView());
handleSize = 0.7 * view->ownerCase()->characteristicCellSize();
}
m_manipulator->setOrigin(dispXf->transformToDisplayCoord( target->targetPointXYZ() + geomDef->referencePointXyz()));
m_manipulator->setTangent(target->tangent());
m_manipulator->setHandleSize(handleSize);
m_cvfModel->removeAllParts();
m_manipulator->appendPartsToModel(m_cvfModel.p());
m_cvfModel->updateBoundingBoxesRecursive();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicWellTarget3dEditor::cleanupBeforeSettingPdmObject()
{
RimWellPathTarget* oldTarget = dynamic_cast<RimWellPathTarget*>(this->pdmObject());
if (oldTarget)
{
oldTarget->m_targetType.uiCapability()->removeFieldEditor(this);
oldTarget->m_targetPoint.uiCapability()->removeFieldEditor(this);
oldTarget->m_azimuth.uiCapability()->removeFieldEditor(this);
oldTarget->m_inclination.uiCapability()->removeFieldEditor(this);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicWellTarget3dEditor::slotUpdated(const cvf::Vec3d& origin, const cvf::Vec3d& tangent)
{
RimWellPathTarget* target = dynamic_cast<RimWellPathTarget*>(this->pdmObject());
if ( !target)
{
return;
}
cvf::ref<caf::DisplayCoordTransform> dispXf;
{
RiuViewer* viewer = dynamic_cast<RiuViewer*>(m_ownerViewer.data());
dispXf = viewer->ownerReservoirView()->displayCoordTransform();
}
RimWellPathGeometryDef* geomDef;
target->firstAncestorOrThisOfTypeAsserted(geomDef);
cvf::Vec3d domainOrigin = dispXf->transformToDomainCoord( origin) - geomDef->referencePointXyz();
domainOrigin.z() = -domainOrigin.z();
QVariant originVariant = caf::PdmValueFieldSpecialization < cvf::Vec3d >::convert(domainOrigin);
target->enableFullUpdate(false);
caf::PdmUiCommandSystemProxy::instance()->setUiValueToField(target->m_targetPoint.uiCapability(), originVariant);
target->enableFullUpdate(true);
}
void RicWellTarget3dEditor::slotSelectedIn3D()
{
RimWellPathTarget* target = dynamic_cast<RimWellPathTarget*>(this->pdmObject());
if ( !target)
{
return;
}
caf::SelectionManager::instance()->setSelectedItemAtLevel(target, caf::SelectionManager::FIRST_LEVEL);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicWellTarget3dEditor::slotDragFinished()
{
RimWellPathTarget* target = dynamic_cast<RimWellPathTarget*>(this->pdmObject());
if ( !target)
{
return;
}
RimModeledWellPath* wellpath;
target->firstAncestorOrThisOfTypeAsserted(wellpath);
wellpath->scheduleUpdateOfDependentVisualization();
}
Reference in New Issue View Git Blame Copy Permalink