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

#3723 Annotations. User editable polyline, both in in view and in property editor

Browse Source
This commit is contained in:
Bjørn Erik Jensen
2018-12-07 09:11:03 +01:00
parent 55f980eeb7
commit b4482d20b0
21 changed files with 1208 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/ProjectDataModel/Annotations/CMakeLists_files.cmake
View File

@@ -17,6 +17,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimPolylinesAnnotationInView.h
${CMAKE_CURRENT_LIST_DIR}/RimReachCircleAnnotationInView.h
${CMAKE_CURRENT_LIST_DIR}/RimTextAnnotationInView.h
${CMAKE_CURRENT_LIST_DIR}/RimAnnotationGroupCollection.h
${CMAKE_CURRENT_LIST_DIR}/RimPolylineTarget.h
)
set (SOURCE_GROUP_SOURCE_FILES
@@ -37,6 +38,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimPolylinesAnnotationInView.cpp
${CMAKE_CURRENT_LIST_DIR}/RimReachCircleAnnotationInView.cpp
${CMAKE_CURRENT_LIST_DIR}/RimTextAnnotationInView.cpp
${CMAKE_CURRENT_LIST_DIR}/RimAnnotationGroupCollection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimPolylineTarget.cpp
)
list(APPEND CODE_HEADER_FILES

99
ApplicationCode/ProjectDataModel/Annotations/RimPolylineTarget.cpp Normal file
View File

@@ -0,0 +1,99 @@
#include "RimPolylineTarget.h"
#include "RimModeledWellPath.h"
#include <cmath>
#include "RimUserDefinedPolylinesAnnotation.h"
#include "cafPdmUiCheckBoxEditor.h"
CAF_PDM_SOURCE_INIT(RimPolylineTarget, "PolylineTarget");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPolylineTarget::RimPolylineTarget()
: m_isFullUpdateEnabled(true)
{
CAF_PDM_InitField(&m_isEnabled, "IsEnabled", true, "", "", "", "");
//m_targetType.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_targetPoint, "TargetPoint", "Point", "", "", "");
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPolylineTarget::~RimPolylineTarget()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimPolylineTarget::isEnabled() const
{
return m_isEnabled;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolylineTarget::setAsPointTargetXYD(const cvf::Vec3d& point)
{
m_targetPoint = point;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolylineTarget::setAsPointXYZAndTangentTarget(const cvf::Vec3d& point,
double azimuth,
double inclination)
{
m_targetPoint = cvf::Vec3d(point.x(), point.y(), -point.z());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec3d RimPolylineTarget::targetPointXYZ() const
{
cvf::Vec3d xyzPoint(m_targetPoint());
xyzPoint.z() = -xyzPoint.z();
return xyzPoint;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolylineTarget::enableFullUpdate(bool enable)
{
m_isFullUpdateEnabled = enable;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RimPolylineTarget::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly)
{
QList<caf::PdmOptionItemInfo> options;
return options;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolylineTarget::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
RimUserDefinedPolylinesAnnotation* polyline;
firstAncestorOrThisOfTypeAsserted(polyline);
polyline->updateVisualization();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolylineTarget::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
m_targetPoint.uiCapability()->setUiReadOnly(m_isEnabled());
}

56
ApplicationCode/ProjectDataModel/Annotations/RimPolylineTarget.h Normal file
View File

@@ -0,0 +1,56 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018 - Equinor
//
// 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.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "cafPdmObject.h"
#include "cvfBase.h"
#include "cvfVector3.h"
#include "cafAppEnum.h"
#include "cafPdmField.h"
#include "cafPdmCoreVec3d.h"
#include "RiaLineArcWellPathCalculator.h"
class RimPolylineTarget : public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
RimPolylineTarget();
~RimPolylineTarget() override;
bool isEnabled() const;
void setAsPointTargetXYD(const cvf::Vec3d& point);
void setAsPointXYZAndTangentTarget(const cvf::Vec3d& point, double azimuth, double inclination);
cvf::Vec3d targetPointXYZ() const;
private:
QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool* useOptionsOnly) override;
void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
private:
friend class RicPolylineTarget3dEditor;
void enableFullUpdate(bool enable);
bool m_isFullUpdateEnabled;
caf::PdmField<bool> m_isEnabled;
caf::PdmField<cvf::Vec3d> m_targetPoint;
};

209
ApplicationCode/ProjectDataModel/Annotations/RimUserDefinedPolylinesAnnotation.cpp
View File

@@ -18,11 +18,21 @@
#include "RimUserDefinedPolylinesAnnotation.h"
#include "WellPathCommands/PointTangentManipulator/RicPolyline3dEditor.h"
#include "WellPathCommands/RicPolylineTargetsPickEventHandler.h"
#include "RimAnnotationCollection.h"
#include "RimAnnotationLineAppearance.h"
#include "RimPolylineTarget.h"
#include "RigPolyLinesData.h"
#include "RiuViewerCommands.h"
#include "cafPdmUiTableViewEditor.h"
#include "cafCmdFeatureMenuBuilder.h"
#include "cafPdmUiPushButtonEditor.h"
//--------------------------------------------------------------------------------------------------
/// Internal function
//--------------------------------------------------------------------------------------------------
@@ -45,10 +55,22 @@ CAF_PDM_SOURCE_INIT(RimUserDefinedPolylinesAnnotation, "UserDefinedPolylinesAnno
///
//--------------------------------------------------------------------------------------------------
RimUserDefinedPolylinesAnnotation::RimUserDefinedPolylinesAnnotation()
: m_pickTargetsEventHandler(new RicPolylineTargetsPickEventHandler(this))
{
CAF_PDM_InitObject("PolyLines Annotation", ":/WellCollection.png", "", "");
CAF_PDM_InitField(&m_pointsXyd, "PointsXyd", {}, "", "", "", "");
CAF_PDM_InitField(&m_enablePicking, "EnablePicking", false, "", "", "", "");
caf::PdmUiPushButtonEditor::configureEditorForField(&m_enablePicking);
m_enablePicking.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::LabelPosType::HIDDEN);
CAF_PDM_InitFieldNoDefault(&m_targets, "Targets", "Targets", "", "", "");
m_targets.uiCapability()->setUiEditorTypeName(caf::PdmUiTableViewEditor::uiEditorTypeName());
m_targets.uiCapability()->setUiTreeChildrenHidden(true);
m_targets.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::TOP);
m_targets.uiCapability()->setCustomContextMenuEnabled(true);
this->setUi3dEditorTypeName(RicPolyline3dEditor::uiEditorTypeName());
}
//--------------------------------------------------------------------------------------------------
@@ -64,20 +86,131 @@ RimUserDefinedPolylinesAnnotation::~RimUserDefinedPolylinesAnnotation()
//--------------------------------------------------------------------------------------------------
cvf::ref<RigPolyLinesData> RimUserDefinedPolylinesAnnotation::polyLinesData()
{
cvf::ref<RigPolyLinesData> pld = new RigPolyLinesData;
std::vector<std::vector<cvf::Vec3d> > lines;
lines.push_back(xydToXyzVector(m_pointsXyd()));
pld->setPolyLines(lines);
cvf::ref<RigPolyLinesData> pld = new RigPolyLinesData;
std::vector<cvf::Vec3d> line;
std::vector<std::vector<cvf::Vec3d> > lines;
for (const RimPolylineTarget* target : m_targets)
{
line.push_back(target->targetPointXYZ());
}
pld->setPolyLines({ line });
return pld;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimPolylineTarget*> RimUserDefinedPolylinesAnnotation::activeTargets() const
{
return m_targets.childObjects();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimUserDefinedPolylinesAnnotation::isEmpty()
{
return m_pointsXyd().empty();
return m_targets.empty();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimUserDefinedPolylinesAnnotation::appendTarget()
{
RimPolylineTarget* wellPathTarget = nullptr;
auto targets = m_targets.childObjects();
if (targets.empty())
{
wellPathTarget = new RimPolylineTarget();
}
else
{
wellPathTarget = dynamic_cast<RimPolylineTarget*>(
targets.back()->xmlCapability()->copyByXmlSerialization(caf::PdmDefaultObjectFactory::instance()));
}
if (wellPathTarget)
{
m_targets.push_back(wellPathTarget);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimUserDefinedPolylinesAnnotation::insertTarget(const RimPolylineTarget* targetToInsertBefore,
RimPolylineTarget* targetToInsert)
{
size_t index = m_targets.index(targetToInsertBefore);
if (index < m_targets.size())
m_targets.insert(index, targetToInsert);
else
m_targets.push_back(targetToInsert);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimUserDefinedPolylinesAnnotation::deleteTarget(RimPolylineTarget* targetTodelete)
{
m_targets.removeChildObject(targetTodelete);
delete targetTodelete;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<RimPolylineTarget*, RimPolylineTarget*>
RimUserDefinedPolylinesAnnotation::findActiveTargetsAroundInsertionPoint(const RimPolylineTarget* targetToInsertBefore)
{
RimPolylineTarget* before = nullptr;
RimPolylineTarget* after = nullptr;
bool foundTarget = false;
for (const auto& wt : m_targets)
{
if (wt == targetToInsertBefore)
{
foundTarget = true;
}
if (wt->isEnabled() && !after && foundTarget) after = wt;
if (wt->isEnabled() && !foundTarget) before = wt;
}
return {before, after};
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimUserDefinedPolylinesAnnotation::updateVisualization()
{
RimAnnotationCollection* annColl = nullptr;
this->firstAncestorOrThisOfTypeAsserted(annColl);
annColl->scheduleRedrawOfRelevantViews();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimUserDefinedPolylinesAnnotation::enablePicking(bool enable)
{
m_enablePicking = enable;
if (enable)
{
RiuViewerCommands::setPickEventHandler(m_pickTargetsEventHandler);
}
else
{
RiuViewerCommands::removePickEventHandlerIfActive(m_pickTargetsEventHandler);
}
updateConnectedEditors();
}
//--------------------------------------------------------------------------------------------------
@@ -85,7 +218,8 @@ bool RimUserDefinedPolylinesAnnotation::isEmpty()
//--------------------------------------------------------------------------------------------------
void RimUserDefinedPolylinesAnnotation::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
uiOrdering.add(&m_pointsXyd);
uiOrdering.add(&m_targets);
uiOrdering.add(&m_enablePicking);
auto appearanceGroup = uiOrdering.addNewGroup("Line Appearance");
appearance()->uiOrdering(uiConfigName, *appearanceGroup);
@@ -100,10 +234,65 @@ void RimUserDefinedPolylinesAnnotation::fieldChangedByUi(const caf::PdmFieldHand
const QVariant& oldValue,
const QVariant& newValue)
{
RimAnnotationCollection* annColl = nullptr;
this->firstAncestorOrThisOfTypeAsserted(annColl);
if (changedField == &m_enablePicking)
{
enablePicking(m_enablePicking);
}
annColl->scheduleRedrawOfRelevantViews();
updateVisualization();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimUserDefinedPolylinesAnnotation::defineCustomContextMenu(const caf::PdmFieldHandle* fieldNeedingMenu,
QMenu* menu,
QWidget* fieldEditorWidget)
{
caf::CmdFeatureMenuBuilder menuBuilder;
menuBuilder << "RicNewPolylineTargetFeature";
menuBuilder << "Separator";
menuBuilder << "RicDeletePolylineTargetFeature";
menuBuilder.appendToMenu(menu);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimUserDefinedPolylinesAnnotation::defineEditorAttribute(const caf::PdmFieldHandle* field,
QString uiConfigName,
caf::PdmUiEditorAttribute* attribute)
{
if (field == &m_enablePicking)
{
auto* pbAttribute = dynamic_cast<caf::PdmUiPushButtonEditorAttribute*>(attribute);
if (pbAttribute)
{
if (!m_enablePicking)
{
pbAttribute->m_buttonText = "Start Picking Points";
}
else
{
pbAttribute->m_buttonText = "Stop Picking Points";
}
}
}
if (field == &m_targets)
{
auto tvAttribute = dynamic_cast<caf::PdmUiTableViewEditorAttribute*>(attribute);
if (tvAttribute)
{
tvAttribute->resizePolicy = caf::PdmUiTableViewEditorAttribute::RESIZE_TO_FIT_CONTENT;
if (m_enablePicking)
{
tvAttribute->baseColor.setRgb(255, 220, 255);
tvAttribute->alwaysEnforceResizePolicy = true;
}
}
}
}

25
ApplicationCode/ProjectDataModel/Annotations/RimUserDefinedPolylinesAnnotation.h
View File

@@ -20,6 +20,10 @@
#include "RimPolylinesAnnotation.h"
#include "cafPdmFieldCvfVec3d.h"
#include "cafPdmChildArrayField.h"
class RicPolylineTargetsPickEventHandler;
class RimPolylineTarget;
//==================================================================================================
///
@@ -38,14 +42,33 @@ public:
~RimUserDefinedPolylinesAnnotation();
cvf::ref<RigPolyLinesData> polyLinesData() override;
std::vector<RimPolylineTarget*> activeTargets() const;
virtual bool isEmpty() override;
void appendTarget();
void insertTarget(const RimPolylineTarget* targetToInsertBefore, RimPolylineTarget* targetToInsert);
void deleteTarget(RimPolylineTarget* targetTodelete);
std::pair<RimPolylineTarget*, RimPolylineTarget*>
findActiveTargetsAroundInsertionPoint(const RimPolylineTarget* targetToInsertBefore);
void updateVisualization();
void enablePicking(bool enable);
protected:
void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
private:
caf::PdmField<std::vector<Vec3d>> m_pointsXyd;
void defineCustomContextMenu(const caf::PdmFieldHandle* fieldNeedingMenu, QMenu* menu, QWidget* fieldEditorWidget) override;
void defineEditorAttribute(const caf::PdmFieldHandle* field,
QString uiConfigName,
caf::PdmUiEditorAttribute* attribute) override;
private:
caf::PdmField<bool> m_enablePicking;
caf::PdmChildArrayField<RimPolylineTarget*> m_targets;
RicPolylineTargetsPickEventHandler* m_pickTargetsEventHandler;
};