OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-20 11:48:35 -06:00
Code Issues Packages Projects Releases Wiki Activity

RimView etc: More aligning GeoMech/Eclipse

Browse Source 
Now Animation drawstyle works fairly well.
This commit is contained in:
Jacob Støren 2015-05-08 14:13:26 +02:00
parent 86b058cdbe
commit d6643d9d35
15 changed files with 408 additions and 369 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ApplicationCode/Application/RiaApplication.cpp
View File

@ -796,7 +796,7 @@ void RiaApplication::createInputMockModel()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RimReservoirView* RiaApplication::activeReservoirView() const
const RimView* RiaApplication::activeReservoirView() const
{
return m_activeReservoirView;
}
@ -804,7 +804,7 @@ const RimReservoirView* RiaApplication::activeReservoirView() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimReservoirView* RiaApplication::activeReservoirView()
RimView* RiaApplication::activeReservoirView()
{
return m_activeReservoirView;
}
@ -812,7 +812,7 @@ RimReservoirView* RiaApplication::activeReservoirView()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RiaApplication::setActiveReservoirView(RimReservoirView* rv)
void RiaApplication::setActiveReservoirView(RimView* rv)
{
m_activeReservoirView = rv;
}

8
ApplicationCode/Application/RiaApplication.h
View File

@ -73,9 +73,9 @@ public:
void executeRegressionTests(const QString& regressionTestPath);
void setActiveReservoirView(RimReservoirView*);
RimReservoirView* activeReservoirView();
const RimReservoirView* activeReservoirView() const;
void setActiveReservoirView(RimView*);
RimView* activeReservoirView();
const RimView* activeReservoirView() const;
void scheduleDisplayModelUpdateAndRedraw(RimView* resViewToUpdate);
@ -172,7 +172,7 @@ private slots:
void slotUpdateScheduledDisplayModels();
private:
caf::PdmPointer<RimReservoirView> m_activeReservoirView;
caf::PdmPointer<RimView> m_activeReservoirView;
caf::PdmPointer<RimProject> m_project;
std::vector<caf::PdmPointer<RimView> > m_resViewsToUpdate;

98
ApplicationCode/CMakeLists.txt
View File

@ -165,55 +165,55 @@ endif()
# creating PCH's for MSVC and GCC on Linux
#############################################################################
set( RAW_SOURCES ${CPP_SOURCES} )
list( REMOVE_ITEM RAW_SOURCES
RiaStdInclude.cpp
${CODE_SOURCE_FILES}
ModelVisualization/RivCellEdgeEffectGenerator.cpp
ModelVisualization/RivPipeGeometryGenerator.cpp
ModelVisualization/RivWellPipesPartMgr.cpp
ModelVisualization/RivWellHeadPartMgr.cpp
Application/RiaImageFileCompare.cpp
Application/RiaImageCompareReporter.cpp
Application/RiaRegressionTest.cpp
SocketInterface/RiaSocketDataTransfer.cpp
FileInterface/RifEclipseInputFileTools.cpp
FileInterface/RifEclipseOutputFileTools.cpp
FileInterface/RifEclipseRestartFilesetAccess.cpp
FileInterface/RifEclipseRestartDataAccess.cpp
FileInterface/RifEclipseUnifiedRestartFileAccess.cpp
FileInterface/RifReaderEclipseInput.cpp
FileInterface/RifReaderEclipseOutput.cpp
UserInterface/RiuSimpleHistogramWidget.cpp
UserInterface/RiuMultiCaseImportDialog.cpp
UserInterface/RiuResultTextBuilder.cpp
)
include( CustomPCH.cmake )
set( ALL_INCLUDES
${LibCore_SOURCE_DIR}
${LibGeometry_SOURCE_DIR}
${LibGuiQt_SOURCE_DIR}
${LibRender_SOURCE_DIR}
${LibViewing_SOURCE_DIR}
${QT_INCLUDES}
)
set( PCH_NAME RiaStdInclude )
set( GCC_PCH_TARGET gccPCH )
set( PCH_COMPILER_DEFINE EMPTY )
IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
set( PCH_COMPILER_DEFINE CVF_LINUX)
ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
precompiled_header( RAW_SOURCES ALL_INCLUDES ${GCC_PCH_TARGET} ${PCH_NAME} ${PCH_COMPILER_DEFINE} )
#set( RAW_SOURCES ${CPP_SOURCES} )
#
#list( REMOVE_ITEM RAW_SOURCES
# RiaStdInclude.cpp
#
# ${CODE_SOURCE_FILES}
#
# ModelVisualization/RivCellEdgeEffectGenerator.cpp
# ModelVisualization/RivPipeGeometryGenerator.cpp
# ModelVisualization/RivWellPipesPartMgr.cpp
# ModelVisualization/RivWellHeadPartMgr.cpp
#
# Application/RiaImageFileCompare.cpp
# Application/RiaImageCompareReporter.cpp
# Application/RiaRegressionTest.cpp
#
# SocketInterface/RiaSocketDataTransfer.cpp
#
# FileInterface/RifEclipseInputFileTools.cpp
# FileInterface/RifEclipseOutputFileTools.cpp
# FileInterface/RifEclipseRestartFilesetAccess.cpp
# FileInterface/RifEclipseRestartDataAccess.cpp
# FileInterface/RifEclipseUnifiedRestartFileAccess.cpp
# FileInterface/RifReaderEclipseInput.cpp
# FileInterface/RifReaderEclipseOutput.cpp
#
# UserInterface/RiuSimpleHistogramWidget.cpp
# UserInterface/RiuMultiCaseImportDialog.cpp
# UserInterface/RiuResultTextBuilder.cpp
#)
#
#include( CustomPCH.cmake )
#set( ALL_INCLUDES
# ${LibCore_SOURCE_DIR}
# ${LibGeometry_SOURCE_DIR}
# ${LibGuiQt_SOURCE_DIR}
# ${LibRender_SOURCE_DIR}
# ${LibViewing_SOURCE_DIR}
# ${QT_INCLUDES}
#)
#
#set( PCH_NAME RiaStdInclude )
#set( GCC_PCH_TARGET gccPCH )
#set( PCH_COMPILER_DEFINE EMPTY )
#IF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
# set( PCH_COMPILER_DEFINE CVF_LINUX)
#ENDIF(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
#
#precompiled_header( RAW_SOURCES ALL_INCLUDES ${GCC_PCH_TARGET} ${PCH_NAME} ${PCH_COMPILER_DEFINE} )
################################################################################

