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

2d Maps: Renames to make classes and variables more consistent.

Browse Source 
* Everything is now named something related to ContourMap:
  - Rim2dEclipseView -> RimContourMapView
  - Rim2dGridProjection -> RimContourMapProjection
  ....
This commit is contained in:
Gaute Lindkvist 2018-11-09 09:04:40 +01:00
parent 9b8584c707
commit 53fad80e89
27 changed files with 254 additions and 255 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
ApplicationCode/Commands/CMakeLists_files.cmake
View File

@ -13,7 +13,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RicGeoMechPropertyFilterNewFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicGeoMechPropertyFilterNewInViewFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicGeoMechPropertyFilterNewExec.h
${CMAKE_CURRENT_LIST_DIR}/RicNewViewFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicNew2dContourViewFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicNewContourMapViewFeature.h
${CMAKE_CURRENT_LIST_DIR}/RicPropertyFilterNewExec.h
${CMAKE_CURRENT_LIST_DIR}/RicRangeFilterExecImpl.h
${CMAKE_CURRENT_LIST_DIR}/RicRangeFilterInsertExec.h
@ -92,7 +92,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RicGeoMechPropertyFilterNewFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicGeoMechPropertyFilterNewInViewFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicGeoMechPropertyFilterNewExec.cpp
${CMAKE_CURRENT_LIST_DIR}/RicNewViewFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicNew2dContourViewFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicNewContourMapViewFeature.cpp
${CMAKE_CURRENT_LIST_DIR}/RicRangeFilterExecImpl.cpp
${CMAKE_CURRENT_LIST_DIR}/RicRangeFilterInsertExec.cpp
${CMAKE_CURRENT_LIST_DIR}/RicRangeFilterInsertFeature.cpp

30
ApplicationCode/Commands/RicNew2dContourViewFeature.cpp → ApplicationCode/Commands/RicNewContourMapViewFeature.cpp
View File

