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

Merged branch maintenance-enhancements into dev

Browse Source
This commit is contained in:
Magne Sjaastad
2016-12-19 15:12:26 +01:00
parent 3fd51e4d4d ac4f21318c
commit b934ae3f26
19 changed files with 569 additions and 102 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
ApplicationCode/Commands/RicExportToLasFileFeature.cpp
View File

@@ -24,6 +24,8 @@
#include "RigLasFileExporter.h"
#include "RimWellLogCurve.h"
#include "WellLogCommands/RicWellLogPlotCurveFeatureImpl.h"
#include "cafPdmUiPropertyViewDialog.h"
#include "cafSelectionManager.h"
@@ -39,7 +41,7 @@ CAF_CMD_SOURCE_INIT(RicExportToLasFileFeature, "RicExportToLasFileFeature");
//--------------------------------------------------------------------------------------------------
bool RicExportToLasFileFeature::isCommandEnabled()
{
return selectedWellLogCurves().size() > 0;
return RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves().size() > 0;
}
//--------------------------------------------------------------------------------------------------
@@ -47,7 +49,7 @@ bool RicExportToLasFileFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicExportToLasFileFeature::onActionTriggered(bool isChecked)
{
std::vector<RimWellLogCurve*> curves = selectedWellLogCurves();
std::vector<RimWellLogCurve*> curves = RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves();
if (curves.size() == 0) return;
RiaApplication* app = RiaApplication::instance();
@@ -103,39 +105,3 @@ void RicExportToLasFileFeature::setupActionLook(QAction* actionToSetup)
actionToSetup->setText("Export To LAS Files...");
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimWellLogCurve*> RicExportToLasFileFeature::selectedWellLogCurves() const
{
std::set<RimWellLogCurve*> curveSet;
{
std::vector<caf::PdmUiItem*> selectedItems;
caf::SelectionManager::instance()->selectedItems(selectedItems);
for (auto selectedItem : selectedItems)
{
caf::PdmObjectHandle* objHandle = dynamic_cast<caf::PdmObjectHandle*>(selectedItem);
if (objHandle)
{
std::vector<RimWellLogCurve*> childCurves;
objHandle->descendantsIncludingThisOfType(childCurves);
for (auto curve : childCurves)
{
curveSet.insert(curve);
}
}
}
}
std::vector<RimWellLogCurve*> allCurves;
for (auto curve : curveSet)
{
allCurves.push_back(curve);
}
return allCurves;
}

3
ApplicationCode/Commands/RicExportToLasFileFeature.h
View File

@@ -37,8 +37,5 @@ protected:
virtual bool isCommandEnabled();
virtual void onActionTriggered( bool isChecked );
virtual void setupActionLook( QAction* actionToSetup );
private:
std::vector<RimWellLogCurve*> selectedWellLogCurves() const;
};

4
ApplicationCode/Commands/WellLogCommands/CMakeLists_files.cmake
View File