14
ApplicationCode/GeoMech/GeoMechDataModel/RigGeoMechCaseData.cpp
View File

@ -296,3 +296,17 @@ size_t RigGeoMechCaseData::frameCount(int stepIndex, const RigFemResultAddress&
return maxFrameCount;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigGeoMechCaseData::assertResultsLoaded(int stepIndex, const RigFemResultAddress& resVarAddr)
{
for (int pIdx = 0; pIdx < m_femPartResults.size(); ++pIdx)
{
if (m_femPartResults[pIdx].notNull())
{
findOrLoadScalarResult(pIdx, stepIndex, resVarAddr);
}
}
}

3
ApplicationCode/GeoMech/GeoMechDataModel/RigGeoMechCaseData.h
View File

@ -44,11 +44,14 @@ public:
std::map<std::string, std::vector<std::string> > scalarFieldAndComponentNames(RigFemResultPosEnum resPos);
std::vector<std::string> stepNames();
void assertResultsLoaded(int stepIndex, const RigFemResultAddress& resVarAddr);
RigFemScalarResultFrames* findOrLoadScalarResult(int partIndex,
int stepIndex,
const RigFemResultAddress& resVarAddr);
size_t frameCount(int stepIndex, const RigFemResultAddress& resVarAddr);
std::vector<double> frameTimes(int stepIndex, const RigFemResultAddress& resVarAddr);
void minMaxScalarValues (const RigFemResultAddress& resVarAddr, int stepIndex, int frameIndex, double* localMin, double* localMax);
void posNegClosestToZero(const RigFemResultAddress& resVarAddr, int stepIndex, int frameIndex, double* localPosClosestToZero, double* localNegClosestToZero);
void minMaxScalarValues (const RigFemResultAddress& resVarAddr, int stepIndex, double* globalMin, double* globalMax);

20
ApplicationCode/ProjectDataModel/RimGeoMechResultSlot.cpp
View File

@ -160,20 +160,24 @@ void RimGeoMechResultSlot::fieldChangedByUi(const caf::PdmFieldHandle* changedFi
if (&m_resultVariableUiField == changedField)
{
QStringList fieldComponentNames = m_resultVariableUiField().split(QRegExp("\\s+"));
if (fieldComponentNames.size() == 2)
if (fieldComponentNames.size() > 0)
{
m_resultPositionType = m_resultPositionTypeUiField;
m_resultFieldName = fieldComponentNames[0];
m_resultComponentName = fieldComponentNames[1];
}
if (fieldComponentNames.size() > 1)
{
m_resultComponentName = fieldComponentNames[1];
}
// Todo: Read results into cache ?
if (m_reservoirView)
{
m_reservoirView->createDisplayModelAndRedraw();
// Todo: Read results into cache ?
if (m_reservoirView)
{
m_reservoirView->createDisplayModelAndRedraw();
}
}
}
}

28
ApplicationCode/ProjectDataModel/RimGeoMechView.cpp
View File

@ -43,29 +43,6 @@
#include "RigFemPartCollection.h"
#include "cafFrameAnimationControl.h"
namespace caf {
template<>
void caf::AppEnum< RimGeoMechView::MeshModeType >::setUp()
{
addItem(RimGeoMechView::FULL_MESH, "FULL_MESH", "All");
addItem(RimGeoMechView::FAULTS_MESH, "FAULTS_MESH", "Faults only");
addItem(RimGeoMechView::NO_MESH, "NO_MESH", "None");
setDefault(RimGeoMechView::FULL_MESH);
}
template<>
void caf::AppEnum< RimGeoMechView::SurfaceModeType >::setUp()
{
addItem(RimGeoMechView::SURFACE, "SURFACE", "All");
addItem(RimGeoMechView::FAULTS, "FAULTS", "Faults only");
addItem(RimGeoMechView::NO_SURFACE, "NO_SURFACE", "None");
setDefault(RimGeoMechView::SURFACE);
}
} // End namespace caf
@ -83,11 +60,6 @@ RimGeoMechView::RimGeoMechView(void)
CAF_PDM_InitFieldNoDefault(&cellResult, "GridCellResult", "Color Result", ":/CellResult.png", "", "");
cellResult = new RimGeoMechResultSlot();
caf::AppEnum<RimGeoMechView::MeshModeType> defaultMeshType = NO_MESH;
if (preferences->defaultGridLines) defaultMeshType = FULL_MESH;
CAF_PDM_InitField(&meshMode, "MeshMode", defaultMeshType, "Grid lines", "", "", "");
CAF_PDM_InitFieldNoDefault(&surfaceMode, "SurfaceMode", "Grid surface", "", "", "");
this->cellResult()->setReservoirView(this);
this->cellResult()->legendConfig()->setPosition(cvf::Vec2ui(10, 120));

19
ApplicationCode/ProjectDataModel/RimGeoMechView.h
View File

@ -52,20 +52,6 @@ public:
RimGeoMechView(void);
virtual ~RimGeoMechView(void);
enum MeshModeType
{
FULL_MESH,
FAULTS_MESH,
NO_MESH
};
enum SurfaceModeType
{
SURFACE,
FAULTS,
NO_SURFACE
};
void setGeoMechCase(RimGeoMechCase* gmCase);
RimGeoMechCase* geoMechCase();
@ -75,8 +61,8 @@ public:
caf::PdmField<RimGeoMechResultSlot*> cellResult;
caf::PdmField< caf::AppEnum< MeshModeType > > meshMode;
caf::PdmField< caf::AppEnum< SurfaceModeType > > surfaceMode;
bool isTimeStepDependentDataVisible();
private:
virtual void createDisplayModel();
@ -92,7 +78,6 @@ private:
virtual void resetLegendsInViewer();
void updateLegends();
bool isTimeStepDependentDataVisible();
caf::PdmPointer<RimGeoMechCase> m_geomechCase;
cvf::ref<RivGeoMechPartMgr> m_geoMechVizModel;
cvf::ref<cvf::Transform> m_scaleTransform;

11
ApplicationCode/ProjectDataModel/RimProject.h
View File

@ -50,10 +50,6 @@ public:
caf::PdmPointersField<RimCommandObject*> commandObjects;
caf::PdmField<QString> treeViewState;
caf::PdmField<QString> currentModelIndexPath;
caf::PdmField<int> nextValidCaseId; // Unique case ID within a project, used to identify a case from Octave scripts
caf::PdmField<int> nextValidCaseGroupId; // Unique case group ID within a project, used to identify a case group from Octave scripts
caf::PdmPointersField<RimCase*> casesObsolete; // obsolete
caf::PdmPointersField<RimIdenticalGridCaseGroup*> caseGroupsObsolete; // obsolete
void setScriptDirectories(const QString& scriptDirectories);
QString projectFileVersionString() const;
@ -79,4 +75,11 @@ protected:
private:
caf::PdmField<QString> m_projectFileVersionString;
caf::PdmField<int> nextValidCaseId; // Unique case ID within a project, used to identify a case from Octave scripts
caf::PdmField<int> nextValidCaseGroupId; // Unique case group ID within a project, used to identify a case group from Octave scripts
caf::PdmPointersField<RimCase*> casesObsolete; // obsolete
caf::PdmPointersField<RimIdenticalGridCaseGroup*> caseGroupsObsolete; // obsolete
};