@ -16,10 +16,10 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "RicNew2dContourViewFeature.h"
#include "RicNewContourMapViewFeature.h"
#include "Rim2dEclipseView.h"
#include "Rim2dEclipseViewCollection.h"
#include "RimContourMapView.h"
#include "RimContourMapViewCollection.h"
#include "RimCellEdgeColors.h"
#include "RimEclipseView.h"
#include "RimEclipseCase.h"
@ -37,27 +37,27 @@
#include <QAction>
CAF_CMD_SOURCE_INIT(RicNew2dContourViewFeature, "RicNew2dContourViewFeature");
CAF_CMD_SOURCE_INIT(RicNewContourMapViewFeature, "RicNewContourMapViewFeature");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RicNew2dContourViewFeature::isCommandEnabled()
bool RicNewContourMapViewFeature::isCommandEnabled()
{
bool selectedView = caf::SelectionManager::instance()->selectedItemOfType<RimEclipseView>() != nullptr;
bool selectedCase = caf::SelectionManager::instance()->selectedItemOfType<RimEclipseCase>() != nullptr;
bool selectedMapCollection = caf::SelectionManager::instance()->selectedItemOfType<Rim2dEclipseViewCollection>();
bool selectedMapCollection = caf::SelectionManager::instance()->selectedItemOfType<RimContourMapViewCollection>();
return selectedView || selectedCase || selectedMapCollection;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicNew2dContourViewFeature::onActionTriggered(bool isChecked)
void RicNewContourMapViewFeature::onActionTriggered(bool isChecked)
{
RimEclipseView* reservoirView = caf::SelectionManager::instance()->selectedItemOfType<RimEclipseView>();
RimEclipseCase* eclipseCase = caf::SelectionManager::instance()->selectedItemAncestorOfType<RimEclipseCase>();
Rim2dEclipseView* contourMap = nullptr;
RimContourMapView* contourMap = nullptr;
// Find case to insert into
if (reservoirView)
@ -85,9 +85,9 @@ void RicNew2dContourViewFeature::onActionTriggered(bool isChecked)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicNew2dContourViewFeature::setupActionLook(QAction* actionToSetup)
void RicNewContourMapViewFeature::setupActionLook(QAction* actionToSetup)
{
Rim2dEclipseView* contourMap = caf::SelectionManager::instance()->selectedItemOfType<Rim2dEclipseView>();
RimContourMapView* contourMap = caf::SelectionManager::instance()->selectedItemOfType<RimContourMapView>();
RimEclipseView* eclipseView = caf::SelectionManager::instance()->selectedItemOfType<RimEclipseView>();
if (contourMap)
{
@ -107,10 +107,10 @@ void RicNew2dContourViewFeature::setupActionLook(QAction* actionToSetup)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dEclipseView* RicNew2dContourViewFeature::create2dContourMapFrom3dView(RimEclipseCase* eclipseCase, const RimEclipseView* sourceView)
RimContourMapView* RicNewContourMapViewFeature::create2dContourMapFrom3dView(RimEclipseCase* eclipseCase, const RimEclipseView* sourceView)
{
Rim2dEclipseView* contourMap = dynamic_cast<Rim2dEclipseView*>(sourceView->xmlCapability()->copyAndCastByXmlSerialization(
Rim2dEclipseView::classKeywordStatic(), sourceView->classKeyword(), caf::PdmDefaultObjectFactory::instance()));
RimContourMapView* contourMap = dynamic_cast<RimContourMapView*>(sourceView->xmlCapability()->copyAndCastByXmlSerialization(
RimContourMapView::classKeywordStatic(), sourceView->classKeyword(), caf::PdmDefaultObjectFactory::instance()));
CVF_ASSERT(contourMap);
contourMap->setEclipseCase(eclipseCase);
@ -132,9 +132,9 @@ Rim2dEclipseView* RicNew2dContourViewFeature::create2dContourMapFrom3dView(RimEc
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dEclipseView* RicNew2dContourViewFeature::create2dContourMap(RimEclipseCase* eclipseCase)
RimContourMapView* RicNewContourMapViewFeature::create2dContourMap(RimEclipseCase* eclipseCase)
{
Rim2dEclipseView* contourMap = new Rim2dEclipseView();
RimContourMapView* contourMap = new RimContourMapView();
contourMap->setEclipseCase(eclipseCase);
// Set default values

8
ApplicationCode/Commands/RicNew2dContourViewFeature.h → ApplicationCode/Commands/RicNewContourMapViewFeature.h
View File

@ -22,13 +22,13 @@
#include "cafCmdFeature.h"
class RimEclipseCase;
class Rim2dEclipseView;
class RimContourMapView;
class RimEclipseView;
//==================================================================================================
///
//==================================================================================================
class RicNew2dContourViewFeature : public caf::CmdFeature
class RicNewContourMapViewFeature : public caf::CmdFeature
{
CAF_CMD_HEADER_INIT;
@ -38,7 +38,7 @@ protected:
void onActionTriggered( bool isChecked ) override;
void setupActionLook( QAction* actionToSetup ) override;
static Rim2dEclipseView* create2dContourMapFrom3dView(RimEclipseCase* eclipseCase, const RimEclipseView* reservoirView);
static Rim2dEclipseView* create2dContourMap(RimEclipseCase* eclipseCase);
static RimContourMapView* create2dContourMapFrom3dView(RimEclipseCase* eclipseCase, const RimEclipseView* reservoirView);
static RimContourMapView* create2dContourMap(RimEclipseCase* eclipseCase);
};

4
ApplicationCode/Commands/RicNewViewFeature.cpp
View File

@ -19,7 +19,7 @@
#include "RicNewViewFeature.h"
#include "Rim2dEclipseView.h"
#include "RimContourMapView.h"
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimGeoMechCase.h"
@ -161,7 +161,7 @@ RimEclipseView* RicNewViewFeature::selectedEclipseView()
for (RimEclipseView* view : selection)
{
if (dynamic_cast<Rim2dEclipseView*>(view) == nullptr)
if (dynamic_cast<RimContourMapView*>(view) == nullptr)
{
return view;
}

4
ApplicationCode/Commands/RicTogglePerspectiveViewFeature.cpp
View File

@ -20,7 +20,7 @@
#include "RicTogglePerspectiveViewFeature.h"
#include "RiuViewer.h"
#include "Rim2dEclipseView.h"
#include "RimContourMapView.h"
#include "Rim3dView.h"
#include "RimGridView.h"
#include "RiuMainWindow.h"
@ -37,7 +37,7 @@ bool RicTogglePerspectiveViewFeature::isCommandEnabled()
{
this->action(); // Retrieve the action to update the looks
RimGridView* activeGridView = RiaApplication::instance()->activeGridView();
Rim2dEclipseView* view2d = dynamic_cast<Rim2dEclipseView*>(activeGridView);
RimContourMapView* view2d = dynamic_cast<RimContourMapView*>(activeGridView);
return !view2d && activeGridView && RiaApplication::instance()->activeReservoirView()->viewer();
}

4
ApplicationCode/Commands/ViewLink/RicLinkVisibleViewsFeatureUi.cpp
View File

@ -22,7 +22,7 @@
#include "RiaApplication.h"
#include "RiaOptionItemFactory.h"
#include "Rim2dEclipseView.h"
#include "RimContourMapView.h"
#include "RimCase.h"
#include "RimGridView.h"
#include "RimViewLinker.h"
@ -83,7 +83,7 @@ std::vector<RimGridView*> RicLinkVisibleViewsFeatureUi::masterViewCandidates() c
// Set Active view as master view if the active view isn't a contour map.
for (size_t i = 0; i < m_allViews.size(); i++)
{
Rim2dEclipseView* contourMap = dynamic_cast<Rim2dEclipseView*>(m_allViews[i]);
RimContourMapView* contourMap = dynamic_cast<RimContourMapView*>(m_allViews[i]);
if (contourMap == nullptr)
{
masterCandidates.push_back(m_allViews[i]);

4
ApplicationCode/ModelVisualization/CMakeLists_files.cmake
View File

@ -45,7 +45,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RivWellConnectionSourceInfo.h
${CMAKE_CURRENT_LIST_DIR}/RivSimWellConnectionSourceInfo.h
${CMAKE_CURRENT_LIST_DIR}/Riv3dWellLogDrawSurfaceGenerator.h
${CMAKE_CURRENT_LIST_DIR}/RivMeshLinesSourceInfo.h
${CMAKE_CURRENT_LIST_DIR}/Riv2dGridProjectionPartMgr.h
${CMAKE_CURRENT_LIST_DIR}/RivContourMapProjectionPartMgr.h
)
set (SOURCE_GROUP_SOURCE_FILES
@ -89,7 +89,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RivWellConnectionSourceInfo.cpp
${CMAKE_CURRENT_LIST_DIR}/RivSimWellConnectionSourceInfo.cpp
${CMAKE_CURRENT_LIST_DIR}/Riv3dWellLogDrawSurfaceGenerator.cpp
${CMAKE_CURRENT_LIST_DIR}/RivMeshLinesSourceInfo.cpp
${CMAKE_CURRENT_LIST_DIR}/Riv2dGridProjectionPartMgr.cpp
${CMAKE_CURRENT_LIST_DIR}/RivContourMapProjectionPartMgr.cpp
)
list(APPEND CODE_HEADER_FILES

48
ApplicationCode/ModelVisualization/Riv2dGridProjectionPartMgr.cpp → ApplicationCode/ModelVisualization/RivContourMapProjectionPartMgr.cpp
View File

@ -1,11 +1,11 @@
#include "Riv2dGridProjectionPartMgr.h"
#include "RivContourMapProjectionPartMgr.h"
#include "RiaWeightedMeanCalculator.h"
#include "RivMeshLinesSourceInfo.h"
#include "RivScalarMapperUtils.h"
#include "Rim2dEclipseView.h"
#include "Rim2dGridProjection.h"
#include "RimContourMapView.h"
#include "RimContourMapProjection.h"
#include "cafEffectGenerator.h"
@ -20,16 +20,16 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Riv2dGridProjectionPartMgr::Riv2dGridProjectionPartMgr(Rim2dGridProjection* gridProjection, Rim2dEclipseView* contourMap)
RivContourMapProjectionPartMgr::RivContourMapProjectionPartMgr(RimContourMapProjection* contourMapProjection, RimContourMapView* contourMap)
{
m_2dGridProjection = gridProjection;
m_contourMapProjection = contourMapProjection;
m_parentContourMap = contourMap;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Riv2dGridProjectionPartMgr::appendProjectionToModel(cvf::ModelBasicList* model, const caf::DisplayCoordTransform* displayCoordTransform) const
void RivContourMapProjectionPartMgr::appendProjectionToModel(cvf::ModelBasicList* model, const caf::DisplayCoordTransform* displayCoordTransform) const
{
cvf::ref<cvf::DrawableGeo> drawable = createDrawable(displayCoordTransform);
if (drawable.notNull() && drawable->boundingBox().isValid())
@ -38,15 +38,15 @@ void Riv2dGridProjectionPartMgr::appendProjectionToModel(cvf::ModelBasicList* mo
part->setDrawable(drawable.p());
cvf::ref<cvf::Vec2fArray> textureCoords = createTextureCoords();
cvf::ScalarMapper* mapper = m_2dGridProjection->legendConfig()->scalarMapper();
cvf::ScalarMapper* mapper = m_contourMapProjection->legendConfig()->scalarMapper();
RivScalarMapperUtils::applyTextureResultsToPart(part.p(), textureCoords.p(), mapper, 1.0f, caf::FC_NONE, true, m_parentContourMap->backgroundColor());
part->setSourceInfo(new RivMeshLinesSourceInfo(m_2dGridProjection.p()));
part->setSourceInfo(new RivMeshLinesSourceInfo(m_contourMapProjection.p()));
model->addPart(part.p());
}
if (m_2dGridProjection->showContourLines())
if (m_contourMapProjection->showContourLines())
{
std::vector<cvf::ref<cvf::DrawableGeo>> contourDrawables = createContourPolygons(displayCoordTransform);
for (cvf::ref<cvf::DrawableGeo> contourDrawable : contourDrawables)
@ -61,7 +61,7 @@ void Riv2dGridProjectionPartMgr::appendProjectionToModel(cvf::ModelBasicList* mo
cvf::ref<cvf::Part> part = new cvf::Part;
part->setDrawable(contourDrawable.p());
part->setEffect(effect.p());
part->setSourceInfo(new RivMeshLinesSourceInfo(m_2dGridProjection.p()));
part->setSourceInfo(new RivMeshLinesSourceInfo(m_contourMapProjection.p()));
model->addPart(part.p());
}
@ -72,21 +72,21 @@ void Riv2dGridProjectionPartMgr::appendProjectionToModel(cvf::ModelBasicList* mo
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::Vec2fArray> Riv2dGridProjectionPartMgr::createTextureCoords() const
cvf::ref<cvf::Vec2fArray> RivContourMapProjectionPartMgr::createTextureCoords() const
{
cvf::Vec2ui patchSize = m_2dGridProjection->surfaceGridSize();
cvf::Vec2ui patchSize = m_contourMapProjection->surfaceGridSize();
cvf::ref<cvf::Vec2fArray> textureCoords = new cvf::Vec2fArray(m_2dGridProjection->vertexCount());
cvf::ref<cvf::Vec2fArray> textureCoords = new cvf::Vec2fArray(m_contourMapProjection->vertexCount());
for (uint j = 0; j < patchSize.y(); ++j)
{
for (uint i = 0; i < patchSize.x(); ++i)
{
if (m_2dGridProjection->hasResultAt(i, j))
if (m_contourMapProjection->hasResultAt(i, j))
{
double value = m_2dGridProjection->value(i, j);
double value = m_contourMapProjection->value(i, j);
(*textureCoords)[i + j * patchSize.x()] =
m_2dGridProjection->legendConfig()->scalarMapper()->mapToTextureCoord(value);
m_contourMapProjection->legendConfig()->scalarMapper()->mapToTextureCoord(value);
}
else
{
@ -100,7 +100,7 @@ cvf::ref<cvf::Vec2fArray> Riv2dGridProjectionPartMgr::createTextureCoords() cons
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Riv2dGridProjectionPartMgr::removeTrianglesWithNoResult(cvf::UIntArray* vertices) const
void RivContourMapProjectionPartMgr::removeTrianglesWithNoResult(cvf::UIntArray* vertices) const
{
std::vector<cvf::uint> trianglesWithResult;
@ -110,8 +110,8 @@ void Riv2dGridProjectionPartMgr::removeTrianglesWithNoResult(cvf::UIntArray* ver
for (size_t t = 0; !anyInvalid && t < 3; ++t)
{
cvf::uint vertexNumber = (*vertices)[n + t];
cvf::Vec2ui ij = m_2dGridProjection->ijFromGridIndex(vertexNumber);
if (!m_2dGridProjection->hasResultAt(ij.x(), ij.y()))
cvf::Vec2ui ij = m_contourMapProjection->ijFromGridIndex(vertexNumber);
if (!m_contourMapProjection->hasResultAt(ij.x(), ij.y()))
{
anyInvalid = true;
}
@ -128,11 +128,11 @@ void Riv2dGridProjectionPartMgr::removeTrianglesWithNoResult(cvf::UIntArray* ver
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::DrawableGeo> Riv2dGridProjectionPartMgr::createDrawable(const caf::DisplayCoordTransform* displayCoordTransform) const
cvf::ref<cvf::DrawableGeo> RivContourMapProjectionPartMgr::createDrawable(const caf::DisplayCoordTransform* displayCoordTransform) const
{
cvf::ref<cvf::Vec3fArray> vertexArray = new cvf::Vec3fArray;
m_2dGridProjection->generateVertices(vertexArray.p(), displayCoordTransform);
cvf::Vec2ui patchSize = m_2dGridProjection->surfaceGridSize();
m_contourMapProjection->generateVertices(vertexArray.p(), displayCoordTransform);
cvf::Vec2ui patchSize = m_contourMapProjection->surfaceGridSize();
// Surface
cvf::ref<cvf::UIntArray> faceList = new cvf::UIntArray;
@ -151,9 +151,9 @@ cvf::ref<cvf::DrawableGeo> Riv2dGridProjectionPartMgr::createDrawable(const caf:
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<cvf::ref<cvf::DrawableGeo>> Riv2dGridProjectionPartMgr::createContourPolygons(const caf::DisplayCoordTransform* displayCoordTransform) const
std::vector<cvf::ref<cvf::DrawableGeo>> RivContourMapProjectionPartMgr::createContourPolygons(const caf::DisplayCoordTransform* displayCoordTransform) const
{
Rim2dGridProjection::ContourPolygons contourPolygons = m_2dGridProjection->generateContourPolygons(displayCoordTransform);
RimContourMapProjection::ContourPolygons contourPolygons = m_contourMapProjection->generateContourPolygons(displayCoordTransform);
std::vector<cvf::ref<cvf::DrawableGeo>> contourDrawables;
contourDrawables.reserve(contourPolygons.size());

12
ApplicationCode/ModelVisualization/Riv2dGridProjectionPartMgr.h → ApplicationCode/ModelVisualization/RivContourMapProjectionPartMgr.h
View File

@ -26,13 +26,13 @@
#include "cvfModelBasicList.h"
#include "cvfObject.h"
class Rim2dEclipseView;
class Rim2dGridProjection;
class RimContourMapView;
class RimContourMapProjection;
class Riv2dGridProjectionPartMgr : public cvf::Object
class RivContourMapProjectionPartMgr : public cvf::Object
{
public:
Riv2dGridProjectionPartMgr(Rim2dGridProjection* gridProjection, Rim2dEclipseView* contourMap);
RivContourMapProjectionPartMgr(RimContourMapProjection* contourMapProjection, RimContourMapView* contourMap);
void appendProjectionToModel(cvf::ModelBasicList* model,
const caf::DisplayCoordTransform* displayCoordTransform) const;
@ -44,7 +44,7 @@ private:
cvf::ref<cvf::DrawableGeo> createDrawable(const caf::DisplayCoordTransform* displayCoordTransform) const;
std::vector<cvf::ref<cvf::DrawableGeo>> createContourPolygons(const caf::DisplayCoordTransform* displayCoordTransform) const;
private:
caf::PdmPointer<Rim2dGridProjection> m_2dGridProjection;
caf::PdmPointer<Rim2dEclipseView> m_parentContourMap;
caf::PdmPointer<RimContourMapProjection> m_contourMapProjection;
caf::PdmPointer<RimContourMapView> m_parentContourMap;
};

12
ApplicationCode/ProjectDataModel/CMakeLists_files.cmake
View File

@ -117,9 +117,9 @@ ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileCurveNameConfig.h
${CMAKE_CURRENT_LIST_DIR}/RimWellLogRftCurveNameConfig.h
${CMAKE_CURRENT_LIST_DIR}/RimDataSourceSteppingTools.h
${CMAKE_CURRENT_LIST_DIR}/RimWellLogCurveCommonDataSource.h
${CMAKE_CURRENT_LIST_DIR}/Rim2dGridProjection.h
${CMAKE_CURRENT_LIST_DIR}/Rim2dEclipseView.h
${CMAKE_CURRENT_LIST_DIR}/Rim2dEclipseViewCollection.h
${CMAKE_CURRENT_LIST_DIR}/RimContourMapProjection.h
${CMAKE_CURRENT_LIST_DIR}/RimContourMapView.h
${CMAKE_CURRENT_LIST_DIR}/RimContourMapViewCollection.h
)
@ -241,9 +241,9 @@ ${CMAKE_CURRENT_LIST_DIR}/RimWellLogFileCurveNameConfig.cpp
${CMAKE_CURRENT_LIST_DIR}/RimWellLogRftCurveNameConfig.cpp
${CMAKE_CURRENT_LIST_DIR}/RimDataSourceSteppingTools.cpp
${CMAKE_CURRENT_LIST_DIR}/RimWellLogCurveCommonDataSource.cpp
${CMAKE_CURRENT_LIST_DIR}/Rim2dGridProjection.cpp
${CMAKE_CURRENT_LIST_DIR}/Rim2dEclipseView.cpp
${CMAKE_CURRENT_LIST_DIR}/Rim2dEclipseViewCollection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimContourMapProjection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimContourMapView.cpp
${CMAKE_CURRENT_LIST_DIR}/RimContourMapViewCollection.cpp
)
list(APPEND CODE_HEADER_FILES

44
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@ -37,8 +37,8 @@
#include "RigMainGrid.h"
#include "RigStatisticsDataCache.h"
#include "Rim2dEclipseView.h"
#include "Rim2dGridProjection.h"
#include "RimContourMapView.h"
#include "RimContourMapProjection.h"
#include "Rim2dIntersectionView.h"
#include "Rim2dIntersectionViewCollection.h"
#include "Rim3dView.h"
@ -176,7 +176,7 @@ Rim3dOverlayInfoConfig::HistogramData Rim3dOverlayInfoConfig::histogramData()
{
auto eclipseView = dynamic_cast<RimEclipseView*>(m_viewDef.p());
auto geoMechView = dynamic_cast<RimGeoMechView*>(m_viewDef.p());
auto contourMap = dynamic_cast<Rim2dEclipseView*>(eclipseView);
auto contourMap = dynamic_cast<RimContourMapView*>(eclipseView);
if (contourMap) return histogramData(contourMap);
else if (eclipseView) return histogramData(eclipseView);
@ -278,20 +278,20 @@ void Rim3dOverlayInfoConfig::setIsActive(bool active)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim3dOverlayInfoConfig::HistogramData Rim3dOverlayInfoConfig::histogramData(Rim2dEclipseView* contourMap)
Rim3dOverlayInfoConfig::HistogramData Rim3dOverlayInfoConfig::histogramData(RimContourMapView* contourMap)
{
HistogramData histData;
if (contourMap)
{
bool isResultsInfoRelevant = contourMap->grid2dProjection()->validVertexCount() > 0u;
bool isResultsInfoRelevant = contourMap->contourMapProjection()->validVertexCount() > 0u;
if (isResultsInfoRelevant)
{
histData.min = contourMap->grid2dProjection()->minValue();
histData.max = contourMap->grid2dProjection()->maxValue();
histData.mean = contourMap->grid2dProjection()->meanValue();
histData.sum = contourMap->grid2dProjection()->sumAllValues();
histData.min = contourMap->contourMapProjection()->minValue();
histData.max = contourMap->contourMapProjection()->maxValue();
histData.mean = contourMap->contourMapProjection()->meanValue();
histData.sum = contourMap->contourMapProjection()->sumAllValues();
}
}
return histData;
@ -496,20 +496,20 @@ QString Rim3dOverlayInfoConfig::caseInfoText(RimEclipseView* eclipseView)
{
QString caseName = eclipseView->eclipseCase()->caseUserDescription();
Rim2dEclipseView* contourMap = dynamic_cast<Rim2dEclipseView*>(eclipseView);
if (contourMap && contourMap->grid2dProjection())
RimContourMapView* contourMap = dynamic_cast<RimContourMapView*>(eclipseView);
if (contourMap && contourMap->contourMapProjection())
{
QString totCellCount = QString::number(contourMap->grid2dProjection()->vertexCount());
cvf::uint validCellCount = contourMap->grid2dProjection()->validVertexCount();
QString totCellCount = QString::number(contourMap->contourMapProjection()->vertexCount());
cvf::uint validCellCount = contourMap->contourMapProjection()->validVertexCount();
QString activeCellCountText = QString::number(validCellCount);
QString iSize = QString::number(contourMap->grid2dProjection()->surfaceGridSize().x());
QString jSize = QString::number(contourMap->grid2dProjection()->surfaceGridSize().y());
QString aggregationType = contourMap->grid2dProjection()->resultAggregationText();
QString iSize = QString::number(contourMap->contourMapProjection()->surfaceGridSize().x());
QString jSize = QString::number(contourMap->contourMapProjection()->surfaceGridSize().y());
QString aggregationType = contourMap->contourMapProjection()->resultAggregationText();
infoText += QString(
"<p><b>-- %1 --</b><p> "
"<b>2d Sample Count. Total:</b> %2 <b>Valid Result:</b> %3 <br>"
"<b>2d %4 Projection, 2d Grid I,J:</b> %5, %6 <br>").arg(caseName, totCellCount, activeCellCountText, aggregationType, iSize, jSize);
"<p><b>-- Contour Map: %1 --</b><p> "
"<b>Sample Count. Total:</b> %2 <b>Valid Results:</b> %3 <br>"
"<b>Projection Type: %4<br>").arg(caseName, totCellCount, activeCellCountText, aggregationType);
}
else if (eclipseView->mainGrid())
{
@ -573,11 +573,11 @@ QString Rim3dOverlayInfoConfig::resultInfoText(const HistogramData& histData, Ri
{
QString infoText;
Rim2dEclipseView* contourMap = dynamic_cast<Rim2dEclipseView*>(eclipseView);
RimContourMapView* contourMap = dynamic_cast<RimContourMapView*>(eclipseView);
if (contourMap)
{
bool isResultsInfoRelevant = contourMap->grid2dProjection()->validVertexCount() > 0u;
bool isResultsInfoRelevant = contourMap->contourMapProjection()->validVertexCount() > 0u;
if (isResultsInfoRelevant)
{
QString propName = eclipseView->cellResult()->resultVariableUiShortName();
@ -815,7 +815,7 @@ void Rim3dOverlayInfoConfig::defineUiOrdering(QString uiConfigName, caf::PdmUiOr
caf::PdmUiGroup* visGroup = uiOrdering.addNewGroup("Visibility");
RimEclipseView * eclipseView = dynamic_cast<RimEclipseView*>(m_viewDef.p());
Rim2dEclipseView* contourMap = dynamic_cast<Rim2dEclipseView*>(eclipseView);
RimContourMapView* contourMap = dynamic_cast<RimContourMapView*>(eclipseView);
RimGeoMechView * geoMechView = dynamic_cast<RimGeoMechView*>(m_viewDef.p());
visGroup->add(&m_showAnimProgress);

4
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.h
View File

@ -30,7 +30,7 @@
#include <cmath>
#include <memory>
class Rim2dEclipseView;
class RimContourMapView;
class RimEclipseView;
class RimGeoMechView;
class RimGridView;
@ -113,7 +113,7 @@ private:
QString timeStepText(RimEclipseView* eclipseView);
QString timeStepText(RimGeoMechView* geoMechView);
HistogramData histogramData(Rim2dEclipseView* contourMap);
HistogramData histogramData(RimContourMapView* contourMap);
HistogramData histogramData(RimEclipseView* eclipseView);
HistogramData histogramData(RimGeoMechView* geoMechView);
QString caseInfoText(RimEclipseView* eclipseView);

10
ApplicationCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@ -21,7 +21,6 @@
#include "RiaApplication.h"
#include "Rim2dEclipseViewCollection.h"
#include "Rim3dOverlayInfoConfig.h"
#include "Rim3dWellLogCurveCollection.h"
#include "Rim3dWellLogExtractionCurve.h"
@ -31,6 +30,7 @@
#include "RimCaseCollection.h"
#include "RimCellRangeFilter.h"
#include "RimCellRangeFilterCollection.h"
#include "RimContourMapViewCollection.h"
#include "RimEclipseCase.h"
#include "RimEclipseCaseCollection.h"
#include "RimEclipseCellColors.h"
@ -156,14 +156,14 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
menuBuilder << "RicPasteEclipseViewsFeature";
menuBuilder << "Separator";
menuBuilder << "RicNewViewFeature";
menuBuilder << "RicNew2dContourViewFeature";
menuBuilder << "RicNewContourMapViewFeature";
menuBuilder << "Separator";
menuBuilder << "RicCopyReferencesToClipboardFeature";
menuBuilder << "RicSaveEclipseInputVisibleCellsFeature";
}
else if (dynamic_cast<Rim2dEclipseViewCollection*>(uiItem))
else if (dynamic_cast<RimContourMapViewCollection*>(uiItem))
{
menuBuilder << "RicNew2dContourViewFeature";
menuBuilder << "RicNewContourMapViewFeature";
}
else if (dynamic_cast<RimCaseCollection*>(uiItem))
{
@ -184,7 +184,7 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
menuBuilder << "Separator";
menuBuilder << "RicNewViewFeature";
menuBuilder << "RicNew2dContourViewFeature";
menuBuilder << "RicNewContourMapViewFeature";
menuBuilder << "RicShowFlowCharacteristicsPlotFeature";
menuBuilder << "RicEclipseCaseNewGroupFeature";
menuBuilder << "Separator";

120
ApplicationCode/ProjectDataModel/Rim2dGridProjection.cpp → ApplicationCode/ProjectDataModel/RimContourMapProjection.cpp
View File

@ -1,4 +1,4 @@
#include "Rim2dGridProjection.h"
#include "RimContourMapProjection.h"
#include "RiaWeightedGeometricMeanCalculator.h"
#include "RiaWeightedHarmonicMeanCalculator.h"
@ -39,30 +39,30 @@
namespace caf
{
template<>
void Rim2dGridProjection::ResultAggregation::setUp()
void RimContourMapProjection::ResultAggregation::setUp()
{
addItem(Rim2dGridProjection::RESULTS_TOP_VALUE, "TOP_VALUE", "Top Value");
addItem(Rim2dGridProjection::RESULTS_MEAN_VALUE, "MEAN_VALUE", "Arithmetic Mean");
addItem(Rim2dGridProjection::RESULTS_HARM_VALUE, "HARM_VALUE", "Harmonic Mean");
addItem(Rim2dGridProjection::RESULTS_GEOM_VALUE, "GEOM_VALUE", "Geometric Mean");
addItem(Rim2dGridProjection::RESULTS_MIN_VALUE, "MIN_VALUE", "Min Value");
addItem(Rim2dGridProjection::RESULTS_MAX_VALUE, "MAX_VALUE", "Max Value");
addItem(Rim2dGridProjection::RESULTS_SUM, "SUM", "Sum");
addItem(Rim2dGridProjection::RESULTS_OIL_COLUMN, "OIL_COLUMN", "Oil Column");
addItem(Rim2dGridProjection::RESULTS_GAS_COLUMN, "GAS_COLUMN", "Gas Column");
addItem(Rim2dGridProjection::RESULTS_HC_COLUMN, "HC_COLUMN", "Hydrocarbon Column");
addItem(RimContourMapProjection::RESULTS_TOP_VALUE, "TOP_VALUE", "Top Value");
addItem(RimContourMapProjection::RESULTS_MEAN_VALUE, "MEAN_VALUE", "Arithmetic Mean");
addItem(RimContourMapProjection::RESULTS_HARM_VALUE, "HARM_VALUE", "Harmonic Mean");
addItem(RimContourMapProjection::RESULTS_GEOM_VALUE, "GEOM_VALUE", "Geometric Mean");
addItem(RimContourMapProjection::RESULTS_MIN_VALUE, "MIN_VALUE", "Min Value");
addItem(RimContourMapProjection::RESULTS_MAX_VALUE, "MAX_VALUE", "Max Value");
addItem(RimContourMapProjection::RESULTS_SUM, "SUM", "Sum");
addItem(RimContourMapProjection::RESULTS_OIL_COLUMN, "OIL_COLUMN", "Oil Column");
addItem(RimContourMapProjection::RESULTS_GAS_COLUMN, "GAS_COLUMN", "Gas Column");
addItem(RimContourMapProjection::RESULTS_HC_COLUMN, "HC_COLUMN", "Hydrocarbon Column");
setDefault(Rim2dGridProjection::RESULTS_TOP_VALUE);
setDefault(RimContourMapProjection::RESULTS_TOP_VALUE);
}
}
CAF_PDM_SOURCE_INIT(Rim2dGridProjection, "Rim2dGridProjection");
CAF_PDM_SOURCE_INIT(RimContourMapProjection, "RimContourMapProjection");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dGridProjection::Rim2dGridProjection()
RimContourMapProjection::RimContourMapProjection()
{
CAF_PDM_InitObject("Rim2dGridProjection", ":/draw_style_meshlines_24x24.png", "", "");
CAF_PDM_InitObject("RimContourMapProjection", ":/draw_style_meshlines_24x24.png", "", "");
CAF_PDM_InitField(&m_relativeSampleSpacing, "SampleSpacing", 0.75, "Sample Spacing Factor", "", "", "");
m_relativeSampleSpacing.uiCapability()->setUiEditorTypeName(caf::PdmUiDoubleSliderEditor::uiEditorTypeName());
@ -71,7 +71,7 @@ Rim2dGridProjection::Rim2dGridProjection()
CAF_PDM_InitField(&m_showContourLines, "ContourLines", true, "Show Contour Lines", "", "", "");
setName("2d Grid Projection");
setName("Map Projection");
nameField()->uiCapability()->setUiReadOnly(true);
m_resultAccessor = new RigHugeValResultAccessor;
@ -80,7 +80,7 @@ Rim2dGridProjection::Rim2dGridProjection()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dGridProjection::~Rim2dGridProjection()
RimContourMapProjection::~RimContourMapProjection()
{
}
@ -88,7 +88,7 @@ Rim2dGridProjection::~Rim2dGridProjection()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::BoundingBox Rim2dGridProjection::expandedBoundingBox() const
cvf::BoundingBox RimContourMapProjection::expandedBoundingBox() const
{
cvf::BoundingBox boundingBox = eclipseCase()->activeCellsBoundingBox();
boundingBox.expand(sampleSpacing() * 0.5);
@ -98,7 +98,7 @@ cvf::BoundingBox Rim2dGridProjection::expandedBoundingBox() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dGridProjection::generateGridMapping()
void RimContourMapProjection::generateGridMapping()
{
calculateTotalCellVisibility();
@ -126,7 +126,7 @@ void Rim2dGridProjection::generateGridMapping()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dGridProjection::generateVertices(cvf::Vec3fArray* vertices, const caf::DisplayCoordTransform* displayCoordTransform)
void RimContourMapProjection::generateVertices(cvf::Vec3fArray* vertices, const caf::DisplayCoordTransform* displayCoordTransform)
{
CVF_ASSERT(vertices);
vertices->resize(vertexCount());
@ -153,7 +153,7 @@ void Rim2dGridProjection::generateVertices(cvf::Vec3fArray* vertices, const caf:
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dGridProjection::ContourPolygons Rim2dGridProjection::generateContourPolygons(const caf::DisplayCoordTransform* displayCoordTransform)
RimContourMapProjection::ContourPolygons RimContourMapProjection::generateContourPolygons(const caf::DisplayCoordTransform* displayCoordTransform)
{
std::vector<cvf::ref<cvf::Vec3fArray>> contourPolygons;
if (minValue() != std::numeric_limits<double>::infinity() && maxValue() != -std::numeric_limits<double>::infinity())
@ -193,7 +193,7 @@ Rim2dGridProjection::ContourPolygons Rim2dGridProjection::generateContourPolygon
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dGridProjection::generateResults()
void RimContourMapProjection::generateResults()
{
generateGridMapping();
int nVertices = vertexCount();
@ -277,7 +277,7 @@ void Rim2dGridProjection::generateResults()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double Rim2dGridProjection::maxValue() const
double RimContourMapProjection::maxValue() const
{
double maxV = -std::numeric_limits<double>::infinity();
@ -296,7 +296,7 @@ double Rim2dGridProjection::maxValue() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double Rim2dGridProjection::minValue() const
double RimContourMapProjection::minValue() const
{
double minV = std::numeric_limits<double>::infinity();
@ -315,7 +315,7 @@ double Rim2dGridProjection::minValue() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double Rim2dGridProjection::meanValue() const
double RimContourMapProjection::meanValue() const
{
return sumAllValues() / validVertexCount();
}
@ -323,7 +323,7 @@ double Rim2dGridProjection::meanValue() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double Rim2dGridProjection::sumAllValues() const
double RimContourMapProjection::sumAllValues() const
{
double sum = 0.0;
@ -342,7 +342,7 @@ double Rim2dGridProjection::sumAllValues() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double Rim2dGridProjection::sampleSpacing() const
double RimContourMapProjection::sampleSpacing() const
{
return m_relativeSampleSpacing * mainGrid()->characteristicIJCellSize();
}
@ -350,7 +350,7 @@ double Rim2dGridProjection::sampleSpacing() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Rim2dGridProjection::showContourLines() const
bool RimContourMapProjection::showContourLines() const
{
return m_showContourLines();
}
@ -358,7 +358,7 @@ bool Rim2dGridProjection::showContourLines() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<double>& Rim2dGridProjection::aggregatedResults() const
const std::vector<double>& RimContourMapProjection::aggregatedResults() const
{
return m_aggregatedResults;
}
@ -366,7 +366,7 @@ const std::vector<double>& Rim2dGridProjection::aggregatedResults() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Rim2dGridProjection::isSummationResult() const
bool RimContourMapProjection::isSummationResult() const
{
return isColumnResult() || m_resultAggregation() == RESULTS_SUM;
}
@ -374,7 +374,7 @@ bool Rim2dGridProjection::isSummationResult() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Rim2dGridProjection::isColumnResult() const
bool RimContourMapProjection::isColumnResult() const
{
return m_resultAggregation() == RESULTS_OIL_COLUMN ||
m_resultAggregation() == RESULTS_GAS_COLUMN ||
@ -384,7 +384,7 @@ bool Rim2dGridProjection::isColumnResult() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double Rim2dGridProjection::value(uint i, uint j) const
double RimContourMapProjection::value(uint i, uint j) const
{
return m_aggregatedResults.at(gridIndex(i, j));
}
@ -392,7 +392,7 @@ double Rim2dGridProjection::value(uint i, uint j) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double Rim2dGridProjection::calculateValue(uint i, uint j) const
double RimContourMapProjection::calculateValue(uint i, uint j) const
{
const std::vector<std::pair<size_t, double>>& matchingCells = cellsAtPos2d(i, j);
if (!matchingCells.empty())
@ -515,7 +515,7 @@ double Rim2dGridProjection::calculateValue(uint i, uint j) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double Rim2dGridProjection::calculateVolumeSum(uint i, uint j) const
double RimContourMapProjection::calculateVolumeSum(uint i, uint j) const
{
const std::vector<std::pair<size_t, double>>& matchingCells = cellsAtPos2d(i, j);
if (!matchingCells.empty())
@ -534,7 +534,7 @@ double Rim2dGridProjection::calculateVolumeSum(uint i, uint j) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double Rim2dGridProjection::calculateSoilSum(uint i, uint j) const
double RimContourMapProjection::calculateSoilSum(uint i, uint j) const
{
const std::vector<std::pair<size_t, double>>& matchingCells = cellsAtPos2d(i, j);
if (!matchingCells.empty())
@ -555,7 +555,7 @@ double Rim2dGridProjection::calculateSoilSum(uint i, uint j) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Rim2dGridProjection::hasResultAt(uint i, uint j) const
bool RimContourMapProjection::hasResultAt(uint i, uint j) const
{
RimEclipseView* view = nullptr;
firstAncestorOrThisOfTypeAsserted(view);
@ -571,7 +571,7 @@ bool Rim2dGridProjection::hasResultAt(uint i, uint j) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec2ui Rim2dGridProjection::surfaceGridSize() const
cvf::Vec2ui RimContourMapProjection::surfaceGridSize() const
{
cvf::BoundingBox boundingBox = expandedBoundingBox();
cvf::Vec3d gridExtent = boundingBox.extent();
@ -585,7 +585,7 @@ cvf::Vec2ui Rim2dGridProjection::surfaceGridSize() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
uint Rim2dGridProjection::vertexCount() const
uint RimContourMapProjection::vertexCount() const
{
cvf::Vec2ui gridSize2d = surfaceGridSize();
return gridSize2d.x() * gridSize2d.y();
@ -594,7 +594,7 @@ uint Rim2dGridProjection::vertexCount() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
uint Rim2dGridProjection::validVertexCount() const
uint RimContourMapProjection::validVertexCount() const
{
uint validCount = 0u;
for (uint i = 0; i < vertexCount(); ++i)
@ -611,7 +611,7 @@ uint Rim2dGridProjection::validVertexCount() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimRegularLegendConfig* Rim2dGridProjection::legendConfig() const
RimRegularLegendConfig* RimContourMapProjection::legendConfig() const
{
RimEclipseView* view = nullptr;
this->firstAncestorOrThisOfTypeAsserted(view);
@ -621,7 +621,7 @@ RimRegularLegendConfig* Rim2dGridProjection::legendConfig() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dGridProjection::calculateTotalCellVisibility()
void RimContourMapProjection::calculateTotalCellVisibility()
{
RimEclipseView* view = nullptr;
firstAncestorOrThisOfTypeAsserted(view);
@ -632,7 +632,7 @@ void Rim2dGridProjection::calculateTotalCellVisibility()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec2d Rim2dGridProjection::globalPos2d(uint i, uint j) const
cvf::Vec2d RimContourMapProjection::globalPos2d(uint i, uint j) const
{
cvf::BoundingBox boundingBox = expandedBoundingBox();
cvf::Vec3d gridExtent = boundingBox.extent();
@ -646,7 +646,7 @@ cvf::Vec2d Rim2dGridProjection::globalPos2d(uint i, uint j) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<std::pair<size_t, double>>& Rim2dGridProjection::cellsAtPos2d(uint i, uint j) const
const std::vector<std::pair<size_t, double>>& RimContourMapProjection::cellsAtPos2d(uint i, uint j) const
{
return m_projected3dGridIndices[gridIndex(i, j)];
}
@ -654,7 +654,7 @@ const std::vector<std::pair<size_t, double>>& Rim2dGridProjection::cellsAtPos2d(
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::pair<size_t, double>> Rim2dGridProjection::visibleCellsAndWeightMatching2dPoint(const cvf::Vec2d& globalPos2d) const
std::vector<std::pair<size_t, double>> RimContourMapProjection::visibleCellsAndWeightMatching2dPoint(const cvf::Vec2d& globalPos2d) const
{
cvf::BoundingBox gridBoundingBox = expandedBoundingBox();
cvf::Vec3d top2dElementCentroid(globalPos2d, gridBoundingBox.max().z());
@ -741,7 +741,7 @@ std::vector<std::pair<size_t, double>> Rim2dGridProjection::visibleCellsAndWeigh
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double Rim2dGridProjection::findColumnResult(ResultAggregation resultAggregation, size_t cellGlobalIdx) const
double RimContourMapProjection::findColumnResult(ResultAggregation resultAggregation, size_t cellGlobalIdx) const
{
const RigCaseCellResultsData* resultData = eclipseCase()->results(RiaDefines::MATRIX_MODEL);
size_t poroResultIndex = resultData->findScalarResultIndex(RiaDefines::STATIC_NATIVE, "PORO");
@ -796,7 +796,7 @@ double Rim2dGridProjection::findColumnResult(ResultAggregation resultAggregation
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double Rim2dGridProjection::findSoilResult(size_t cellGlobalIdx) const
double RimContourMapProjection::findSoilResult(size_t cellGlobalIdx) const
{
const RigCaseCellResultsData* resultData = eclipseCase()->results(RiaDefines::MATRIX_MODEL);
const RigActiveCellInfo* activeCellInfo = eclipseCase()->eclipseCaseData()->activeCellInfo(RiaDefines::MATRIX_MODEL);
@ -818,7 +818,7 @@ double Rim2dGridProjection::findSoilResult(size_t cellGlobalIdx) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RimEclipseResultCase* Rim2dGridProjection::eclipseCase() const
const RimEclipseResultCase* RimContourMapProjection::eclipseCase() const
{
const RimEclipseResultCase* eclipseCase = nullptr;
firstAncestorOrThisOfTypeAsserted(eclipseCase);
@ -828,7 +828,7 @@ const RimEclipseResultCase* Rim2dGridProjection::eclipseCase() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
size_t Rim2dGridProjection::gridIndex(uint i, uint j) const
size_t RimContourMapProjection::gridIndex(uint i, uint j) const
{
cvf::Vec2ui gridSize2d = surfaceGridSize();
@ -841,7 +841,7 @@ size_t Rim2dGridProjection::gridIndex(uint i, uint j) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec2ui Rim2dGridProjection::ijFromGridIndex(size_t index) const
cvf::Vec2ui RimContourMapProjection::ijFromGridIndex(size_t index) const
{
CVF_TIGHT_ASSERT(index < vertexCount());
@ -856,7 +856,7 @@ cvf::Vec2ui Rim2dGridProjection::ijFromGridIndex(size_t index) const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dGridProjection::updateLegend()
void RimContourMapProjection::updateLegend()
{
RimEclipseView* view = nullptr;
firstAncestorOrThisOfTypeAsserted(view);
@ -889,7 +889,7 @@ void Rim2dGridProjection::updateLegend()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dGridProjection::ResultAggregation Rim2dGridProjection::resultAggregation() const
RimContourMapProjection::ResultAggregation RimContourMapProjection::resultAggregation() const
{
return m_resultAggregation();
}
@ -897,7 +897,7 @@ Rim2dGridProjection::ResultAggregation Rim2dGridProjection::resultAggregation()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString Rim2dGridProjection::resultAggregationText() const
QString RimContourMapProjection::resultAggregationText() const
{
return m_resultAggregation().uiText();
}
@ -905,7 +905,7 @@ QString Rim2dGridProjection::resultAggregationText() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> Rim2dGridProjection::xPositions() const
std::vector<double> RimContourMapProjection::xPositions() const
{
cvf::BoundingBox boundingBox = expandedBoundingBox();
cvf::Vec3d gridExtent = boundingBox.extent();
@ -926,7 +926,7 @@ std::vector<double> Rim2dGridProjection::xPositions() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<double> Rim2dGridProjection::yPositions() const
std::vector<double> RimContourMapProjection::yPositions() const
{
cvf::BoundingBox boundingBox = expandedBoundingBox();
cvf::Vec3d gridExtent = boundingBox.extent();
@ -946,7 +946,7 @@ std::vector<double> Rim2dGridProjection::yPositions() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RigMainGrid* Rim2dGridProjection::mainGrid() const
RigMainGrid* RimContourMapProjection::mainGrid() const
{
RimEclipseResultCase* eclipseCase = nullptr;
firstAncestorOrThisOfTypeAsserted(eclipseCase);
@ -956,7 +956,7 @@ RigMainGrid* Rim2dGridProjection::mainGrid() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dGridProjection::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
void RimContourMapProjection::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
if (changedField == &m_resultAggregation)
{
@ -975,7 +975,7 @@ void Rim2dGridProjection::fieldChangedByUi(const caf::PdmFieldHandle* changedFie
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dGridProjection::defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute)
void RimContourMapProjection::defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute)
{
if (&m_relativeSampleSpacing == field)
{
@ -991,7 +991,7 @@ void Rim2dGridProjection::defineEditorAttribute(const caf::PdmFieldHandle* field
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dGridProjection::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
void RimContourMapProjection::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
{
uiTreeOrdering.skipRemainingChildren(true);
}
@ -999,7 +999,7 @@ void Rim2dGridProjection::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrd
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dGridProjection::initAfterRead()
void RimContourMapProjection::initAfterRead()
{
legendConfig()->disableAllTimeStepsRange(isSummationResult());
}

7
ApplicationCode/ProjectDataModel/Rim2dGridProjection.h → ApplicationCode/ProjectDataModel/RimContourMapProjection.h
View File

@ -39,7 +39,7 @@ class RimEclipseResultCase;
///
///
//==================================================================================================
class Rim2dGridProjection : public RimCheckableNamedObject
class RimContourMapProjection : public RimCheckableNamedObject
{
CAF_PDM_HEADER_INIT;
public:
@ -59,8 +59,8 @@ public:
typedef caf::AppEnum<ResultAggregationEnum> ResultAggregation;
typedef std::vector<cvf::ref<cvf::Vec3fArray>> ContourPolygons;
Rim2dGridProjection();
~Rim2dGridProjection() override;
RimContourMapProjection();
~RimContourMapProjection() override;
void generateVertices(cvf::Vec3fArray* vertices, const caf::DisplayCoordTransform* displayCoordTransform);
@ -109,7 +109,6 @@ protected:
std::vector<std::pair<size_t, double>> visibleCellsAndWeightMatching2dPoint(const cvf::Vec2d& globalPos2d) const;
double findColumnResult(ResultAggregation resultAggregation, size_t cellGlobalIdx) const;
double findSoilResult(size_t cellGlobalIdx) const;
std::array<cvf::Vec3d, 8> createHexOverlapEstimation(const cvf::BoundingBox& boundingBox2dExtrusion, const std::array<cvf::Vec3d, 8>& hexCorners, cvf::BoundingBox* overlapBoundingBox) const;
const RimEclipseResultCase* eclipseCase() const;
RigMainGrid* mainGrid() const;

72
ApplicationCode/ProjectDataModel/Rim2dEclipseView.cpp → ApplicationCode/ProjectDataModel/RimContourMapView.cpp
View File

@ -16,12 +16,12 @@
//
/////////////////////////////////////////////////////////////////////////////////
#include "Rim2dEclipseView.h"
#include "RimContourMapView.h"
#include "Riv2dGridProjectionPartMgr.h"
#include "RivContourMapProjectionPartMgr.h"
#include "RiuViewer.h"
#include "Rim2dGridProjection.h"
#include "RimContourMapProjection.h"
#include "Rim3dOverlayInfoConfig.h"
#include "RimCellRangeFilterCollection.h"
#include "RimEclipseCellColors.h"
@ -37,19 +37,19 @@
#include "cvfPart.h"
#include "cvfScene.h"
CAF_PDM_SOURCE_INIT(Rim2dEclipseView, "Rim2dEclipseView");
CAF_PDM_SOURCE_INIT(RimContourMapView, "RimContourMapView");
const cvf::Mat4d defaultViewMatrix(1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 1000,
0, 0, 0, 1);
Rim2dEclipseView::Rim2dEclipseView()
RimContourMapView::RimContourMapView()
{
CAF_PDM_InitObject("2d Contour Map", ":/2DMap16x16.png", "", "");
CAF_PDM_InitObject("Contour Map View", ":/2DMap16x16.png", "", "");
CAF_PDM_InitFieldNoDefault(&m_2dGridProjection, "Grid2dProjection", "2d Grid Projection", "", "", "");
m_2dGridProjection = new Rim2dGridProjection();
CAF_PDM_InitFieldNoDefault(&m_contourMapProjection, "ContourMapProjection", "Contour Map Projection", "", "", "");
m_contourMapProjection = new RimContourMapProjection();
CAF_PDM_InitField(&m_showAxisLines, "ShowAxisLines", true, "Show Axis Lines", "", "", "");
@ -58,7 +58,7 @@ Rim2dEclipseView::Rim2dEclipseView()
wellCollection()->isActive = false;
faultCollection()->showFaultCollection = false;
m_grid2dProjectionPartMgr = new Riv2dGridProjectionPartMgr(grid2dProjection(), this);
m_contourMapProjectionPartMgr = new RivContourMapProjectionPartMgr(contourMapProjection(), this);
((RiuViewerToViewInterface*)this)->setCameraPosition(defaultViewMatrix);
}
@ -66,15 +66,15 @@ Rim2dEclipseView::Rim2dEclipseView()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dGridProjection* Rim2dEclipseView::grid2dProjection() const
RimContourMapProjection* RimContourMapView::contourMapProjection() const
{
return m_2dGridProjection().p();
return m_contourMapProjection().p();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dEclipseView::initAfterRead()
void RimContourMapView::initAfterRead()
{
m_gridCollection->setActive(false); // This is also not added to the tree view, so cannot be enabled.
disablePerspectiveProjectionField();
@ -87,7 +87,7 @@ void Rim2dEclipseView::initAfterRead()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dEclipseView::createDisplayModel()
void RimContourMapView::createDisplayModel()
{
RimEclipseView::createDisplayModel();
@ -100,7 +100,7 @@ void Rim2dEclipseView::createDisplayModel()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dEclipseView::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
void RimContourMapView::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup* viewGroup = uiOrdering.addNewGroup("Viewer");
viewGroup->add(this->userDescriptionField());
@ -112,12 +112,12 @@ void Rim2dEclipseView::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dEclipseView::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
void RimContourMapView::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName /*= ""*/)
{
uiTreeOrdering.add(m_overlayInfoConfig());
uiTreeOrdering.add(m_2dGridProjection);
uiTreeOrdering.add(m_contourMapProjection);
uiTreeOrdering.add(cellResult());
cellResult()->uiCapability()->setUiReadOnly(m_2dGridProjection->isColumnResult());
cellResult()->uiCapability()->setUiReadOnly(m_contourMapProjection->isColumnResult());
uiTreeOrdering.add(wellCollection());
uiTreeOrdering.add(faultCollection());
uiTreeOrdering.add(m_rangeFilterCollection());
@ -129,32 +129,32 @@ void Rim2dEclipseView::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrderi
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dEclipseView::updateCurrentTimeStep()
void RimContourMapView::updateCurrentTimeStep()
{
if (m_2dGridProjection->isChecked())
if (m_contourMapProjection->isChecked())
{
m_2dGridProjection->generateResults();
m_contourMapProjection->generateResults();
}
static_cast<RimEclipsePropertyFilterCollection*>(nonOverridePropertyFilterCollection())->updateFromCurrentTimeStep();
updateLegends(); // To make sure the scalar mappers are set up correctly
if (m_viewer && m_2dGridProjection->isChecked())
if (m_viewer && m_contourMapProjection->isChecked())
{
cvf::Scene* frameScene = m_viewer->frame(m_currentTimeStep);
cvf::String name = "Grid2dProjection";
cvf::String name = "ContourMapProjection";
this->removeModelByName(frameScene, name);
cvf::ref<cvf::ModelBasicList> grid2dProjectionModelBasicList = new cvf::ModelBasicList;
grid2dProjectionModelBasicList->setName(name);
cvf::ref<cvf::ModelBasicList> contourMapProjectionModelBasicList = new cvf::ModelBasicList;
contourMapProjectionModelBasicList->setName(name);
cvf::ref<caf::DisplayCoordTransform> transForm = this->displayCoordTransform();
m_grid2dProjectionPartMgr->appendProjectionToModel(grid2dProjectionModelBasicList.p(), transForm.p());
grid2dProjectionModelBasicList->updateBoundingBoxesRecursive();
frameScene->addModel(grid2dProjectionModelBasicList.p());
m_contourMapProjectionPartMgr->appendProjectionToModel(contourMapProjectionModelBasicList.p(), transForm.p());
contourMapProjectionModelBasicList->updateBoundingBoxesRecursive();
frameScene->addModel(contourMapProjectionModelBasicList.p());
if (m_overlayInfoConfig->isActive())
{
@ -166,18 +166,18 @@ void Rim2dEclipseView::updateCurrentTimeStep()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dEclipseView::updateLegends()
void RimContourMapView::updateLegends()
{
if (m_viewer)
{
m_viewer->removeAllColorLegends();
if (m_2dGridProjection && m_2dGridProjection->isChecked())
if (m_contourMapProjection && m_contourMapProjection->isChecked())
{
RimRegularLegendConfig* projectionLegend = m_2dGridProjection->legendConfig();
RimRegularLegendConfig* projectionLegend = m_contourMapProjection->legendConfig();
if (projectionLegend)
{
m_2dGridProjection->updateLegend();
m_contourMapProjection->updateLegend();
if (projectionLegend->showLegend())
{
m_viewer->addColorLegendToBottomLeftCorner(projectionLegend->titledOverlayFrame());
@ -190,7 +190,7 @@ void Rim2dEclipseView::updateLegends()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dEclipseView::updateViewWidgetAfterCreation()
void RimContourMapView::updateViewWidgetAfterCreation()
{
if (m_viewer)
{
@ -205,16 +205,16 @@ void Rim2dEclipseView::updateViewWidgetAfterCreation()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dEclipseView::updateViewFollowingRangeFilterUpdates()
void RimContourMapView::updateViewFollowingRangeFilterUpdates()
{
m_2dGridProjection->setCheckState(true);
m_contourMapProjection->setCheckState(true);
scheduleCreateDisplayModelAndRedraw();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dEclipseView::onLoadDataAndUpdate()
void RimContourMapView::onLoadDataAndUpdate()
{
RimEclipseView::onLoadDataAndUpdate();
if (m_viewer)
@ -226,7 +226,7 @@ void Rim2dEclipseView::onLoadDataAndUpdate()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dEclipseView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
void RimContourMapView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
RimEclipseView::fieldChangedByUi(changedField, oldValue, newValue);

14
ApplicationCode/ProjectDataModel/Rim2dEclipseView.h → ApplicationCode/ProjectDataModel/RimContourMapView.h
View File

@ -20,14 +20,14 @@
#include "RimEclipseView.h"
class Riv2dGridProjectionPartMgr;
class RivContourMapProjectionPartMgr;
class Rim2dEclipseView : public RimEclipseView
class RimContourMapView : public RimEclipseView
{
CAF_PDM_HEADER_INIT;
public:
Rim2dEclipseView();
Rim2dGridProjection* grid2dProjection() const;
RimContourMapView();
RimContourMapProjection* contourMapProjection() const;
protected:
void initAfterRead() override;
@ -42,9 +42,9 @@ protected:
void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
private:
cvf::ref<Riv2dGridProjectionPartMgr> m_grid2dProjectionPartMgr;
caf::PdmChildField<Rim2dGridProjection*> m_2dGridProjection;
caf::PdmField<bool> m_showAxisLines;
cvf::ref<RivContourMapProjectionPartMgr> m_contourMapProjectionPartMgr;
caf::PdmChildField<RimContourMapProjection*> m_contourMapProjection;
caf::PdmField<bool> m_showAxisLines;
};

24
ApplicationCode/ProjectDataModel/Rim2dEclipseViewCollection.cpp → ApplicationCode/ProjectDataModel/RimContourMapViewCollection.cpp
View File

@ -1,25 +1,25 @@
#include "Rim2dEclipseViewCollection.h"
#include "RimContourMapViewCollection.h"
#include "Rim2dEclipseView.h"
#include "RimContourMapView.h"
#include "RimCase.h"
CAF_PDM_SOURCE_INIT(Rim2dEclipseViewCollection, "Eclipse2dViewCollection");
CAF_PDM_SOURCE_INIT(RimContourMapViewCollection, "Eclipse2dViewCollection");
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dEclipseViewCollection::Rim2dEclipseViewCollection()
RimContourMapViewCollection::RimContourMapViewCollection()
{
CAF_PDM_InitObject("2D Contour Maps", ":/2DMaps16x16.png", "", "");
CAF_PDM_InitObject("Contour Maps", ":/2DMaps16x16.png", "", "");
CAF_PDM_InitFieldNoDefault(&m_2dEclipseViews, "EclipseViews", "Contour Maps", ":/CrossSection16x16.png", "", "");
m_2dEclipseViews.uiCapability()->setUiTreeHidden(true);
CAF_PDM_InitFieldNoDefault(&m_contourMapViews, "EclipseViews", "Contour Maps", ":/CrossSection16x16.png", "", "");
m_contourMapViews.uiCapability()->setUiTreeHidden(true);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dEclipseViewCollection::~Rim2dEclipseViewCollection()
RimContourMapViewCollection::~RimContourMapViewCollection()
{
}
@ -27,16 +27,16 @@ Rim2dEclipseViewCollection::~Rim2dEclipseViewCollection()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<Rim2dEclipseView*> Rim2dEclipseViewCollection::views()
std::vector<RimContourMapView*> RimContourMapViewCollection::views()
{
return m_2dEclipseViews.childObjects();
return m_contourMapViews.childObjects();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dEclipseViewCollection::push_back(Rim2dEclipseView* contourMap)
void RimContourMapViewCollection::push_back(RimContourMapView* contourMap)
{
m_2dEclipseViews.push_back(contourMap);
m_contourMapViews.push_back(contourMap);
}

14
ApplicationCode/ProjectDataModel/Rim2dEclipseViewCollection.h → ApplicationCode/ProjectDataModel/RimContourMapViewCollection.h
View File

@ -22,19 +22,19 @@
#include "cafPdmField.h"
#include "cafPdmChildArrayField.h"
class Rim2dEclipseView;
class RimContourMapView;
class Rim2dEclipseViewCollection : public caf::PdmObject
class RimContourMapViewCollection : public caf::PdmObject
{
CAF_PDM_HEADER_INIT;
public:
Rim2dEclipseViewCollection();
~Rim2dEclipseViewCollection() override;
RimContourMapViewCollection();
~RimContourMapViewCollection() override;
std::vector<Rim2dEclipseView*> views();
void push_back(Rim2dEclipseView* contourMap);
std::vector<RimContourMapView*> views();
void push_back(RimContourMapView* contourMap);
private:
caf::PdmChildArrayField<Rim2dEclipseView*> m_2dEclipseViews;
caf::PdmChildArrayField<RimContourMapView*> m_contourMapViews;
};

24
ApplicationCode/ProjectDataModel/RimEclipseCase.cpp
View File

@ -35,8 +35,8 @@
#include "RigSimWellData.h"
#include "RigVirtualPerforationTransmissibilities.h"
#include "Rim2dEclipseView.h"
#include "Rim2dEclipseViewCollection.h"
#include "RimContourMapView.h"
#include "RimContourMapViewCollection.h"
#include "Rim2dIntersectionView.h"
#include "Rim2dIntersectionViewCollection.h"
#include "RimCaseCollection.h"
@ -101,9 +101,9 @@ RimEclipseCase::RimEclipseCase()
CAF_PDM_InitFieldNoDefault(&m_filesContainingFaultsSemColSeparated, "CachedFileNamesContainingFaults", "", "", "", "");
m_filesContainingFaultsSemColSeparated.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_2dContourMapCollection, "ContourMaps", "2d Contour Maps", "", "", "");
m_2dContourMapCollection = new Rim2dEclipseViewCollection;
m_2dContourMapCollection.uiCapability()->setUiTreeHidden(true);
CAF_PDM_InitFieldNoDefault(&m_contourMapCollection, "ContourMaps", "2d Contour Maps", "", "", "");
m_contourMapCollection = new RimContourMapViewCollection;
m_contourMapCollection.uiCapability()->setUiTreeHidden(true);
// Obsolete fields
CAF_PDM_InitFieldNoDefault(&m_filesContainingFaults_OBSOLETE, "FilesContainingFaults", "", "", "", "");
@ -239,7 +239,7 @@ void RimEclipseCase::initAfterRead()
riv->setEclipseCase(this);
}
for (Rim2dEclipseView* contourMap : m_2dContourMapCollection->views())
for (RimContourMapView* contourMap : m_contourMapCollection->views())
{
contourMap->setEclipseCase(this);
}
@ -520,9 +520,9 @@ void RimEclipseCase::defineUiTreeOrdering(caf::PdmUiTreeOrdering& uiTreeOrdering
{
uiTreeOrdering.add(&m_2dIntersectionViewCollection);
}
if (!m_2dContourMapCollection->views().empty())
if (!m_contourMapCollection->views().empty())
{
uiTreeOrdering.add(&m_2dContourMapCollection);
uiTreeOrdering.add(&m_contourMapCollection);
}
uiTreeOrdering.skipRemainingChildren(true);
}
@ -575,9 +575,9 @@ RimCaseCollection* RimEclipseCase::parentCaseCollection()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dEclipseViewCollection* RimEclipseCase::contourMapCollection()
RimContourMapViewCollection* RimEclipseCase::contourMapCollection()
{
return m_2dContourMapCollection;
return m_contourMapCollection;
}
//--------------------------------------------------------------------------------------------------
@ -869,7 +869,7 @@ std::vector<Rim3dView*> RimEclipseCase::allSpecialViews() const
views.push_back(view);
}
for (Rim2dEclipseView* view : m_2dContourMapCollection->views())
for (RimContourMapView* view : m_contourMapCollection->views())
{
views.push_back(view);
}
@ -939,7 +939,7 @@ void RimEclipseCase::reloadDataAndUpdate()
reservoirView->updateAnnotationItems();
}
for (Rim2dEclipseView* contourMap : m_2dContourMapCollection->views())
for (RimContourMapView* contourMap : m_contourMapCollection->views())
{
CVF_ASSERT(contourMap);
contourMap->loadDataAndUpdate();

8
ApplicationCode/ProjectDataModel/RimEclipseCase.h
View File

@ -45,8 +45,8 @@ class RigMainGrid;
class RimCaseCollection;
class RimIdenticalGridCaseGroup;
class RimReservoirCellResultsStorage;
class Rim2dEclipseView;
class Rim2dEclipseViewCollection;
class RimContourMapView;
class RimContourMapViewCollection;
class RimEclipseView;
class RigVirtualPerforationTransmissibilities;
@ -95,7 +95,7 @@ public:
RimCaseCollection* parentCaseCollection();
Rim2dEclipseViewCollection* contourMapCollection();
RimContourMapViewCollection* contourMapCollection();
QStringList timeStepStrings() const override;
QString timeStepName(int frameIdx) const override;
@ -140,7 +140,7 @@ private:
caf::PdmField<QString> m_filesContainingFaultsSemColSeparated;
caf::PdmField<bool> m_releaseResultMemory;
caf::PdmChildField<Rim2dEclipseViewCollection*> m_2dContourMapCollection;
caf::PdmChildField<RimContourMapViewCollection*> m_contourMapCollection;
cvf::ref<RigEclipseCaseData> m_rigEclipseCase;
QString m_timeStepFormatString;

2
ApplicationCode/ProjectDataModel/RimGridView.h
View File

@ -23,7 +23,7 @@
#include "cvfBase.h"
#include "cvfArray.h"
class Rim2dGridProjection;
class RimContourMapProjection;
class Rim3dOverlayInfoConfig;
class RimIntersectionCollection;
class RimPropertyFilterCollection;

4
ApplicationCode/ProjectDataModel/RimNameConfig.h
View File

@ -53,10 +53,10 @@ public:
virtual caf::PdmUiGroup* createUiGroup(QString uiConfigName, caf::PdmUiOrdering& uiOrdering);
protected:
void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
QString autoName() const;
virtual void updateAllSettings();
void initAfterRead() override;
void initAfterRead() override;
protected:
caf::PdmField<bool> m_isUsingAutoName_OBSOLETE;

4
ApplicationCode/ProjectDataModel/RimSimWellInViewCollection.cpp
View File

@ -28,7 +28,7 @@
#include "RigEclipseCaseData.h"
#include "RigSimWellData.h"
#include "Rim2dEclipseView.h"
#include "RimContourMapView.h"
#include "RimEclipseCase.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseView.h"
@ -519,7 +519,7 @@ void RimSimWellInViewCollection::defineUiOrdering(QString uiConfigName, caf::Pdm
{
updateStateForVisibilityCheckboxes();
bool isContourMap = dynamic_cast<const Rim2dEclipseView*>(m_reservoirView) != nullptr;
bool isContourMap = dynamic_cast<const RimContourMapView*>(m_reservoirView) != nullptr;
caf::PdmUiGroup* appearanceGroup = uiOrdering.addNewGroup("Visibility");
if (!isContourMap)

18
ApplicationCode/ProjectDataModel/RimViewController.cpp
View File

@ -28,7 +28,7 @@
#include "RigGeoMechCaseData.h"
#include "RigMainGrid.h"
#include "Rim2dEclipseView.h"
#include "RimContourMapView.h"
#include "Rim3dView.h"
#include "RimCase.h"
#include "RimCellRangeFilter.h"
@ -671,8 +671,8 @@ RimGridView* RimViewController::masterView() const
//--------------------------------------------------------------------------------------------------
bool RimViewController::isCameraControlPossible() const
{
Rim2dEclipseView* contourMapMasterView = dynamic_cast<Rim2dEclipseView*>(masterView());
Rim2dEclipseView* contourMapManagedView = dynamic_cast<Rim2dEclipseView*>(managedEclipseView());
RimContourMapView* contourMapMasterView = dynamic_cast<RimContourMapView*>(masterView());
RimContourMapView* contourMapManagedView = dynamic_cast<RimContourMapView*>(managedEclipseView());
return !(contourMapMasterView || contourMapManagedView);
}
@ -910,8 +910,8 @@ bool RimViewController::isRangeFilterMappingApplicable() const
//--------------------------------------------------------------------------------------------------
bool RimViewController::isCellResultControlAdvisable() const
{
bool contourMapMasterView = dynamic_cast<Rim2dEclipseView*>(masterView()) != nullptr;
bool contourMapManagedView = dynamic_cast<Rim2dEclipseView*>(managedEclipseView()) != nullptr;
bool contourMapMasterView = dynamic_cast<RimContourMapView*>(masterView()) != nullptr;
bool contourMapManagedView = dynamic_cast<RimContourMapView*>(managedEclipseView()) != nullptr;
return !isMasterAndDepViewDifferentType() && contourMapMasterView != contourMapManagedView;
}
@ -920,8 +920,8 @@ bool RimViewController::isCellResultControlAdvisable() const
//--------------------------------------------------------------------------------------------------
bool RimViewController::isRangeFilterControlAdvisable() const
{
bool contourMapMasterView = dynamic_cast<Rim2dEclipseView*>(masterView()) != nullptr;
bool contourMapManagedView = dynamic_cast<Rim2dEclipseView*>(managedEclipseView()) != nullptr;
bool contourMapMasterView = dynamic_cast<RimContourMapView*>(masterView()) != nullptr;
bool contourMapManagedView = dynamic_cast<RimContourMapView*>(managedEclipseView()) != nullptr;
return isRangeFilterControlPossible() && contourMapMasterView != contourMapManagedView;
}
@ -930,8 +930,8 @@ bool RimViewController::isRangeFilterControlAdvisable() const
//--------------------------------------------------------------------------------------------------
bool RimViewController::isPropertyFilterControlAdvisable() const
{
bool contourMapMasterView = dynamic_cast<Rim2dEclipseView*>(masterView()) != nullptr;
bool contourMapManagedView = dynamic_cast<Rim2dEclipseView*>(managedEclipseView()) != nullptr;
bool contourMapMasterView = dynamic_cast<RimContourMapView*>(masterView()) != nullptr;
bool contourMapManagedView = dynamic_cast<RimContourMapView*>(managedEclipseView()) != nullptr;
return isPropertyFilterControlPossible() && contourMapMasterView != contourMapManagedView;
}

2
ApplicationCode/ProjectDataModel/RimWellLogExtractionCurveNameConfig.h
View File

@ -38,7 +38,7 @@ public:
bool addTimeStep() const;
bool addDate() const;
void enableAllAutoNameTags(bool enable) override;
void enableAllAutoNameTags(bool enable) override;
private:
caf::PdmField<bool> m_addCaseName;

8
ApplicationCode/UserInterface/RiuMainWindow.cpp
View File

@ -26,7 +26,7 @@
#include "RiaRegressionTest.h"
#include "RiaRegressionTestRunner.h"
#include "Rim2dEclipseView.h"
#include "RimContourMapView.h"
#include "Rim2dIntersectionView.h"
#include "Rim3dView.h"
#include "RimCellEdgeColors.h"
@ -852,7 +852,7 @@ void RiuMainWindow::slotRefreshEditActions()
void RiuMainWindow::slotRefreshViewActions()
{
RimGridView* gridView = RiaApplication::instance()->activeGridView();
Rim2dEclipseView* view2d = dynamic_cast<Rim2dEclipseView*>(gridView);
RimContourMapView* view2d = dynamic_cast<RimContourMapView*>(gridView);
bool enabled = gridView != nullptr && view2d == nullptr;
m_viewFromNorth->setEnabled(enabled);
m_viewFromSouth->setEnabled(enabled);
@ -1578,7 +1578,7 @@ void RiuMainWindow::slotToggleFaultLabelsAction(bool showLabels)
void RiuMainWindow::refreshDrawStyleActions()
{
RimGridView* gridView = RiaApplication::instance()->activeGridView();
Rim2dEclipseView* view2d = dynamic_cast<Rim2dEclipseView*>(gridView);
RimContourMapView* view2d = dynamic_cast<RimContourMapView*>(gridView);
bool is2dMap = view2d != nullptr;
bool is3dGridView = gridView != nullptr && !is2dMap;
@ -1808,7 +1808,7 @@ void RiuMainWindow::slotScaleChanged(int scaleValue)
void RiuMainWindow::updateScaleValue()
{
Rim3dView* view = RiaApplication::instance()->activeReservoirView();
bool isRegularReservoirView = view && dynamic_cast<Rim2dEclipseView*>(view) == nullptr;
bool isRegularReservoirView = view && dynamic_cast<RimContourMapView*>(view) == nullptr;
if (isRegularReservoirView)
{
m_scaleFactor->setEnabled(true);