@@ -18,6 +18,8 @@ ${CEE_CURRENT_LIST_DIR}RicWellLogPlotTrackFeatureImpl.h
${CEE_CURRENT_LIST_DIR}RicPasteWellLogCurveFeature.h
${CEE_CURRENT_LIST_DIR}RicPasteWellLogTrackFeature.h
${CEE_CURRENT_LIST_DIR}RicPasteWellLogPlotFeature.h
${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeature.h
${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeatureUi.h
)
set (SOURCE_GROUP_SOURCE_FILES
@@ -34,6 +36,8 @@ ${CEE_CURRENT_LIST_DIR}RicWellLogPlotTrackFeatureImpl.cpp
${CEE_CURRENT_LIST_DIR}RicPasteWellLogCurveFeature.cpp
${CEE_CURRENT_LIST_DIR}RicPasteWellLogTrackFeature.cpp
${CEE_CURRENT_LIST_DIR}RicPasteWellLogPlotFeature.cpp
${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeature.cpp
${CEE_CURRENT_LIST_DIR}RicChangeDataSourceFeatureUi.cpp
)
list(APPEND CODE_HEADER_FILES

98
ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeature.cpp Normal file
View File

@@ -0,0 +1,98 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2016 Statoil ASA
//
// 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 "RicChangeDataSourceFeature.h"
#include "RicChangeDataSourceFeatureUi.h"
#include "RicWellLogPlotCurveFeatureImpl.h"
#include "RimCase.h"
#include "RimWellLogCurve.h"
#include "RimWellLogExtractionCurve.h"
#include "RimWellPath.h"
#include "cafPdmUiPropertyViewDialog.h"
#include <QAction>
CAF_CMD_SOURCE_INIT(RicChangeDataSourceFeature, "RicChangeDataSourceFeature");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicChangeDataSourceFeature::isCommandEnabled()
{
std::vector<RimWellLogExtractionCurve*> extrCurves = extractionCurves();
return extrCurves.size() > 0;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicChangeDataSourceFeature::onActionTriggered(bool isChecked)
{
std::vector<RimWellLogExtractionCurve*> extrCurves = extractionCurves();
if (extrCurves.size() == 0) return;
RicChangeDataSourceFeatureUi featureUi;
featureUi.wellPathToApply = extrCurves[0]->wellPath();
featureUi.caseToApply = extrCurves[0]->rimCase();
caf::PdmUiPropertyViewDialog propertyDialog(nullptr, &featureUi, "Change Data Source for Selected Curves", "");
propertyDialog.resize(QSize(500, 200));
if (propertyDialog.exec() == QDialog::Accepted)
{
for (RimWellLogExtractionCurve* extractionCurve : extrCurves)
{
extractionCurve->setWellPath(featureUi.wellPathToApply);
extractionCurve->setCase(featureUi.caseToApply);
extractionCurve->loadDataAndUpdate();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicChangeDataSourceFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setText("Change Data Source");
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimWellLogExtractionCurve*> RicChangeDataSourceFeature::extractionCurves()
{
std::vector<RimWellLogExtractionCurve*> extrCurves;
std::vector<RimWellLogCurve*> curves = RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves();
for (RimWellLogCurve* c : curves)
{
if (dynamic_cast<RimWellLogExtractionCurve*>(c))
{
extrCurves.push_back(dynamic_cast<RimWellLogExtractionCurve*>(c));
}
}
return extrCurves;
}

41
ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeature.h Normal file
View File

@@ -0,0 +1,41 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2016 Statoil ASA
//
// 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 "cafCmdFeature.h"
#include <vector>
class RimWellLogExtractionCurve;
//==================================================================================================
///
//==================================================================================================
class RicChangeDataSourceFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
protected:
virtual bool isCommandEnabled() override;
virtual void onActionTriggered( bool isChecked ) override;
virtual void setupActionLook(QAction* actionToSetup) override;
private:
static std::vector<RimWellLogExtractionCurve*> extractionCurves();
};

87
ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeatureUi.cpp Normal file
View File

@@ -0,0 +1,87 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2016 Statoil ASA
//
// 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 "RicChangeDataSourceFeatureUi.h"
#include "RimCase.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimWellPath.h"
#include "RimWellPathCollection.h"
#include "RiaApplication.h"
CAF_PDM_SOURCE_INIT(RicChangeDataSourceFeatureUi, "ChangeDataSourceFeatureUi");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicChangeDataSourceFeatureUi::RicChangeDataSourceFeatureUi()
{
CAF_PDM_InitObject("Change Data Source", "", "", "");
CAF_PDM_InitFieldNoDefault(&wellPathToApply, "CurveWellPath", "Well Path", "", "", "");
CAF_PDM_InitFieldNoDefault(&caseToApply, "CurveCase", "Case", "", "", "");
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RicChangeDataSourceFeatureUi::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly)
{
QList<caf::PdmOptionItemInfo> optionList;
if (fieldNeedingOptions == &caseToApply)
{
RimProject* proj = RiaApplication::instance()->project();
std::vector<RimCase*> cases;
proj->allCases(cases);
for (RimCase* c : cases)
{
optionList.push_back(caf::PdmOptionItemInfo(c->caseUserDescription(), c));
}
}
else if (fieldNeedingOptions == &wellPathToApply)
{
RimProject* proj = RiaApplication::instance()->project();
if (proj->activeOilField()->wellPathCollection())
{
for (RimWellPath* wellPath : proj->activeOilField()->wellPathCollection()->wellPaths)
{
optionList.push_back(caf::PdmOptionItemInfo(wellPath->name(), wellPath));
}
}
}
return optionList;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicChangeDataSourceFeatureUi::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup* group = uiOrdering.addNewGroup("Apply the following for all selected curves");
group->add(&caseToApply);
group->add(&wellPathToApply);
}

46
ApplicationCode/Commands/WellLogCommands/RicChangeDataSourceFeatureUi.h Normal file
View File

@@ -0,0 +1,46 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2016 Statoil ASA
//
// 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 "cafPdmPtrField.h"
#include "cafPdmUiOrdering.h"
class RimCase;
class RimWellPath;
//==================================================================================================
///
//==================================================================================================
class RicChangeDataSourceFeatureUi : public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
RicChangeDataSourceFeatureUi();
caf::PdmPtrField<RimCase*> caseToApply;
caf::PdmPtrField<RimWellPath*> wellPathToApply;
protected:
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly) override;
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
};

40
ApplicationCode/Commands/WellLogCommands/RicWellLogPlotCurveFeatureImpl.cpp
View File

@@ -19,6 +19,10 @@
#include "RicWellLogPlotCurveFeatureImpl.h"
#include "RimWellLogCurve.h"
#include "cafSelectionManager.h"
#include <QColor>
static const int RI_LOGPLOT_CURVECOLORSCOUNT = 15;
@@ -52,3 +56,39 @@ cvf::Color3f RicWellLogPlotCurveFeatureImpl::curveColorFromTable()
cvf::Color3f cvfColor(color.redF(), color.greenF(), color.blueF());
return cvfColor;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimWellLogCurve*> RicWellLogPlotCurveFeatureImpl::selectedWellLogCurves()
{
std::set<RimWellLogCurve*> curveSet;
{
std::vector<caf::PdmUiItem*> selectedItems;
caf::SelectionManager::instance()->selectedItems(selectedItems);
for (caf::PdmUiItem* selectedItem : selectedItems)
{
caf::PdmObjectHandle* objHandle = dynamic_cast<caf::PdmObjectHandle*>(selectedItem);
if (objHandle)
{
std::vector<RimWellLogCurve*> childCurves;
objHandle->descendantsIncludingThisOfType(childCurves);
for (RimWellLogCurve* curve : childCurves)
{
curveSet.insert(curve);
}
}
}
}
std::vector<RimWellLogCurve*> allCurves;
for (RimWellLogCurve* curve : curveSet)
{
allCurves.push_back(curve);
}
return allCurves;
}

4
ApplicationCode/Commands/WellLogCommands/RicWellLogPlotCurveFeatureImpl.h
View File

@@ -21,12 +21,14 @@
#include "cafPdmFieldCvfColor.h"
class RimWellLogCurve;
//==================================================================================================
///
//==================================================================================================
class RicWellLogPlotCurveFeatureImpl
{
public:
static cvf::Color3f curveColorFromTable();
static std::vector<RimWellLogCurve*> selectedWellLogCurves();
};

7
ApplicationCode/GeoMech/GeoMechDataModel/RigFemPart.cpp
View File

@@ -287,16 +287,13 @@ float RigFemPart::characteristicElementSize()
{
if (m_characteristicElementSize != std::numeric_limits<float>::infinity()) return m_characteristicElementSize;
// take 100 elements
float elmIdxJump = elementCount() / 100.0f;
int elmIdxIncrement = elmIdxJump < 1 ? 1: (int) elmIdxJump;
int elmsToAverageCount = 0;
float sumMaxEdgeLength = 0;
for (int elmIdx = 0; elmIdx < elementCount(); elmIdx += elmIdxIncrement)
for (int elmIdx = 0; elmIdx < elementCount(); elmIdx++)
{
RigElementType eType = this->elementType(elmIdx);
if (eType == HEX8 || eType == HEX8P)
if (eType == HEX8P)
{
const int* elmentConn = this->connectivities(elmIdx);
cvf::Vec3f nodePos0 = this->nodes().coordinates[elmentConn[0]];

1
ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@@ -393,6 +393,7 @@ QStringList RimContextCommandBuilder::commandsFromSelection()
{
commandIds << "RicCopyReferencesToClipboardFeature";
commandIds << "RicExportToLasFileFeature";
commandIds << "RicChangeDataSourceFeature";
}
else if (dynamic_cast<RimWellLogPlotCollection*>(uiItem))
{

65
ApplicationCode/ProjectDataModel/RimViewController.cpp
View File

@@ -67,6 +67,7 @@ RimViewController::RimViewController(void)
m_managedView.uiCapability()->setUiTreeChildrenHidden(true);
CAF_PDM_InitField(&m_syncCamera, "SyncCamera", true, "Camera", "", "", "");
CAF_PDM_InitField(&m_showCursor, "ShowCursor", true, " Show Cursor", "", "", "");
CAF_PDM_InitField(&m_syncTimeStep, "SyncTimeStep", true, "Time Step", "", "", "");
CAF_PDM_InitField(&m_syncCellResult, "SyncCellResult", false, "Cell Result", "", "", "");
CAF_PDM_InitField(&m_syncLegendDefinitions, "SyncLegendDefinitions", true, " Legend Definition", "", "", "");
@@ -174,6 +175,13 @@ void RimViewController::fieldChangedByUi(const caf::PdmFieldHandle* changedField
{
updateTimeStepLink();
}
else if (changedField == &m_showCursor)
{
if (!m_showCursor && m_managedView && m_managedView->viewer())
{
m_managedView->viewer()->setCursorPosition(cvf::Vec3d::UNDEFINED);
}
}
else if (changedField == &m_syncCellResult)
{
updateResultColorsControl();
@@ -223,7 +231,7 @@ void RimViewController::fieldChangedByUi(const caf::PdmFieldHandle* changedField
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimEclipseView* RimViewController::managedEclipseView()
RimEclipseView* RimViewController::managedEclipseView() const
{
RimView* rimView = m_managedView;
@@ -233,7 +241,7 @@ RimEclipseView* RimViewController::managedEclipseView()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGeoMechView* RimViewController::managedGeoView()
RimGeoMechView* RimViewController::managedGeoView() const
{
RimView* rimView = m_managedView;
@@ -418,13 +426,23 @@ void RimViewController::updateOptionSensitivity()
this->m_syncRangeFilters = false;
}
if (m_syncCamera)
{
this->m_showCursor.uiCapability()->setUiReadOnly(false);
}
else
{
this->m_showCursor.uiCapability()->setUiReadOnly(true);
this->m_showCursor = false;
}
m_syncVisibleCells.uiCapability()->setUiReadOnly(!this->isMasterAndDepViewDifferentType());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimView* RimViewController::managedView()
RimView* RimViewController::managedView() const
{
return m_managedView;
}
@@ -455,6 +473,7 @@ void RimViewController::defineUiOrdering(QString uiConfigName, caf::PdmUiOrderin
caf::PdmUiGroup* scriptGroup = uiOrdering.addNewGroup("Link Options");
scriptGroup->add(&m_syncCamera);
scriptGroup->add(&m_showCursor);
scriptGroup->add(&m_syncTimeStep);
scriptGroup->add(&m_syncCellResult);
scriptGroup->add(&m_syncLegendDefinitions);
@@ -530,7 +549,7 @@ void RimViewController::updateLegendDefinitions()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimViewLinker* RimViewController::ownerViewLinker()
RimViewLinker* RimViewController::ownerViewLinker() const
{
RimViewLinker* viewLinker = NULL;
this->firstAncestorOrThisOfType(viewLinker);
@@ -619,7 +638,7 @@ const RigCaseToCaseCellMapper* RimViewController::cellMapper()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimView* RimViewController::masterView()
RimView* RimViewController::masterView() const
{
return ownerViewLinker()->masterView();
}
@@ -627,7 +646,7 @@ RimView* RimViewController::masterView()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isMasterAndDepViewDifferentType()
bool RimViewController::isMasterAndDepViewDifferentType() const
{
RimEclipseView* eclipseMasterView = dynamic_cast<RimEclipseView*>(masterView());
RimGeoMechView* geoMasterView = dynamic_cast<RimGeoMechView*>(masterView());
@@ -648,7 +667,7 @@ bool RimViewController::isMasterAndDepViewDifferentType()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewController::scheduleCreateDisplayModelAndRedrawForDependentView()
void RimViewController::scheduleCreateDisplayModelAndRedrawForDependentView() const
{
if (!this->isActive()) return;
@@ -668,7 +687,7 @@ void RimViewController::scheduleCreateDisplayModelAndRedrawForDependentView()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewController::scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType)
void RimViewController::scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType) const
{
if (!this->isActive()) return;
@@ -693,7 +712,7 @@ void RimViewController::scheduleGeometryRegenForDepViews(RivCellSetEnum geometry
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isActive()
bool RimViewController::isActive() const
{
return ownerViewLinker()->isActive() && this->m_isActive();
}
@@ -701,7 +720,7 @@ bool RimViewController::isActive()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isCameraLinked()
bool RimViewController::isCameraLinked() const
{
if (ownerViewLinker()->isActive() && this->m_isActive())
{
@@ -716,7 +735,15 @@ bool RimViewController::isCameraLinked()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isTimeStepLinked()
bool RimViewController::showCursor() const
{
return m_showCursor;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isTimeStepLinked() const
{
if (ownerViewLinker()->isActive() && this->m_isActive())
{
@@ -731,7 +758,7 @@ bool RimViewController::isTimeStepLinked()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isResultColorControlled()
bool RimViewController::isResultColorControlled() const
{
if (ownerViewLinker()->isActive() && this->m_isActive())
{
@@ -746,7 +773,7 @@ bool RimViewController::isResultColorControlled()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isLegendDefinitionsControlled()
bool RimViewController::isLegendDefinitionsControlled() const
{
if (ownerViewLinker()->isActive() && this->m_isActive())
{
@@ -761,7 +788,7 @@ bool RimViewController::isLegendDefinitionsControlled()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isVisibleCellsOveridden()
bool RimViewController::isVisibleCellsOveridden() const
{
if (isMasterAndDepViewDifferentType())
{
@@ -783,7 +810,7 @@ bool RimViewController::isVisibleCellsOveridden()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isRangeFilterControlPossible()
bool RimViewController::isRangeFilterControlPossible() const
{
return true;
#if 0
@@ -817,7 +844,7 @@ bool RimViewController::isRangeFilterControlPossible()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isRangeFilterMappingApliccable()
bool RimViewController::isRangeFilterMappingApliccable() const
{
if (!isMasterAndDepViewDifferentType()) return false;
@@ -850,7 +877,7 @@ bool RimViewController::isRangeFilterMappingApliccable()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isRangeFiltersControlled()
bool RimViewController::isRangeFiltersControlled() const
{
if (!isRangeFilterControlPossible()) return false;
@@ -866,7 +893,7 @@ bool RimViewController::isRangeFiltersControlled()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isPropertyFilterControlPossible()
bool RimViewController::isPropertyFilterControlPossible() const
{
// The cases need to be the same
RimGeoMechView* geomView = dynamic_cast<RimGeoMechView*>(masterView());
@@ -898,7 +925,7 @@ bool RimViewController::isPropertyFilterControlPossible()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewController::isPropertyFilterOveridden()
bool RimViewController::isPropertyFilterOveridden() const
{
if (!isPropertyFilterControlPossible()) return false;

44
ApplicationCode/ProjectDataModel/RimViewController.h
View File

@@ -47,28 +47,29 @@ public:
RimViewController(void);
virtual ~RimViewController(void);
bool isActive();
bool isActive() const;
RimView* managedView();
RimView* managedView() const;
void setManagedView(RimView* view);
RimView* masterView();
RimViewLinker* ownerViewLinker();
RimView* masterView() const;
RimViewLinker* ownerViewLinker() const;
const RigCaseToCaseCellMapper* cellMapper();
bool isCameraLinked();
bool isTimeStepLinked();
bool isCameraLinked() const;
bool showCursor() const;
bool isTimeStepLinked() const;
bool isResultColorControlled();
bool isLegendDefinitionsControlled();
bool isRangeFiltersControlled();
bool isResultColorControlled() const;
bool isLegendDefinitionsControlled() const;
bool isRangeFiltersControlled() const;
bool isVisibleCellsOveridden();
bool isPropertyFilterOveridden();
bool isVisibleCellsOveridden() const;
bool isPropertyFilterOveridden() const;
void scheduleCreateDisplayModelAndRedrawForDependentView();
void scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType);
void scheduleCreateDisplayModelAndRedrawForDependentView() const;
void scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType) const;
void updateOverrides();
void updateOptionSensitivity();
void removeOverrides();
@@ -93,24 +94,27 @@ private:
void updateResultColorsControl();
void updateLegendDefinitions();
bool isMasterAndDepViewDifferentType();
bool isRangeFilterControlPossible();
bool isPropertyFilterControlPossible();
bool isRangeFilterMappingApliccable();
bool isMasterAndDepViewDifferentType() const;
bool isRangeFilterControlPossible() const;
bool isPropertyFilterControlPossible() const;
bool isRangeFilterMappingApliccable() const;
RimEclipseView* managedEclipseView() const;
RimGeoMechView* managedGeoView() const;
RimEclipseView* managedEclipseView();
RimGeoMechView* managedGeoView();
static void removeOverrides(RimView* view);
static bool askUserToRestoreOriginalRangeFilterCollection(const QString& viewName);
private:
caf::PdmField<QString> m_name;
caf::PdmPtrField<RimView*> m_managedView;
caf::PdmField<bool> m_isActive;
caf::PdmField<bool> m_syncCamera;
caf::PdmField<bool> m_showCursor;
caf::PdmField<bool> m_syncTimeStep;
// Overridden properties
caf::PdmField<bool> m_syncCellResult;
caf::PdmField<bool> m_syncLegendDefinitions;

48
ApplicationCode/ProjectDataModel/RimViewLinker.cpp
View File

@@ -247,7 +247,7 @@ void RimViewLinker::removeOverrides()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::allViewsForCameraSync(RimView* source, std::vector<RimView*>& views)
void RimViewLinker::allViewsForCameraSync(const RimView* source, std::vector<RimView*>& views) const
{
if (!isActive()) return;
@@ -322,7 +322,7 @@ void RimViewLinker::setMasterView(RimView* view)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimView* RimViewLinker::masterView()
RimView* RimViewLinker::masterView() const
{
return m_masterView;
}
@@ -330,7 +330,7 @@ RimView* RimViewLinker::masterView()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::allViews(std::vector<RimView*>& views)
void RimViewLinker::allViews(std::vector<RimView*>& views) const
{
views.push_back(m_masterView());
@@ -382,7 +382,7 @@ void RimViewLinker::updateScaleZ(RimView* sourceView, double scaleZ)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimViewLinker::isActive()
bool RimViewLinker::isActive() const
{
RimViewLinkerCollection* viewLinkerCollection = NULL;
this->firstAncestorOrThisOfType(viewLinkerCollection);
@@ -482,6 +482,40 @@ void RimViewLinker::findNameAndIconFromView(QString* name, QIcon* icon, RimView*
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::updateCursorPosition(const RimView* sourceView, const cvf::Vec3d& domainCoord)
{
RimViewController* sourceViewLink = sourceView->viewController();
if (sourceViewLink && !sourceViewLink->showCursor())
{
return;
}
std::vector<RimView*> viewsToUpdate;
allViewsForCameraSync(sourceView, viewsToUpdate);
for (RimView* destinationView : viewsToUpdate)
{
if (destinationView == sourceView) continue;
if (destinationView != m_masterView)
{
RimViewController* viewLink = destinationView->viewController();
if (!viewLink) continue;
if (!viewLink->showCursor()) continue;
}
RiuViewer* destinationViewer = destinationView->viewer();
if (destinationViewer)
{
destinationViewer->setCursorPosition(domainCoord);
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -626,18 +660,16 @@ void RimViewLinker::addDependentView(RimView* view)
this->m_viewControllers.push_back(viewContr);
viewContr->setManagedView(view);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering)
void RimViewLinker::addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering) const
{
for (size_t j = 0; j < m_viewControllers.size(); j++)
{
uiTreeOrdering.add(m_viewControllers()[j]);
uiTreeOrdering.add(m_viewControllers[j]);
}
}

15
ApplicationCode/ProjectDataModel/RimViewLinker.h
View File

@@ -28,6 +28,9 @@
#include "cafPdmObject.h"
#include "cafPdmPtrField.h"
#include "cvfBase.h"
#include "cvfVector3.h"
namespace cvf
{
class BoundingBox;
@@ -50,10 +53,10 @@ public:
RimViewLinker(void);
virtual ~RimViewLinker(void);
bool isActive();
bool isActive() const;
void setMasterView(RimView* view);
RimView* masterView();
RimView* masterView() const;
void addDependentView(RimView* view);
void updateDependentViews();
@@ -73,15 +76,17 @@ public:
void scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType);
void scheduleCreateDisplayModelAndRedrawForDependentViews();
void allViews(std::vector<RimView*>& views);
void allViews(std::vector<RimView*>& views) const;
void updateUiNameAndIcon();
void addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering);
void addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering) const;
static void applyIconEnabledState(caf::PdmObject* obj, const QIcon& icon, bool disable);
static void findNameAndIconFromView(QString* name, QIcon* icon, RimView* view);
void updateCursorPosition(const RimView* sourceView, const cvf::Vec3d& domainCoord);
public:
static QString displayNameForView(RimView* view);
@@ -90,7 +95,7 @@ protected:
virtual void initAfterRead();
private:
void allViewsForCameraSync(RimView* source, std::vector<RimView*>& views);
void allViewsForCameraSync(const RimView* source, std::vector<RimView*>& views) const;
void removeOverrides();

24
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.cpp
View File

@@ -113,6 +113,30 @@ void RimWellLogExtractionCurve::setWellPath(RimWellPath* wellPath)
m_wellPath = wellPath;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellPath* RimWellLogExtractionCurve::wellPath() const
{
return m_wellPath;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimWellLogExtractionCurve::setCase(RimCase* rimCase)
{
m_case = rimCase;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCase* RimWellLogExtractionCurve::rimCase() const
{
return m_case;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

6
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurve.h
View File

@@ -41,8 +41,12 @@ public:
RimWellLogExtractionCurve();
virtual ~RimWellLogExtractionCurve();
void setWellPath(RimWellPath* wellPath);
RimWellPath* wellPath() const;
void setCase(RimCase* rimCase);
RimCase* rimCase() const;
void setPropertiesFromView(RimView* view);
virtual QString wellName() const;

88
ApplicationCode/UserInterface/RiuViewer.cpp
View File

@@ -39,6 +39,7 @@
#include "cafCategoryLegend.h"
#include "cafCeetronPlusNavigation.h"
#include "cafDisplayCoordTransform.h"
#include "cafEffectGenerator.h"
#include "cafFrameAnimationControl.h"
@@ -170,8 +171,9 @@ RiuViewer::RiuViewer(const QGLFormat& format, QWidget* parent)
setContextMenuPolicy(Qt::PreventContextMenu);
m_gridBoxGenerator = new RivGridBoxGenerator;
}
m_cursorPositionDomainCoords = cvf::Vec3d::UNDEFINED;
}
//--------------------------------------------------------------------------------------------------
///
@@ -408,6 +410,29 @@ void RiuViewer::paintOverlayItems(QPainter* painter)
m_versionInfoLabel->render(painter, pos);
yPos += size.height() + margin;
}
if (!m_cursorPositionDomainCoords.isUndefined())
{
if (mainCamera())
{
cvf::ref<caf::DisplayCoordTransform> trans = m_rimView->displayCoordTransform();
cvf::Vec3d displayCoord = trans->transformToDisplayCoord(m_cursorPositionDomainCoords);
cvf::Vec3d screenCoords;
if (mainCamera()->project(displayCoord, &screenCoords))
{
int translatedMousePosY = height() - screenCoords.y();
QPoint centerPos(screenCoords.x(), translatedMousePosY);
// Draw a cross hair marker
int markerHalfLength = 6;
painter->drawLine(centerPos.x(), centerPos.y() - markerHalfLength, centerPos.x(), centerPos.y() + markerHalfLength);
painter->drawLine(centerPos.x() - markerHalfLength, centerPos.y(), centerPos.x() + markerHalfLength, centerPos.y());
}
}
}
}
//--------------------------------------------------------------------------------------------------
@@ -658,6 +683,54 @@ void RiuViewer::resizeGL(int width, int height)
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuViewer::mouseMoveEvent(QMouseEvent* mouseEvent)
{
if (m_rimView)
{
RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
if (viewLinker)
{
int translatedMousePosX = mouseEvent->pos().x();
int translatedMousePosY = height() - mouseEvent->pos().y();
cvf::Vec3d displayCoord(0, 0, 0);
if (mainCamera()->unproject(cvf::Vec3d(static_cast<double>(translatedMousePosX), static_cast<double>(translatedMousePosY), 0), &displayCoord))
{
if (m_cursorPositionDomainCoords != cvf::Vec3d::UNDEFINED)
{
// Reset the extra cursor if the view currently is receiving mouse cursor events
// Set undefined and redraw to remove the previously displayed cursor
m_cursorPositionDomainCoords = cvf::Vec3d::UNDEFINED;
update();
}
cvf::ref<caf::DisplayCoordTransform> trans = m_rimView->displayCoordTransform();
cvf::Vec3d domainCoord = trans->transformToDomainCoord(displayCoord);
viewLinker->updateCursorPosition(m_rimView, domainCoord);
}
}
}
caf::Viewer::mouseMoveEvent(mouseEvent);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuViewer::leaveEvent(QEvent *)
{
if (m_rimView && m_rimView->assosiatedViewLinker())
{
RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
viewLinker->updateCursorPosition(m_rimView, cvf::Vec3d::UNDEFINED);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -755,6 +828,19 @@ void RiuViewer::updateParallelProjectionSettings(RiuViewer* sourceViewer)
this->updateParallelProjectionCameraPosFromPointOfInterestMove(poi);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiuViewer::setCursorPosition(const cvf::Vec3d& domainCoord)
{
if (m_cursorPositionDomainCoords != domainCoord)
{
m_cursorPositionDomainCoords = domainCoord;
update();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

6
ApplicationCode/UserInterface/RiuViewer.h
View File

@@ -96,6 +96,8 @@ public:
void updateParallelProjectionSettings(RiuViewer* sourceViewer);
void setCursorPosition(const cvf::Vec3d& domainCoord);
public slots:
virtual void slotSetCurrentFrame(int frameIndex);
virtual void slotEndAnimation();
@@ -103,6 +105,8 @@ public slots:
protected:
virtual void optimizeClippingPlanes();
virtual void resizeGL(int width, int height);
virtual void mouseMoveEvent(QMouseEvent* e) override;
virtual void leaveEvent(QEvent *) override;
private:
void updateTextAndTickMarkColorForOverlayItems();
@@ -140,5 +144,7 @@ private:
RiuViewerCommands* m_viewerCommands;
RivGridBoxGenerator* m_gridBoxGenerator;
cvf::Vec3d m_cursorPositionDomainCoords;
};