215
ApplicationCode/ProjectDataModel/RimReservoirView.cpp
View File

@ -62,29 +62,6 @@
#include <limits.h>
namespace caf {
template<>
void caf::AppEnum< RimReservoirView::MeshModeType >::setUp()
{
addItem(RimReservoirView::FULL_MESH, "FULL_MESH", "All");
addItem(RimReservoirView::FAULTS_MESH, "FAULTS_MESH", "Faults only");
addItem(RimReservoirView::NO_MESH, "NO_MESH", "None");
setDefault(RimReservoirView::FULL_MESH);
}
template<>
void caf::AppEnum< RimReservoirView::SurfaceModeType >::setUp()
{
addItem(RimReservoirView::SURFACE, "SURFACE", "All");
addItem(RimReservoirView::FAULTS, "FAULTS", "Faults only");
addItem(RimReservoirView::NO_SURFACE, "NO_SURFACE", "None");
setDefault(RimReservoirView::SURFACE);
}
} // End namespace caf
@ -124,11 +101,6 @@ RimReservoirView::RimReservoirView()
propertyFilterCollection = new RimCellPropertyFilterCollection();
propertyFilterCollection->setReservoirView(this);
caf::AppEnum<RimReservoirView::MeshModeType> defaultMeshType = NO_MESH;
if (preferences->defaultGridLines) defaultMeshType = FULL_MESH;
CAF_PDM_InitField(&meshMode, "MeshMode", defaultMeshType, "Grid lines", "", "", "");
CAF_PDM_InitFieldNoDefault(&surfaceMode, "SurfaceMode", "Grid surface", "", "", "");
// Visualization fields
CAF_PDM_InitField(&showMainGrid, "ShowMainGrid", true, "Show Main Grid", "", "", "");
CAF_PDM_InitField(&showInactiveCells, "ShowInactiveCells", false, "Show Inactive Cells", "", "", "");
@ -149,7 +121,6 @@ RimReservoirView::RimReservoirView()
m_pipesPartManager = new RivReservoirPipesPartMgr(this);
m_reservoir = NULL;
m_previousGridModeMeshLinesWasFaults = false;
}
//--------------------------------------------------------------------------------------------------
@ -215,13 +186,15 @@ void RimReservoirView::clampCurrentTimestep()
//--------------------------------------------------------------------------------------------------
void RimReservoirView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
if (changedField == &scaleZ )
RimView::fieldChangedByUi(changedField, oldValue, newValue);
if (changedField == &scaleZ)
{
if (scaleZ < 1) scaleZ = 1;
// Regenerate well paths
RimOilField* oilFields = RiaApplication::instance()->project() ? RiaApplication::instance()->project()->activeOilField() : NULL;
RimWellPathCollection* wellPathCollection = (oilFields) ? oilFields->wellPathCollection() : NULL;
RimWellPathCollection* wellPathCollection = (oilFields) ? oilFields->wellPathCollection() : NULL;
if (wellPathCollection) wellPathCollection->wellPathCollectionPartMgr()->scheduleGeometryRegen();
if (m_viewer)
@ -232,8 +205,8 @@ void RimReservoirView::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
dir = m_viewer->mainCamera()->direction();
up = m_viewer->mainCamera()->up();
eye[2] = poi[2]*scaleZ()/m_reservoirGridPartManager->scaleTransform()->worldTransform()(2,2) + (eye[2] - poi[2]);
poi[2] = poi[2]*scaleZ()/m_reservoirGridPartManager->scaleTransform()->worldTransform()(2,2);
eye[2] = poi[2]*scaleZ()/m_reservoirGridPartManager->scaleTransform()->worldTransform()(2, 2) + (eye[2] - poi[2]);
poi[2] = poi[2]*scaleZ()/m_reservoirGridPartManager->scaleTransform()->worldTransform()(2, 2);
m_viewer->mainCamera()->setFromLookAt(eye, eye + dir, up);
m_viewer->setPointOfInterest(poi);
@ -245,16 +218,7 @@ void RimReservoirView::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
RiuMainWindow::instance()->updateScaleValue();
}
else if (changedField == &maximumFrameRate)
{
// !! Use cvf::UNDEFINED_INT or something if we end up with frame rate 0?
// !! Should be able to specify legal range for number properties
if (m_viewer)
{
m_viewer->animationControl()->setTimeout(maximumFrameRate != 0 ? 1000/maximumFrameRate : INT_MAX);
}
}
else if (changedField == &showWindow )
else if (changedField == &showWindow)
{
if (showWindow)
{
@ -277,67 +241,40 @@ void RimReservoirView::fieldChangedByUi(const caf::PdmFieldHandle* changedField,
this->updateUiIconFromToggleField();
}
else if (changedField == &backgroundColor )
{
if (viewer() != NULL)
{
updateViewerWidget();
}
}
else if (changedField == &m_currentTimeStep)
{
if (m_viewer)
{
m_viewer->update();
}
}
else if (changedField == &showInvalidCells )
else if (changedField == &showInvalidCells)
{
m_reservoirGridPartManager->scheduleGeometryRegen(RivReservoirViewPartMgr::INACTIVE);
m_reservoirGridPartManager->scheduleGeometryRegen(RivReservoirViewPartMgr::RANGE_FILTERED_INACTIVE);
createDisplayModelAndRedraw();
}
else if ( changedField == &showInactiveCells )
}
else if (changedField == &showInactiveCells)
{
m_reservoirGridPartManager->scheduleGeometryRegen(RivReservoirViewPartMgr::INACTIVE);
m_reservoirGridPartManager->scheduleGeometryRegen(RivReservoirViewPartMgr::RANGE_FILTERED_INACTIVE);
createDisplayModelAndRedraw();
}
else if ( changedField == &showMainGrid )
}
else if (changedField == &showMainGrid)
{
createDisplayModelAndRedraw();
}
else if ( changedField == &rangeFilterCollection )
}
else if (changedField == &rangeFilterCollection)
{
m_reservoirGridPartManager->scheduleGeometryRegen(RivReservoirViewPartMgr::RANGE_FILTERED);
m_reservoirGridPartManager->scheduleGeometryRegen(RivReservoirViewPartMgr::RANGE_FILTERED_INACTIVE);
scheduleCreateDisplayModelAndRedraw();
}
else if ( changedField == &propertyFilterCollection)
}
else if (changedField == &propertyFilterCollection)
{
m_reservoirGridPartManager->scheduleGeometryRegen(RivReservoirViewPartMgr::PROPERTY_FILTERED);
scheduleCreateDisplayModelAndRedraw();
}
else if (changedField == &meshMode)
{
createDisplayModel();
updateDisplayModelVisibility();
RiuMainWindow::instance()->refreshDrawStyleActions();
}
else if (changedField == &surfaceMode)
{
createDisplayModel();
updateDisplayModelVisibility();
RiuMainWindow::instance()->refreshDrawStyleActions();
}
else if (changedField == &name)
{
updateViewerWidgetWindowTitle();
}
}
void RimReservoirView::updateScaleTransform()
@ -1355,120 +1292,6 @@ void RimReservoirView::updateDisplayModelForWellResults()
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirView::setMeshOnlyDrawstyle()
{
if (isGridVisualizationMode())
{
meshMode.setValueFromUi(FULL_MESH);
}
else
{
meshMode.setValueFromUi(FAULTS_MESH);
}
surfaceMode.setValueFromUi(NO_SURFACE);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirView::setMeshSurfDrawstyle()
{
if (isGridVisualizationMode())
{
surfaceMode.setValueFromUi(SURFACE);
meshMode.setValueFromUi(FULL_MESH);
}
else
{
surfaceMode.setValueFromUi(FAULTS);
meshMode.setValueFromUi(FAULTS_MESH);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirView::setFaultMeshSurfDrawstyle()
{
// Surf: No Fault Surf
// Mesh -------------
// No FF FF SF
// Fault FF FF SF
// Mesh SF SF SF
if (this->isGridVisualizationMode())
{
surfaceMode.setValueFromUi(SURFACE);
}
else
{
surfaceMode.setValueFromUi(FAULTS);
}
meshMode.setValueFromUi(FAULTS_MESH);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirView::setSurfOnlyDrawstyle()
{
if (isGridVisualizationMode())
{
surfaceMode.setValueFromUi(SURFACE);
}
else
{
surfaceMode.setValueFromUi(FAULTS);
}
meshMode.setValueFromUi(NO_MESH);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirView::setShowFaultsOnly(bool showFaults)
{
if (showFaults)
{
m_previousGridModeMeshLinesWasFaults = meshMode() == FAULTS_MESH;
if (surfaceMode() != NO_SURFACE) surfaceMode.setValueFromUi(FAULTS);
if (meshMode() != NO_MESH) meshMode.setValueFromUi(FAULTS_MESH);
}
else
{
if (surfaceMode() != NO_SURFACE) surfaceMode.setValueFromUi(SURFACE);
if (meshMode() != NO_MESH) meshMode.setValueFromUi(m_previousGridModeMeshLinesWasFaults ? FAULTS_MESH: FULL_MESH);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimReservoirView::setSurfaceDrawstyle()
{
if (surfaceMode() != NO_SURFACE) surfaceMode.setValueFromUi(SURFACE);
}
//--------------------------------------------------------------------------------------------------
///
// Surf: No Fault Surf
// Mesh -------------
// No F F G
// Fault F F G
// Mesh G G G
//
//--------------------------------------------------------------------------------------------------
bool RimReservoirView::isGridVisualizationMode() const
{
return ( this->surfaceMode() == SURFACE
|| this->meshMode() == FULL_MESH);
}
//--------------------------------------------------------------------------------------------------
///

26
ApplicationCode/ProjectDataModel/RimReservoirView.h
View File

@ -82,20 +82,6 @@ public:
RimReservoirView(void);
virtual ~RimReservoirView(void);
enum MeshModeType
{
FULL_MESH,
FAULTS_MESH,
NO_MESH
};
enum SurfaceModeType
{
SURFACE,
FAULTS,
NO_SURFACE
};
// Fields containing child objects :
caf::PdmField<RimResultSlot*> cellResult;
@ -113,8 +99,6 @@ public:
caf::PdmField<bool> showInactiveCells;
caf::PdmField<bool> showMainGrid;
caf::PdmField< caf::AppEnum< MeshModeType > > meshMode;
caf::PdmField< caf::AppEnum< SurfaceModeType > > surfaceMode;
// Access internal objects
RimReservoirCellResultsStorage* currentGridCellResults();
@ -127,14 +111,7 @@ public:
public:
void setMeshOnlyDrawstyle();
void setMeshSurfDrawstyle();
void setSurfOnlyDrawstyle();
void setFaultMeshSurfDrawstyle();
void setSurfaceDrawstyle();
void setShowFaultsOnly(bool showFaults);
bool isGridVisualizationMode() const;
// Does this belong here, really ?
void calculateVisibleWellCellsIncFence(cvf::UByteArray* visibleCells, RigGridBase * grid);
@ -194,7 +171,6 @@ private:
private:
caf::PdmPointer<RimCase> m_reservoir;
bool m_previousGridModeMeshLinesWasFaults;
std::vector<RivReservoirViewPartMgr::ReservoirGeometryCacheType> m_visibleGridParts;
};

191
ApplicationCode/ProjectDataModel/RimView.cpp
View File

@ -12,6 +12,32 @@
#include "cvfViewport.h"
#include "cafFrameAnimationControl.h"
namespace caf {
template<>
void caf::AppEnum< RimView::MeshModeType >::setUp()
{
addItem(RimView::FULL_MESH, "FULL_MESH", "All");
addItem(RimView::FAULTS_MESH, "FAULTS_MESH", "Faults only");
addItem(RimView::NO_MESH, "NO_MESH", "None");
setDefault(RimView::FULL_MESH);
}
template<>
void caf::AppEnum< RimView::SurfaceModeType >::setUp()
{
addItem(RimView::SURFACE, "SURFACE", "All");
addItem(RimView::FAULTS, "FAULTS", "Faults only");
addItem(RimView::NO_SURFACE, "NO_SURFACE", "None");
setDefault(RimView::SURFACE);
}
} // End namespace caf
CAF_PDM_ABSTRACT_SOURCE_INIT(RimView, "GenericView"); // Do not use. Abstract class
//--------------------------------------------------------------------------------------------------
@ -49,7 +75,12 @@ RimView::RimView(void)
overlayInfoConfig = new Rim3dOverlayInfoConfig();
overlayInfoConfig->setReservoirView(this);
caf::AppEnum<RimView::MeshModeType> defaultMeshType = NO_MESH;
if (preferences->defaultGridLines) defaultMeshType = FULL_MESH;
CAF_PDM_InitField(&meshMode, "MeshMode", defaultMeshType, "Grid lines", "", "", "");
CAF_PDM_InitFieldNoDefault(&surfaceMode, "SurfaceMode", "Grid surface", "", "", "");
m_previousGridModeMeshLinesWasFaults = false;
}
//--------------------------------------------------------------------------------------------------
@ -221,5 +252,165 @@ void RimView::setupBeforeSave()
}
}
//--------------------------------------------------------------------------------------------------
///
// Surf: No Fault Surf
// Mesh -------------
// No F F G
// Fault F F G
// Mesh G G G
//
//--------------------------------------------------------------------------------------------------
bool RimView::isGridVisualizationMode() const
{
return ( this->surfaceMode() == SURFACE
|| this->meshMode() == FULL_MESH);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimView::setMeshOnlyDrawstyle()
{
if (isGridVisualizationMode())
{
meshMode.setValueFromUi(FULL_MESH);
}
else
{
meshMode.setValueFromUi(FAULTS_MESH);
}
surfaceMode.setValueFromUi(NO_SURFACE);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimView::setMeshSurfDrawstyle()
{
if (isGridVisualizationMode())
{
surfaceMode.setValueFromUi(SURFACE);
meshMode.setValueFromUi(FULL_MESH);
}
else
{
surfaceMode.setValueFromUi(FAULTS);
meshMode.setValueFromUi(FAULTS_MESH);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimView::setFaultMeshSurfDrawstyle()
{
// Surf: No Fault Surf
// Mesh -------------
// No FF FF SF
// Fault FF FF SF
// Mesh SF SF SF
if (this->isGridVisualizationMode())
{
surfaceMode.setValueFromUi(SURFACE);
}
else
{
surfaceMode.setValueFromUi(FAULTS);
}
meshMode.setValueFromUi(FAULTS_MESH);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimView::setSurfOnlyDrawstyle()
{
if (isGridVisualizationMode())
{
surfaceMode.setValueFromUi(SURFACE);
}
else
{
surfaceMode.setValueFromUi(FAULTS);
}
meshMode.setValueFromUi(NO_MESH);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimView::setShowFaultsOnly(bool showFaults)
{
if (showFaults)
{
m_previousGridModeMeshLinesWasFaults = meshMode() == FAULTS_MESH;
if (surfaceMode() != NO_SURFACE) surfaceMode.setValueFromUi(FAULTS);
if (meshMode() != NO_MESH) meshMode.setValueFromUi(FAULTS_MESH);
}
else
{
if (surfaceMode() != NO_SURFACE) surfaceMode.setValueFromUi(SURFACE);
if (meshMode() != NO_MESH) meshMode.setValueFromUi(m_previousGridModeMeshLinesWasFaults ? FAULTS_MESH: FULL_MESH);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimView::setSurfaceDrawstyle()
{
if (surfaceMode() != NO_SURFACE) surfaceMode.setValueFromUi(SURFACE);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
if (changedField == &meshMode)
{
createDisplayModel();
updateDisplayModelVisibility();
RiuMainWindow::instance()->refreshDrawStyleActions();
}
else if (changedField == &surfaceMode)
{
createDisplayModel();
updateDisplayModelVisibility();
RiuMainWindow::instance()->refreshDrawStyleActions();
}
else if (changedField == &name)
{
updateViewerWidgetWindowTitle();
}
else if (changedField == &m_currentTimeStep)
{
if (m_viewer)
{
m_viewer->update();
}
}
else if (changedField == &backgroundColor)
{
if (viewer() != NULL)
{
updateViewerWidget();
}
}
else if (changedField == &maximumFrameRate)
{
// !! Use cvf::UNDEFINED_INT or something if we end up with frame rate 0?
// !! Should be able to specify legal range for number properties
if (m_viewer)
{
m_viewer->animationControl()->setTimeout(maximumFrameRate != 0 ? 1000/maximumFrameRate : INT_MAX);
}
}
}

33
ApplicationCode/ProjectDataModel/RimView.h
View File

@ -23,6 +23,7 @@
#include "cafPdmField.h"
#include "cafPdmFieldCvfColor.h"
#include "cafPdmFieldCvfMat4d.h"
#include "cafAppEnum.h"
class RiuViewer;
class Rim3dOverlayInfoConfig;
@ -55,6 +56,34 @@ public:
caf::PdmField<int> maximumFrameRate;
caf::PdmField<bool> animationMode;
// Draw style
enum MeshModeType
{
FULL_MESH,
FAULTS_MESH,
NO_MESH
};
enum SurfaceModeType
{
SURFACE,
FAULTS,
NO_SURFACE
};
caf::PdmField< caf::AppEnum< MeshModeType > > meshMode;
caf::PdmField< caf::AppEnum< SurfaceModeType > > surfaceMode;
void setMeshOnlyDrawstyle();
void setMeshSurfDrawstyle();
void setSurfOnlyDrawstyle();
void setFaultMeshSurfDrawstyle();
void setSurfaceDrawstyle();
void setShowFaultsOnly(bool showFaults);
bool isGridVisualizationMode() const;
// Animation
int currentTimeStep() { return m_currentTimeStep;}
void setCurrentTimeStep(int frameIdx);
@ -91,6 +120,10 @@ protected:
// Overridden PDM methods:
virtual void setupBeforeSave();
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue);
private:
bool m_previousGridModeMeshLinesWasFaults;
};

5
ApplicationCode/SocketInterface/RiaSocketServer.cpp
View File

@ -152,9 +152,10 @@ RimCase* RiaSocketServer::findReservoir(int caseId)
if (currCaseId < 0)
{
if (RiaApplication::instance()->activeReservoirView())
RimReservoirView* riv = dynamic_cast<RimReservoirView*>(RiaApplication::instance()->activeReservoirView());
if (riv)
{
return RiaApplication::instance()->activeReservoirView()->eclipseCase();
return riv->eclipseCase();
}
}
else

100
ApplicationCode/UserInterface/RiuMainWindow.cpp
View File

@ -37,7 +37,11 @@
#include "RimProject.h"
#include "RimReservoirCellResultsStorage.h"
#include "RimReservoirView.h"
#include "RimGeoMechView.h"
#include "RimGeoMechCase.h"
#include "RimResultSlot.h"
#include "RimGeoMechResultSlot.h"
#include "RimTools.h"
#include "RimUiTreeModelPdm.h"
#include "RimUiTreeView.h"
@ -50,6 +54,8 @@
#include "RiuViewer.h"
#include "RiuWellImportWizard.h"
#include "RigGeoMechCaseData.h"
#include "cafAboutDialog.h"
#include "cafAnimationToolBar.h"
#include "cafPdmFieldCvfMat4d.h"
@ -58,6 +64,7 @@
#include "cvfTimer.h"
#include "RimGeoMechModels.h"
#include "RimGeoMechView.h"
//==================================================================================================
@ -708,45 +715,67 @@ void RiuMainWindow::refreshAnimationActions()
RiaApplication* app = RiaApplication::instance();
bool enableAnimControls = false;
if (app->activeReservoirView() &&
app->activeReservoirView()->viewer() &&
app->activeReservoirView()->viewer()->frameCount())
RimView * activeView = app->activeReservoirView();
if (activeView &&
activeView->viewer() &&
activeView->viewer()->frameCount())
{
enableAnimControls = true;
RimReservoirView * activeRiv = dynamic_cast<RimReservoirView*>(activeView);
if (app->activeReservoirView()->currentGridCellResults())
if (activeRiv)
{
if (app->activeReservoirView()->isTimeStepDependentDataVisible())
if (activeRiv->currentGridCellResults())
{
std::vector<QDateTime> timeStepDates = app->activeReservoirView()->currentGridCellResults()->cellResults()->timeStepDates(0);
bool showHoursAndMinutes = false;
for (size_t i = 0; i < timeStepDates.size(); i++)
if (activeRiv->isTimeStepDependentDataVisible())
{
if (timeStepDates[i].time().hour() != 0.0 || timeStepDates[i].time().minute() != 0.0)
std::vector<QDateTime> timeStepDates = activeRiv->currentGridCellResults()->cellResults()->timeStepDates(0);
bool showHoursAndMinutes = false;
for (size_t i = 0; i < timeStepDates.size(); i++)
{
showHoursAndMinutes = true;
if (timeStepDates[i].time().hour() != 0.0 || timeStepDates[i].time().minute() != 0.0)
{
showHoursAndMinutes = true;
}
}
QString formatString = "dd.MMM yyyy";
if (showHoursAndMinutes)
{
formatString += " - hh:mm";
}
for (size_t i = 0; i < timeStepDates.size(); i++)
{
timeStepStrings += timeStepDates[i].toString(formatString);
}
currentTimeStepIndex = RiaApplication::instance()->activeReservoirView()->currentTimeStep();
}
else
{
timeStepStrings.push_back(tr("Static Property"));
}
}
}
else
{
RimGeoMechView * activeGmv = dynamic_cast<RimGeoMechView*>(activeView);
if (activeGmv)
{
if (activeGmv->isTimeStepDependentDataVisible())
{
RigFemResultAddress resAddr = activeGmv->cellResult()->resultAddress();
size_t frameCount = activeGmv->geoMechCase()->geoMechData()->frameCount(0, resAddr);
for (size_t i = 0; i < frameCount; i++)
{
timeStepStrings += QString::number(i);
}
}
QString formatString = "dd.MMM yyyy";
if (showHoursAndMinutes)
{
formatString += " - hh:mm";
}
for (size_t i = 0; i < timeStepDates.size(); i++)
{
timeStepStrings += timeStepDates[i].toString(formatString);
}
currentTimeStepIndex = RiaApplication::instance()->activeReservoirView()->currentTimeStep();
}
else
{
timeStepStrings.push_back(tr("Static Property"));
}
}
// Animation control is only relevant for more than one time step
if (timeStepStrings.size() < 2)
{
enableAnimControls = false;
@ -1321,7 +1350,7 @@ void RiuMainWindow::slotSubWindowActivated(QMdiSubWindow* subWindow)
riv->viewer()->layoutWidget() &&
riv->viewer()->layoutWidget()->parent() == subWindow)
{
RimReservoirView* previousActiveReservoirView = RiaApplication::instance()->activeReservoirView();
RimView* previousActiveReservoirView = RiaApplication::instance()->activeReservoirView();
RiaApplication::instance()->setActiveReservoirView(riv);
if (previousActiveReservoirView && previousActiveReservoirView != riv)
{
@ -1475,7 +1504,7 @@ void RiuMainWindow::slotBuildWindowActions()
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::slotCurrentChanged(const QModelIndex & current, const QModelIndex & previous)
{
RimReservoirView* activeReservoirView = RiaApplication::instance()->activeReservoirView();
RimView* activeReservoirView = RiaApplication::instance()->activeReservoirView();
QModelIndex activeViewModelIndex = m_treeModelPdm->getModelIndexFromPdmObject(activeReservoirView);
QModelIndex tmp = current;
@ -1486,7 +1515,7 @@ void RiuMainWindow::slotCurrentChanged(const QModelIndex & current, const QModel
caf::PdmUiTreeItem* treeItem = m_treeModelPdm->getTreeItemFromIndex(tmp);
caf::PdmObject* pdmObject = treeItem->dataObject();
RimReservoirView* rimReservoirView = dynamic_cast<RimReservoirView*>(pdmObject);
RimView* rimReservoirView = dynamic_cast<RimView*>(pdmObject);
if (rimReservoirView)
{
// If current selection is an item within a different reservoir view than active,
@ -1694,9 +1723,10 @@ void RiuMainWindow::slotToggleFaultsAction(bool showFaults)
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::slotToggleFaultLabelsAction(bool showLabels)
{
if (!RiaApplication::instance()->activeReservoirView()) return;
RimReservoirView* activeRiv = dynamic_cast<RimReservoirView*>(RiaApplication::instance()->activeReservoirView());
if (!activeRiv) return;
RiaApplication::instance()->activeReservoirView()->faultCollection->showFaultLabel.setValueFromUi(showLabels);
activeRiv->faultCollection->showFaultLabel.setValueFromUi(showLabels);
refreshDrawStyleActions();
}
@ -1713,6 +1743,10 @@ void RiuMainWindow::refreshDrawStyleActions()
m_drawStyleSurfOnlyAction->setEnabled(enable);
m_drawStyleFaultLinesSolidAction->setEnabled(enable);
RimReservoirView* riv = dynamic_cast<RimReservoirView*>(RiaApplication::instance()->activeReservoirView());
enable = enable && riv;
m_drawStyleToggleFaultsAction->setEnabled(enable);
m_toggleFaultsLabelAction->setEnabled(enable);
@ -1720,7 +1754,7 @@ void RiuMainWindow::refreshDrawStyleActions()
if (enable)
{
RimReservoirView* riv = RiaApplication::instance()->activeReservoirView();
m_drawStyleToggleFaultsAction->blockSignals(true);
m_drawStyleToggleFaultsAction->setChecked( !riv->isGridVisualizationMode());
m_drawStyleToggleFaultsAction->blockSignals(false);
@ -2009,7 +2043,7 @@ void RiuMainWindow::setDefaultWindowSize()
//--------------------------------------------------------------------------------------------------
void RiuMainWindow::slotAddWellCellsToRangeFilterAction(bool doAdd)
{
RimReservoirView* riv = RiaApplication::instance()->activeReservoirView();
RimReservoirView* riv = dynamic_cast<RimReservoirView*>(RiaApplication::instance()->activeReservoirView());
if (riv)
{
caf::AppEnum<RimWellCollection::WellCellsRangeFilterType> rangeAddType;