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

#7811 Modeled Well Path : Optionally show absolute coordinates

Browse Source
This commit is contained in:
Magne Sjaastad 2021-06-28 09:48:38 +02:00
parent eb3c52aeb1
commit 62d67a52c7
9 changed files with 241 additions and 99 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

76
ApplicationLibCode/Commands/WellPathCommands/PointTangentManipulator/RicWellTarget3dEditor.cpp
View File

@ -57,14 +57,7 @@ RicWellTarget3dEditor::~RicWellTarget3dEditor()
ownerRiuViewer->removeStaticModel( m_cvfModel.p() ); ownerRiuViewer->removeStaticModel( m_cvfModel.p() );
} }
RimWellPathTarget* oldTarget = dynamic_cast<RimWellPathTarget*>( this->pdmObject() ); removeAllFieldEditors();
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; delete m_manipulator;
} }
@ -88,10 +81,10 @@ void RicWellTarget3dEditor::configureAndUpdateUi( const QString& uiConfigName )
RimWellPathGeometryDef* geomDef; RimWellPathGeometryDef* geomDef;
target->firstAncestorOrThisOfTypeAsserted( geomDef ); target->firstAncestorOrThisOfTypeAsserted( geomDef );
target->m_targetType.uiCapability()->addFieldEditor( this ); for ( auto field : target->fieldsFor3dManipulator() )
target->m_targetPoint.uiCapability()->addFieldEditor( this ); {
target->m_azimuth.uiCapability()->addFieldEditor( this ); field->uiCapability()->addFieldEditor( this );
target->m_inclination.uiCapability()->addFieldEditor( this ); }
if ( m_manipulator.isNull() ) if ( m_manipulator.isNull() )
{ {
@ -127,14 +120,7 @@ void RicWellTarget3dEditor::configureAndUpdateUi( const QString& uiConfigName )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RicWellTarget3dEditor::cleanupBeforeSettingPdmObject() void RicWellTarget3dEditor::cleanupBeforeSettingPdmObject()
{ {
RimWellPathTarget* oldTarget = dynamic_cast<RimWellPathTarget*>( this->pdmObject() ); removeAllFieldEditors();
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 );
}
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -150,18 +136,38 @@ void RicWellTarget3dEditor::slotUpdated( const cvf::Vec3d& origin, const cvf::Ve
return; return;
} }
cvf::ref<caf::DisplayCoordTransform> dispXf = view->displayCoordTransform();
RimWellPathGeometryDef* geomDef; RimWellPathGeometryDef* geomDef;
target->firstAncestorOrThisOfTypeAsserted( geomDef ); target->firstAncestorOrThisOfTypeAsserted( geomDef );
if ( !geomDef ) return;
cvf::Vec3d domainOrigin = dispXf->transformToDomainCoord( origin ) - geomDef->anchorPointXyz(); cvf::ref<caf::DisplayCoordTransform> dispXf = view->displayCoordTransform();
domainOrigin.z() = -domainOrigin.z();
QVariant originVariant = caf::PdmValueFieldSpecialization<cvf::Vec3d>::convert( domainOrigin );
target->enableFullUpdate( false ); auto domainCoordXYZ = dispXf->transformToDomainCoord( origin );
caf::PdmUiCommandSystemProxy::instance()->setUiValueToField( target->m_targetPoint.uiCapability(), originVariant );
target->enableFullUpdate( true ); // If CTRL is pressed, modify the reference point instead of the well path target
bool modifyReferencePoint = ( QApplication::keyboardModifiers() & Qt::ControlModifier );
if ( modifyReferencePoint )
{
auto relativePositionXYZ = domainCoordXYZ - geomDef->anchorPointXyz();
auto delta = target->targetPointXYZ() - relativePositionXYZ;
auto currentRefPointXyz = geomDef->anchorPointXyz();
auto newRefPointXyz = currentRefPointXyz - delta;
geomDef->setReferencePointXyz( newRefPointXyz );
geomDef->changed.send( false );
geomDef->updateWellPathVisualization( true );
for ( auto wt : geomDef->activeWellTargets() )
{
wt->updateConnectedEditors();
}
}
else
{
cvf::Vec3d relativePositionXYD = domainCoordXYZ - geomDef->anchorPointXyz();
relativePositionXYD.z() = -relativePositionXYD.z();
target->updateFrom3DManipulator( relativePositionXYD );
}
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -191,3 +197,17 @@ void RicWellTarget3dEditor::slotDragFinished()
target->onMoved(); target->onMoved();
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicWellTarget3dEditor::removeAllFieldEditors()
{
if ( RimWellPathTarget* oldTarget = dynamic_cast<RimWellPathTarget*>( this->pdmObject() ) )
{
for ( auto field : oldTarget->fieldsFor3dManipulator() )
{
field->uiCapability()->removeFieldEditor( this );
}
}
}

10
ApplicationLibCode/Commands/WellPathCommands/PointTangentManipulator/RicWellTarget3dEditor.h
View File

@ -20,18 +20,19 @@
#include "Ric3dObjectEditorHandle.h" #include "Ric3dObjectEditorHandle.h"
class RicPointTangentManipulator;
#include "cvfObject.h" #include "cvfObject.h"
#include "cvfVector3.h" #include "cvfVector3.h"
#include <QPointer>
class RicPointTangentManipulator;
namespace cvf namespace cvf
{ {
class ModelBasicList; class ModelBasicList;
} }
class QString; class QString;
#include <QPointer>
class RicWellTarget3dEditor : public Ric3dObjectEditorHandle class RicWellTarget3dEditor : public Ric3dObjectEditorHandle
{ {
@ -50,6 +51,9 @@ private slots:
void slotSelectedIn3D(); void slotSelectedIn3D();
void slotDragFinished(); void slotDragFinished();
private:
void removeAllFieldEditors();
private: private:
QPointer<RicPointTangentManipulator> m_manipulator; QPointer<RicPointTangentManipulator> m_manipulator;
cvf::ref<cvf::ModelBasicList> m_cvfModel; cvf::ref<cvf::ModelBasicList> m_cvfModel;

1
ApplicationLibCode/Commands/WellPathCommands/RicNewWellPathLateralAtDepthFeature.cpp
View File

@ -100,6 +100,7 @@ RimWellPath* RicNewWellPathLateralAtDepthFeature::createLateralAtMeasuredDepth(
->clippedPointSubset( parentWellPath->wellPathGeometry()->measuredDepths().front(), parentWellMD ); ->clippedPointSubset( parentWellPath->wellPathGeometry()->measuredDepths().front(), parentWellMD );
newModeledWellPath->geometryDefinition()->setMdAtFirstTarget( measuredDepths.back() ); newModeledWellPath->geometryDefinition()->setMdAtFirstTarget( measuredDepths.back() );
// newModeledWellPath->geometryDefinition()->setReferencePointXyz( pointVector.back() );
newModeledWellPath->geometryDefinition()->setFixedWellPathPoints( pointVector ); newModeledWellPath->geometryDefinition()->setFixedWellPathPoints( pointVector );
newModeledWellPath->geometryDefinition()->setFixedMeasuredDepths( measuredDepths ); newModeledWellPath->geometryDefinition()->setFixedMeasuredDepths( measuredDepths );
} }

5
ApplicationLibCode/ProjectDataModel/RimModeledWellPath.cpp
View File

@ -265,14 +265,15 @@ void RimModeledWellPath::updateTieInLocationFromParentWell()
parentWellPath = tieIn->parentWell(); parentWellPath = tieIn->parentWell();
auto targets = m_geometryDefinition->activeWellTargets(); auto targets = m_geometryDefinition->activeWellTargets();
if ( parentWellPath && !targets.empty() ) if ( parentWellPath && !targets.empty() && parentWellPath->wellPathGeometry() &&
!parentWellPath->wellPathGeometry()->measuredDepths().empty() )
{ {
auto [pointVector, measuredDepths] = auto [pointVector, measuredDepths] =
parentWellPath->wellPathGeometry() parentWellPath->wellPathGeometry()
->clippedPointSubset( parentWellPath->wellPathGeometry()->measuredDepths().front(), ->clippedPointSubset( parentWellPath->wellPathGeometry()->measuredDepths().front(),
tieIn->tieInMeasuredDepth() ); tieIn->tieInMeasuredDepth() );
if ( pointVector.size() > 2u ) if ( pointVector.size() >= 2u )
{ {
auto firstTarget = targets.front(); auto firstTarget = targets.front();
firstTarget->setPointXYZ( pointVector.back() ); firstTarget->setPointXYZ( pointVector.back() );

19
ApplicationLibCode/ProjectDataModel/RimWellPathGeometryDef.cpp
View File

@ -84,6 +84,8 @@ RimWellPathGeometryDef::RimWellPathGeometryDef()
m_wellTargets.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::TOP ); m_wellTargets.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::TOP );
m_wellTargets.uiCapability()->setCustomContextMenuEnabled( true ); m_wellTargets.uiCapability()->setCustomContextMenuEnabled( true );
CAF_PDM_InitField( &m_showAbsolutePosForWellTargets, "ShowAbsolutePosForWellTargets", false, "Show UTM Coords", "", "", "" );
CAF_PDM_InitScriptableField( &m_useAutoGeneratedTargetAtSeaLevel, CAF_PDM_InitScriptableField( &m_useAutoGeneratedTargetAtSeaLevel,
"UseAutoGeneratedTargetAtSeaLevel", "UseAutoGeneratedTargetAtSeaLevel",
true, true,
@ -125,6 +127,14 @@ cvf::Vec3d RimWellPathGeometryDef::anchorPointXyz() const
return xyz; return xyz;
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec3d RimWellPathGeometryDef::anchorPointXyd() const
{
return m_referencePointUtmXyd();
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -284,6 +294,14 @@ double RimWellPathGeometryDef::sphereRadiusFactor() const
return m_sphereRadiusFactor(); return m_sphereRadiusFactor();
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimWellPathGeometryDef::showAbsoluteCoordinates() const
{
return m_showAbsolutePosForWellTargets;
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -459,6 +477,7 @@ void RimWellPathGeometryDef::defineUiOrdering( QString uiConfigName, caf::PdmUiO
group->add( &m_sphereColor ); group->add( &m_sphereColor );
group->add( &m_sphereRadiusFactor ); group->add( &m_sphereRadiusFactor );
uiOrdering.add( &m_showAbsolutePosForWellTargets );
uiOrdering.add( &m_wellTargets ); uiOrdering.add( &m_wellTargets );
uiOrdering.add( &m_pickPointsEnabled ); uiOrdering.add( &m_pickPointsEnabled );

17
ApplicationLibCode/ProjectDataModel/RimWellPathGeometryDef.h
View File

@ -50,6 +50,7 @@ public:
~RimWellPathGeometryDef() override; ~RimWellPathGeometryDef() override;
cvf::Vec3d anchorPointXyz() const; cvf::Vec3d anchorPointXyz() const;
cvf::Vec3d anchorPointXyd() const;
void setReferencePointXyz( const cvf::Vec3d& refPointXyz ); void setReferencePointXyz( const cvf::Vec3d& refPointXyz );
double airGap() const; double airGap() const;
@ -87,6 +88,7 @@ public:
bool showSpheres() const; bool showSpheres() const;
cvf::Color3f sphereColor() const; cvf::Color3f sphereColor() const;
double sphereRadiusFactor() const; double sphereRadiusFactor() const;
bool showAbsoluteCoordinates() const;
protected: protected:
void defineCustomContextMenu( const caf::PdmFieldHandle* fieldNeedingMenu, QMenu* menu, QWidget* fieldEditorWidget ) override; void defineCustomContextMenu( const caf::PdmFieldHandle* fieldNeedingMenu, QMenu* menu, QWidget* fieldEditorWidget ) override;
@ -116,13 +118,16 @@ private:
caf::PdmField<double> m_airGap; caf::PdmField<double> m_airGap;
caf::PdmField<double> m_mdAtFirstTarget; caf::PdmField<double> m_mdAtFirstTarget;
caf::PdmChildArrayField<RimWellPathTarget*> m_wellTargets; caf::PdmChildArrayField<RimWellPathTarget*> m_wellTargets;
caf::PdmField<bool> m_useAutoGeneratedTargetAtSeaLevel; caf::PdmField<bool> m_showAbsolutePosForWellTargets;
caf::PdmChildField<RimWellPathTarget*> m_autoTargetAtSeaLevel;
caf::PdmField<bool> m_pickPointsEnabled; caf::PdmField<bool> m_useAutoGeneratedTargetAtSeaLevel;
caf::PdmField<std::vector<cvf::Vec3d>> m_fixedWellPathPoints; caf::PdmChildField<RimWellPathTarget*> m_autoTargetAtSeaLevel;
caf::PdmField<std::vector<double>> m_fixedMeasuredDepths; caf::PdmField<bool> m_pickPointsEnabled;
caf::PdmField<std::vector<cvf::Vec3d>> m_fixedWellPathPoints;
caf::PdmField<std::vector<double>> m_fixedMeasuredDepths;
caf::PdmField<bool> m_isAttachedToParentWell; caf::PdmField<bool> m_isAttachedToParentWell;

179
ApplicationLibCode/ProjectDataModel/RimWellPathTarget.cpp
View File

@ -32,6 +32,7 @@
#include "cafPdmUiCheckBoxEditor.h" #include "cafPdmUiCheckBoxEditor.h"
#include "cafPdmUiLineEditor.h" #include "cafPdmUiLineEditor.h"
#include "cafPdmUiCommandSystemProxy.h"
#include <cmath> #include <cmath>
CAF_PDM_SOURCE_INIT( RimWellPathTarget, "WellPathTarget" ); CAF_PDM_SOURCE_INIT( RimWellPathTarget, "WellPathTarget" );
@ -41,9 +42,9 @@ namespace caf
template <> template <>
void caf::AppEnum<RimWellPathTarget::TargetTypeEnum>::setUp() void caf::AppEnum<RimWellPathTarget::TargetTypeEnum>::setUp()
{ {
addItem( RimWellPathTarget::POINT_AND_TANGENT, "POINT_AND_TANGENT", "Point and Tangent" ); addItem( RimWellPathTarget::TargetTypeEnum::POINT_AND_TANGENT, "POINT_AND_TANGENT", "Point and Tangent" );
addItem( RimWellPathTarget::POINT, "POINT", "Point" ); addItem( RimWellPathTarget::TargetTypeEnum::POINT, "POINT", "Point" );
setDefault( RimWellPathTarget::POINT_AND_TANGENT ); setDefault( RimWellPathTarget::TargetTypeEnum::POINT_AND_TANGENT );
} }
} // namespace caf } // namespace caf
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -51,8 +52,8 @@ void caf::AppEnum<RimWellPathTarget::TargetTypeEnum>::setUp()
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimWellPathTarget::RimWellPathTarget() RimWellPathTarget::RimWellPathTarget()
: moved( this ) : moved( this )
, m_targetType( POINT_AND_TANGENT ) , m_targetType( TargetTypeEnum::POINT_AND_TANGENT )
, m_targetPoint( cvf::Vec3d::ZERO ) , m_targetPointXYD( cvf::Vec3d::ZERO )
, m_azimuth( 0.0 ) , m_azimuth( 0.0 )
, m_inclination( 0.0 ) , m_inclination( 0.0 )
, m_isFullUpdateEnabled( true ) , m_isFullUpdateEnabled( true )
@ -67,20 +68,22 @@ RimWellPathTarget::RimWellPathTarget()
CAF_PDM_InitField( &m_isEnabled, "IsEnabled", true, "", "", "", "" ); CAF_PDM_InitField( &m_isEnabled, "IsEnabled", true, "", "", "", "" );
CAF_PDM_InitField( &m_isLocked, "IsLocked", false, "", "", "", "" ); CAF_PDM_InitField( &m_isLocked, "IsLocked", false, "", "", "", "" );
m_isLocked.uiCapability()->setUiHidden( true ); m_isLocked.uiCapability()->setUiHidden( true );
// m_targetType.uiCapability()->setUiHidden(true);
CAF_PDM_InitScriptableFieldNoDefault( &m_targetPoint, "TargetPoint", "Point", "", "", "" ); CAF_PDM_InitScriptableFieldNoDefault( &m_targetPointXYD, "TargetPoint", "Relative Coord", "", "", "" );
CAF_PDM_InitScriptableFieldNoDefault( &m_targetPointForDisplay, "TargetPointForDisplay", "UTM Coord", "", "", "" );
m_targetPointForDisplay.registerGetMethod( this, &RimWellPathTarget::targetPointForDisplayXYD );
m_targetPointForDisplay.registerSetMethod( this, &RimWellPathTarget::setTargetPointFromDisplayCoord );
CAF_PDM_InitScriptableField( &m_dogleg1, "Dogleg1", 3.0, "DL in", "", "[deg/30m]", "" ); CAF_PDM_InitScriptableField( &m_dogleg1, "Dogleg1", 3.0, "DL in", "", "[deg/30m]", "" );
CAF_PDM_InitScriptableField( &m_dogleg2, "Dogleg2", 3.0, "DL out", "", "[deg/30m]", "" ); CAF_PDM_InitScriptableField( &m_dogleg2, "Dogleg2", 3.0, "DL out", "", "[deg/30m]", "" );
CAF_PDM_InitFieldNoDefault( &m_targetType, "TargetType", "Type", "", "", "" ); CAF_PDM_InitFieldNoDefault( &m_targetType, "TargetType", "Type", "", "", "" );
m_targetType.uiCapability()->setUiHidden( true ); m_targetType.uiCapability()->setUiHidden( true );
CAF_PDM_InitField( &m_hasTangentConstraintUiField, "HasTangentConstraint", false, "Dir", "", "", "" ); CAF_PDM_InitField( &m_hasTangentConstraintUiField, "HasTangentConstraint", false, "Dir", "", "", "" );
m_hasTangentConstraintUiField.xmlCapability()->disableIO(); m_hasTangentConstraintUiField.xmlCapability()->disableIO();
CAF_PDM_InitScriptableField( &m_azimuth, "Azimuth", 0.0, "Azi(deg)", "", "", "" ); CAF_PDM_InitScriptableField( &m_azimuth, "Azimuth", 0.0, "Azi(deg)", "", "", "" );
CAF_PDM_InitScriptableField( &m_inclination, "Inclination", 0.0, "Inc(deg)", "", "", "" ); CAF_PDM_InitScriptableField( &m_inclination, "Inclination", 0.0, "Inc(deg)", "", "", "" );
CAF_PDM_InitFieldNoDefault( &m_parentWellPath, "ParentWellPath", "Parent Well Path", "", "", "" );
m_parentWellPath.uiCapability()->setUiHidden( true );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -111,7 +114,7 @@ bool RimWellPathTarget::isEnabled() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPathTarget::setPointXYZ( const cvf::Vec3d& point ) void RimWellPathTarget::setPointXYZ( const cvf::Vec3d& point )
{ {
m_targetPoint = { point.x(), point.y(), -point.z() }; m_targetPointXYD = { point.x(), point.y(), -point.z() };
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -119,10 +122,10 @@ void RimWellPathTarget::setPointXYZ( const cvf::Vec3d& point )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPathTarget::setAsPointTargetXYD( const cvf::Vec3d& point ) void RimWellPathTarget::setAsPointTargetXYD( const cvf::Vec3d& point )
{ {
m_targetType = POINT; m_targetType = TargetTypeEnum::POINT;
m_targetPoint = point; m_targetPointXYD = point;
m_azimuth = 0.0; m_azimuth = 0.0;
m_inclination = 0.0; m_inclination = 0.0;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -130,10 +133,10 @@ void RimWellPathTarget::setAsPointTargetXYD( const cvf::Vec3d& point )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPathTarget::setAsPointTargetXYZ( const cvf::Vec3d& point ) void RimWellPathTarget::setAsPointTargetXYZ( const cvf::Vec3d& point )
{ {
m_targetType = POINT; m_targetType = TargetTypeEnum::POINT;
m_targetPoint = cvf::Vec3d( point.x(), point.y(), -point.z() ); m_targetPointXYD = cvf::Vec3d( point.x(), point.y(), -point.z() );
m_azimuth = 0.0; m_azimuth = 0.0;
m_inclination = 0.0; m_inclination = 0.0;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -150,10 +153,10 @@ void RimWellPathTarget::setAsPointXYZAndTangentTarget( const cvf::Vec3d& point,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPathTarget::setAsPointXYZAndTangentTarget( const cvf::Vec3d& point, double azimuth, double inclination ) void RimWellPathTarget::setAsPointXYZAndTangentTarget( const cvf::Vec3d& point, double azimuth, double inclination )
{ {
m_targetType = POINT_AND_TANGENT; m_targetType = TargetTypeEnum::POINT_AND_TANGENT;
m_targetPoint = cvf::Vec3d( point.x(), point.y(), -point.z() ); m_targetPointXYD = cvf::Vec3d( point.x(), point.y(), -point.z() );
m_azimuth = cvf::Math::toDegrees( azimuth ); m_azimuth = cvf::Math::toDegrees( azimuth );
m_inclination = cvf::Math::toDegrees( inclination ); m_inclination = cvf::Math::toDegrees( inclination );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -161,13 +164,23 @@ void RimWellPathTarget::setAsPointXYZAndTangentTarget( const cvf::Vec3d& point,
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPathTarget::setDerivedTangent( double azimuth, double inclination ) void RimWellPathTarget::setDerivedTangent( double azimuth, double inclination )
{ {
if ( m_targetType == POINT ) if ( m_targetType == TargetTypeEnum::POINT )
{ {
m_azimuth = cvf::Math::toDegrees( azimuth ); m_azimuth = cvf::Math::toDegrees( azimuth );
m_inclination = cvf::Math::toDegrees( inclination ); m_inclination = cvf::Math::toDegrees( inclination );
} }
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPathTarget::updateFrom3DManipulator( const cvf::Vec3d& pointXYD )
{
enableFullUpdate( false );
m_targetPointXYD.setValueWithFieldChanged( pointXYD );
enableFullUpdate( true );
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -176,7 +189,7 @@ RiaLineArcWellPathCalculator::WellTarget RimWellPathTarget::wellTargetData()
RiaLineArcWellPathCalculator::WellTarget targetData; RiaLineArcWellPathCalculator::WellTarget targetData;
targetData.targetPointXYZ = targetPointXYZ(); targetData.targetPointXYZ = targetPointXYZ();
targetData.isTangentConstrained = ( targetType() == POINT_AND_TANGENT ); targetData.isTangentConstrained = ( targetType() == TargetTypeEnum::POINT_AND_TANGENT );
targetData.azimuth = azimuth(); targetData.azimuth = azimuth();
targetData.inclination = inclination(); targetData.inclination = inclination();
targetData.radius1 = radius1(); targetData.radius1 = radius1();
@ -198,7 +211,7 @@ RimWellPathTarget::TargetTypeEnum RimWellPathTarget::targetType() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
cvf::Vec3d RimWellPathTarget::targetPointXYZ() const cvf::Vec3d RimWellPathTarget::targetPointXYZ() const
{ {
cvf::Vec3d xyzPoint( m_targetPoint() ); cvf::Vec3d xyzPoint( m_targetPointXYD() );
xyzPoint.z() = -xyzPoint.z(); xyzPoint.z() = -xyzPoint.z();
return xyzPoint; return xyzPoint;
} }
@ -208,7 +221,7 @@ cvf::Vec3d RimWellPathTarget::targetPointXYZ() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RimWellPathTarget::azimuth() const double RimWellPathTarget::azimuth() const
{ {
if ( m_targetType() == POINT_AND_TANGENT ) if ( m_targetType() == TargetTypeEnum::POINT_AND_TANGENT )
{ {
return cvf::Math::toRadians( m_azimuth ); return cvf::Math::toRadians( m_azimuth );
} }
@ -223,7 +236,7 @@ double RimWellPathTarget::azimuth() const
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
double RimWellPathTarget::inclination() const double RimWellPathTarget::inclination() const
{ {
if ( m_targetType() == POINT_AND_TANGENT ) if ( m_targetType() == TargetTypeEnum::POINT_AND_TANGENT )
{ {
return cvf::Math::toRadians( m_inclination ); return cvf::Math::toRadians( m_inclination );
} }
@ -338,6 +351,14 @@ void RimWellPathTarget::flagRadius2AsIncorrect( bool isEditable, bool isIncorrec
m_dogleg2.uiCapability()->setUiReadOnly( !isEditable ); m_dogleg2.uiCapability()->setUiReadOnly( !isEditable );
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<caf::PdmFieldHandle*> RimWellPathTarget::fieldsFor3dManipulator()
{
return { &m_targetType, &m_targetPointXYD, &m_azimuth, &m_inclination };
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -361,17 +382,75 @@ void RimWellPathTarget::defineEditorAttribute( const caf::PdmFieldHandle* field,
QString uiConfigName, QString uiConfigName,
caf::PdmUiEditorAttribute* attribute ) caf::PdmUiEditorAttribute* attribute )
{ {
if ( field == &m_targetPoint ) if ( field == &m_targetPointXYD )
{ {
auto uiDisplayStringAttr = dynamic_cast<caf::PdmUiLineEditorAttributeUiDisplayString*>( attribute ); auto uiDisplayStringAttr = dynamic_cast<caf::PdmUiLineEditorAttributeUiDisplayString*>( attribute );
if ( uiDisplayStringAttr ) if ( uiDisplayStringAttr )
{ {
uiDisplayStringAttr->m_displayString = QString::number( m_targetPoint()[0], 'f', 2 ) + " " + uiDisplayStringAttr->m_displayString = QString::number( m_targetPointXYD()[0], 'f', 2 ) + " " +
QString::number( m_targetPoint()[1], 'f', 2 ) + " " + QString::number( m_targetPointXYD()[1], 'f', 2 ) + " " +
QString::number( m_targetPoint()[2], 'f', 2 ); QString::number( m_targetPointXYD()[2], 'f', 2 );
} }
} }
else if ( field == &m_targetPointForDisplay )
{
auto uiDisplayStringAttr = dynamic_cast<caf::PdmUiLineEditorAttributeUiDisplayString*>( attribute );
if ( uiDisplayStringAttr )
{
uiDisplayStringAttr->m_displayString = QString::number( m_targetPointForDisplay()[0], 'f', 2 ) + " " +
QString::number( m_targetPointForDisplay()[1], 'f', 2 ) + " " +
QString::number( m_targetPointForDisplay()[2], 'f', 2 );
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec3d RimWellPathTarget::targetPointForDisplayXYD() const
{
auto geoDef = geometryDefinition();
if ( geoDef && geoDef->showAbsoluteCoordinates() )
{
auto offsetXYZ = geoDef->anchorPointXyz();
auto coordXYD = targetPointXYZ() + offsetXYZ;
coordXYD.z() = -coordXYD.z();
return coordXYD;
}
return m_targetPointXYD();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellPathTarget::setTargetPointFromDisplayCoord( const cvf::Vec3d& coordInXYD )
{
cvf::Vec3d offsetXYD = cvf::Vec3d::ZERO;
auto geoDef = geometryDefinition();
if ( geoDef && geoDef->showAbsoluteCoordinates() )
{
offsetXYD = geoDef->anchorPointXyd();
}
auto newCoordInXYD = coordInXYD - offsetXYD;
m_targetPointXYD = newCoordInXYD;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellPathGeometryDef* RimWellPathTarget::geometryDefinition() const
{
RimWellPathGeometryDef* geoDef = nullptr;
this->firstAncestorOfType( geoDef );
return geoDef;
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -385,11 +464,12 @@ QList<caf::PdmOptionItemInfo> RimWellPathTarget::calculateValueOptions( const ca
{ {
options.push_back( options.push_back(
caf::PdmOptionItemInfo( "o->", caf::PdmOptionItemInfo( "o->",
RimWellPathTarget::POINT_AND_TANGENT ) ); //, false, RimWellPathTarget::TargetTypeEnum::POINT_AND_TANGENT ) ); //, false,
// QIcon(":/WellTargetPointTangent16x16.png") // QIcon(":/WellTargetPointTangent16x16.png")
//)); //));
options.push_back( caf::PdmOptionItemInfo( "o", RimWellPathTarget::POINT ) ); //, false, options.push_back(
// QIcon(":/WellTargetPoint16x16.png"))); caf::PdmOptionItemInfo( "o", RimWellPathTarget::TargetTypeEnum::POINT ) ); //, false,
// QIcon(":/WellTargetPoint16x16.png")));
} }
return options; return options;
} }
@ -404,9 +484,9 @@ void RimWellPathTarget::fieldChangedByUi( const caf::PdmFieldHandle* changedFiel
if ( changedField == &m_hasTangentConstraintUiField ) if ( changedField == &m_hasTangentConstraintUiField )
{ {
if ( m_hasTangentConstraintUiField ) if ( m_hasTangentConstraintUiField )
m_targetType = POINT_AND_TANGENT; m_targetType = TargetTypeEnum::POINT_AND_TANGENT;
else else
m_targetType = POINT; m_targetType = TargetTypeEnum::POINT;
} }
moved.send( m_isFullUpdateEnabled ); moved.send( m_isFullUpdateEnabled );
@ -417,15 +497,15 @@ void RimWellPathTarget::fieldChangedByUi( const caf::PdmFieldHandle* changedFiel
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
void RimWellPathTarget::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) void RimWellPathTarget::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{ {
m_hasTangentConstraintUiField = ( m_targetType == POINT_AND_TANGENT ); m_hasTangentConstraintUiField = ( m_targetType == TargetTypeEnum::POINT_AND_TANGENT );
if ( m_isEnabled() && !m_isLocked() ) if ( m_isEnabled() && !m_isLocked() )
{ {
m_hasTangentConstraintUiField.uiCapability()->setUiReadOnly( false ); m_hasTangentConstraintUiField.uiCapability()->setUiReadOnly( false );
m_targetType.uiCapability()->setUiReadOnly( false ); m_targetType.uiCapability()->setUiReadOnly( false );
m_targetPoint.uiCapability()->setUiReadOnly( false ); m_targetPointXYD.uiCapability()->setUiReadOnly( false );
if ( m_targetType == POINT ) if ( m_targetType == TargetTypeEnum::POINT )
{ {
m_azimuth.uiCapability()->setUiReadOnly( true ); m_azimuth.uiCapability()->setUiReadOnly( true );
m_inclination.uiCapability()->setUiReadOnly( true ); m_inclination.uiCapability()->setUiReadOnly( true );
@ -440,7 +520,7 @@ void RimWellPathTarget::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderi
{ {
m_dogleg1.uiCapability()->setUiReadOnly( true ); m_dogleg1.uiCapability()->setUiReadOnly( true );
m_targetType.uiCapability()->setUiReadOnly( true ); m_targetType.uiCapability()->setUiReadOnly( true );
m_targetPoint.uiCapability()->setUiReadOnly( true ); m_targetPointXYD.uiCapability()->setUiReadOnly( true );
m_azimuth.uiCapability()->setUiReadOnly( true ); m_azimuth.uiCapability()->setUiReadOnly( true );
m_inclination.uiCapability()->setUiReadOnly( true ); m_inclination.uiCapability()->setUiReadOnly( true );
m_dogleg2.uiCapability()->setUiReadOnly( true ); m_dogleg2.uiCapability()->setUiReadOnly( true );
@ -451,4 +531,15 @@ void RimWellPathTarget::defineUiOrdering( QString uiConfigName, caf::PdmUiOrderi
{ {
m_isEnabled.uiCapability()->setUiReadOnly( true ); m_isEnabled.uiCapability()->setUiReadOnly( true );
} }
{
bool showAbsCoords = false;
auto geoDef = geometryDefinition();
if ( geoDef && geoDef->showAbsoluteCoordinates() )
{
showAbsCoords = true;
}
m_targetPointForDisplay.uiCapability()->setUiHidden( !showAbsCoords );
}
} }

21
ApplicationLibCode/ProjectDataModel/RimWellPathTarget.h
View File

@ -20,13 +20,15 @@
#include "cafPdmObject.h" #include "cafPdmObject.h"
#include "RiaLineArcWellPathCalculator.h" #include "RiaLineArcWellPathCalculator.h"
#include "cafAppEnum.h" #include "cafAppEnum.h"
#include "cafPdmCoreVec3d.h" #include "cafPdmCoreVec3d.h"
#include "cafPdmField.h" #include "cafPdmField.h"
#include "cafPdmProxyValueField.h"
#include "cafPdmPtrField.h" #include "cafPdmPtrField.h"
#include "cvfVector3.h" #include "cvfVector3.h"
class RimWellPath; class RimWellPathGeometryDef;
class RimWellPathTarget : public caf::PdmObject class RimWellPathTarget : public caf::PdmObject
{ {
@ -48,14 +50,16 @@ public:
void setAsPointXYZAndTangentTarget( const cvf::Vec3d& point, const cvf::Vec3d& tangent ); void setAsPointXYZAndTangentTarget( const cvf::Vec3d& point, const cvf::Vec3d& tangent );
void setAsPointXYZAndTangentTarget( const cvf::Vec3d& point, double azimuth, double inclination ); void setAsPointXYZAndTangentTarget( const cvf::Vec3d& point, double azimuth, double inclination );
void setDerivedTangent( double azimuth, double inclination ); void setDerivedTangent( double azimuth, double inclination );
void updateFrom3DManipulator( const cvf::Vec3d& pointXYD );
RiaLineArcWellPathCalculator::WellTarget wellTargetData(); RiaLineArcWellPathCalculator::WellTarget wellTargetData();
enum TargetTypeEnum enum class TargetTypeEnum
{ {
POINT_AND_TANGENT, POINT_AND_TANGENT,
POINT POINT
}; };
TargetTypeEnum targetType() const; TargetTypeEnum targetType() const;
cvf::Vec3d targetPointXYZ() const; cvf::Vec3d targetPointXYZ() const;
double azimuth() const; double azimuth() const;
@ -66,6 +70,8 @@ public:
void flagRadius1AsIncorrect( bool isEditable, bool isIncorrect, double actualRadius ); void flagRadius1AsIncorrect( bool isEditable, bool isIncorrect, double actualRadius );
void flagRadius2AsIncorrect( bool isEditable, bool isIncorrect, double actualRadius ); void flagRadius2AsIncorrect( bool isEditable, bool isIncorrect, double actualRadius );
std::vector<caf::PdmFieldHandle*> fieldsFor3dManipulator();
void onMoved(); void onMoved();
private: private:
@ -77,19 +83,22 @@ private:
QString uiConfigName, QString uiConfigName,
caf::PdmUiEditorAttribute* attribute ) override; caf::PdmUiEditorAttribute* attribute ) override;
cvf::Vec3d targetPointForDisplayXYD() const;
void setTargetPointFromDisplayCoord( const cvf::Vec3d& coordInXYZ );
RimWellPathGeometryDef* geometryDefinition() const;
private: private:
friend class RicWellTarget3dEditor;
void enableFullUpdate( bool enable ); void enableFullUpdate( bool enable );
bool m_isFullUpdateEnabled; bool m_isFullUpdateEnabled;
caf::PdmField<bool> m_isEnabled; caf::PdmField<bool> m_isEnabled;
caf::PdmField<bool> m_isLocked; caf::PdmField<bool> m_isLocked;
caf::PdmField<caf::AppEnum<TargetTypeEnum>> m_targetType; caf::PdmField<caf::AppEnum<TargetTypeEnum>> m_targetType;
caf::PdmField<cvf::Vec3d> m_targetPoint; caf::PdmField<cvf::Vec3d> m_targetPointXYD;
caf::PdmProxyValueField<cvf::Vec3d> m_targetPointForDisplay;
caf::PdmField<double> m_azimuth; caf::PdmField<double> m_azimuth;
caf::PdmField<double> m_inclination; caf::PdmField<double> m_inclination;
caf::PdmField<double> m_dogleg1; caf::PdmField<double> m_dogleg1;
caf::PdmField<double> m_dogleg2; caf::PdmField<double> m_dogleg2;
caf::PdmField<bool> m_hasTangentConstraintUiField; caf::PdmField<bool> m_hasTangentConstraintUiField;
caf::PdmPtrField<RimWellPath*> m_parentWellPath;
}; };

12
ApplicationLibCode/ProjectDataModel/RimWellPathTieIn.cpp
View File

@ -30,8 +30,6 @@
#include "RiuMainWindow.h" #include "RiuMainWindow.h"
#include "cafPdmFieldScriptingCapability.h"
#include "cafPdmObjectScriptingCapability.h"
#include "cafPdmUiDoubleValueEditor.h" #include "cafPdmUiDoubleValueEditor.h"
CAF_PDM_SOURCE_INIT( RimWellPathTieIn, "RimWellPathTieIn" ); CAF_PDM_SOURCE_INIT( RimWellPathTieIn, "RimWellPathTieIn" );
@ -48,15 +46,9 @@ RimWellPathTieIn::RimWellPathTieIn()
CAF_PDM_InitFieldNoDefault( &m_tieInMeasuredDepth, "TieInMeasuredDepth", "Tie In Measured Depth", "", "", "" ); CAF_PDM_InitFieldNoDefault( &m_tieInMeasuredDepth, "TieInMeasuredDepth", "Tie In Measured Depth", "", "", "" );
m_tieInMeasuredDepth.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() ); m_tieInMeasuredDepth.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleValueEditor::uiEditorTypeName() );
CAF_PDM_InitScriptableField( &m_addValveAtConnection, CAF_PDM_InitField( &m_addValveAtConnection, "AddValveAtConnection", false, "Add Outlet Valve for Branches", "", "", "" );
"AddValveAtConnection",
false,
"Add Outlet Valve for Branches",
"",
"",
"" );
CAF_PDM_InitScriptableFieldNoDefault( &m_valve, "Valve", "Branch Outlet Valve", "", "", "" ); CAF_PDM_InitFieldNoDefault( &m_valve, "Valve", "Branch Outlet Valve", "", "", "" );
m_valve = new RimWellPathValve; m_valve = new RimWellPathValve;
} }