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

#2331 Introduce new intermediate class RimGridView

Browse Source
This commit is contained in:
Jacob Støren
2018-01-15 14:52:22 +01:00
parent 1bbd3ade7b
commit b092565a61
48 changed files with 1387 additions and 508 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
ApplicationCode/Application/RiaApplication.cpp
View File

@@ -570,7 +570,8 @@ bool RiaApplication::loadProject(const QString& projectFileName, ProjectLoadActi
riv->loadDataAndUpdate();
this->setActiveReservoirView(riv);
riv->rangeFilterCollection()->updateIconState();
RimGridView* rigv = dynamic_cast<RimGridView*>(riv);
if (rigv) rigv->rangeFilterCollection()->updateIconState();
viewProgress.incrementProgress();
}
@@ -1163,6 +1164,14 @@ Rim3dView* RiaApplication::activeReservoirView()
return m_activeReservoirView;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimGridView* RiaApplication::activeGridView()
{
return dynamic_cast<RimGridView*>( m_activeReservoirView.p());
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/Application/RiaApplication.h
View File

@@ -48,6 +48,7 @@ class RigEclipseCaseData;
class RimCommandObject;
class RimEclipseCase;
class RimEclipseView;
class RimGridView;
class RimProject;
class RimSummaryPlot;
class Rim3dView;
@@ -102,6 +103,7 @@ public:
void setActiveReservoirView(Rim3dView*);
Rim3dView* activeReservoirView();
const Rim3dView* activeReservoirView() const;
RimGridView* activeGridView();
RimViewWindow* activePlotWindow() const;

2
ApplicationCode/Commands/CrossSectionCommands/RicAppendIntersectionFeature.cpp
View File

@@ -102,7 +102,7 @@ void RicAppendIntersectionFeatureCmd::redo()
intersection->name = QString("Intersection");
m_intersectionCollection->appendIntersection(intersection);
Rim3dView* view = nullptr;
RimGridView* view = nullptr;
m_intersectionCollection->firstAncestorOrThisOfTypeAsserted(view);
//Enable display of grid cells, to be able to show generated property filter

2
ApplicationCode/Commands/CrossSectionCommands/RicNewAzimuthDipIntersectionFeature.cpp
View File

@@ -61,7 +61,7 @@ bool RicNewAzimuthDipIntersectionFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicNewAzimuthDipIntersectionFeature::onActionTriggered(bool isChecked)
{
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
if (!activeView) return;
RicNewAzimuthDipIntersectionFeatureCmd* cmd = new RicNewAzimuthDipIntersectionFeatureCmd(activeView->crossSectionCollection);

2
ApplicationCode/Commands/CrossSectionCommands/RicNewPolylineIntersectionFeature.cpp
View File

@@ -60,7 +60,7 @@ bool RicNewPolylineIntersectionFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicNewPolylineIntersectionFeature::onActionTriggered(bool isChecked)
{
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
if (!activeView) return;
RicNewPolylineIntersectionFeatureCmd* cmd = new RicNewPolylineIntersectionFeatureCmd(activeView->crossSectionCollection);

2
ApplicationCode/Commands/CrossSectionCommands/RicNewWellPathIntersectionFeature.cpp
View File

@@ -56,7 +56,7 @@ bool RicNewWellPathIntersectionFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicNewWellPathIntersectionFeature::onActionTriggered(bool isChecked)
{
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
if (!activeView) return;
std::vector<RimWellPath*> collection;

2
ApplicationCode/Commands/EclipseCommands/RicEclipsePropertyFilterNewExec.cpp
View File

@@ -58,7 +58,7 @@ void RicEclipsePropertyFilterNewExec::redo()
{
RicEclipsePropertyFilterFeatureImpl::addPropertyFilter(m_propertyFilterCollection);
Rim3dView* view = nullptr;
RimGridView* view = nullptr;
m_propertyFilterCollection->firstAncestorOrThisOfTypeAsserted(view);
//Enable display of grid cells, to be able to show generated property filter

2
ApplicationCode/Commands/ExportCommands/RicExportMultipleSnapshotsFeature.cpp
View File

@@ -207,7 +207,7 @@ void RicExportMultipleSnapshotsFeature::exportViewVariations(Rim3dView* rimView,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicExportMultipleSnapshotsFeature::exportViewVariationsToFolder(Rim3dView* rimView, RimMultiSnapshotDefinition* msd, const QString& folder)
void RicExportMultipleSnapshotsFeature::exportViewVariationsToFolder(RimGridView* rimView, RimMultiSnapshotDefinition* msd, const QString& folder)
{
RimCase* rimCase = rimView->ownerCase();
CVF_ASSERT(rimCase);

3
ApplicationCode/Commands/ExportCommands/RicExportMultipleSnapshotsFeature.h
View File

@@ -23,6 +23,7 @@
class RimMultiSnapshotDefinition;
class RimProject;
class Rim3dView;
class RimGridView;
//==================================================================================================
///
@@ -42,7 +43,7 @@ public:
static void exportViewVariations(Rim3dView* rimView, RimMultiSnapshotDefinition* msd, const QString& folder);
private:
static void exportViewVariationsToFolder(Rim3dView* rimView, RimMultiSnapshotDefinition* msd, const QString& folder);
static void exportViewVariationsToFolder(RimGridView* rimView, RimMultiSnapshotDefinition* msd, const QString& folder);
static QString resultName(Rim3dView* rimView);
};

11
ApplicationCode/Commands/ExportCommands/RicSnapshotAllViewsToFileFeature.cpp
View File

@@ -124,9 +124,14 @@ void RicSnapshotAllViewsToFileFeature::exportSnapshotOfAllViewsIntoFolder(QStrin
RicSnapshotViewToFileFeature::saveSnapshotAs(absoluteFileName, riv);
// Statistics dialog
QImage img = riv->overlayInfoConfig()->statisticsDialogScreenShotImage();
absoluteFileName = caf::Utils::constructFullFileName(absSnapshotPath, fileName + "_Statistics", ".png");
RicSnapshotViewToFileFeature::saveSnapshotAs(absoluteFileName, img);
RimGridView* rigv = dynamic_cast<RimGridView*>(riv);
if ( rigv )
{
QImage img = rigv->overlayInfoConfig()->statisticsDialogScreenShotImage();
absoluteFileName = caf::Utils::constructFullFileName(absSnapshotPath, fileName + "_Statistics", ".png");
RicSnapshotViewToFileFeature::saveSnapshotAs(absoluteFileName, img);
}
}
}
}

2
ApplicationCode/Commands/FlowCommands/RicShowContributingWellsFeature.cpp
View File

@@ -94,7 +94,7 @@ void RicShowContributingWellsFeature::onActionTriggered(bool isChecked)
{
modifiedView->createDisplayModelAndRedraw();
std::vector<Rim3dView*> viewsToUpdate;
std::vector<RimGridView*> viewsToUpdate;
viewsToUpdate.push_back(modifiedView);
RimViewManipulator::applySourceViewCameraOnDestinationViews(eclipseView, viewsToUpdate);

2
ApplicationCode/Commands/IntersectionBoxCommands/RicAppendIntersectionBoxFeature.cpp
View File

@@ -63,7 +63,7 @@ void RicAppendIntersectionBoxFeature::onActionTriggered(bool isChecked)
coll->updateConnectedEditors();
RiuMainWindow::instance()->selectAsCurrentItem(intersectionBox);
Rim3dView* rimView = nullptr;
RimGridView* rimView = nullptr;
coll->firstAncestorOrThisOfTypeAsserted(rimView);
rimView->showGridCells(false);
}

4
ApplicationCode/Commands/IntersectionBoxCommands/RicIntersectionBoxAtPosFeature.cpp
View File

@@ -50,7 +50,7 @@ bool RicIntersectionBoxAtPosFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicIntersectionBoxAtPosFeature::onActionTriggered(bool isChecked)
{
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
if (activeView)
{
RimIntersectionCollection* coll = activeView->crossSectionCollection();
@@ -67,7 +67,7 @@ void RicIntersectionBoxAtPosFeature::onActionTriggered(bool isChecked)
coll->updateConnectedEditors();
RiuMainWindow::instance()->selectAsCurrentItem(intersectionBox);
Rim3dView* rimView = NULL;
RimGridView* rimView = NULL;
coll->firstAncestorOrThisOfType(rimView);
if (rimView)
{

4
ApplicationCode/Commands/IntersectionBoxCommands/RicIntersectionBoxXSliceFeature.cpp
View File

@@ -50,7 +50,7 @@ bool RicIntersectionBoxXSliceFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicIntersectionBoxXSliceFeature::onActionTriggered(bool isChecked)
{
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
if (activeView)
{
RimIntersectionCollection* coll = activeView->crossSectionCollection();
@@ -67,7 +67,7 @@ void RicIntersectionBoxXSliceFeature::onActionTriggered(bool isChecked)
coll->updateConnectedEditors();
RiuMainWindow::instance()->selectAsCurrentItem(intersectionBox);
Rim3dView* rimView = NULL;
RimGridView* rimView = NULL;
coll->firstAncestorOrThisOfType(rimView);
if (rimView)
{

4
ApplicationCode/Commands/IntersectionBoxCommands/RicIntersectionBoxYSliceFeature.cpp
View File

@@ -50,7 +50,7 @@ bool RicIntersectionBoxYSliceFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicIntersectionBoxYSliceFeature::onActionTriggered(bool isChecked)
{
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
if (activeView)
{
RimIntersectionCollection* coll = activeView->crossSectionCollection();
@@ -67,7 +67,7 @@ void RicIntersectionBoxYSliceFeature::onActionTriggered(bool isChecked)
coll->updateConnectedEditors();
RiuMainWindow::instance()->selectAsCurrentItem(intersectionBox);
Rim3dView* rimView = NULL;
RimGridView* rimView = NULL;
coll->firstAncestorOrThisOfType(rimView);
if (rimView)
{

4
ApplicationCode/Commands/IntersectionBoxCommands/RicIntersectionBoxZSliceFeature.cpp
View File

@@ -50,7 +50,7 @@ bool RicIntersectionBoxZSliceFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicIntersectionBoxZSliceFeature::onActionTriggered(bool isChecked)
{
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
if (activeView)
{
RimIntersectionCollection* coll = activeView->crossSectionCollection();
@@ -66,7 +66,7 @@ void RicIntersectionBoxZSliceFeature::onActionTriggered(bool isChecked)
coll->updateConnectedEditors();
RiuMainWindow::instance()->selectAsCurrentItem(intersectionBox);
Rim3dView* rimView = NULL;
RimGridView* rimView = NULL;
coll->firstAncestorOrThisOfType(rimView);
if (rimView)
{

6
ApplicationCode/Commands/RicGridStatisticsDialog.cpp
View File

@@ -115,7 +115,7 @@ void RicGridStatisticsDialog::setLabel(const QString& labelText)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicGridStatisticsDialog::updateFromRimView(Rim3dView* rimView)
void RicGridStatisticsDialog::updateFromRimView(RimGridView* rimView)
{
m_currentRimView = rimView;
setInfoText(m_currentRimView);
@@ -134,7 +134,7 @@ QImage RicGridStatisticsDialog::screenShotImage()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicGridStatisticsDialog::setInfoText(Rim3dView* view)
void RicGridStatisticsDialog::setInfoText(RimGridView* view)
{
Rim3dOverlayInfoConfig* overlayInfo = view->overlayInfoConfig();
if (view && overlayInfo)
@@ -151,7 +151,7 @@ void RicGridStatisticsDialog::setInfoText(Rim3dView* view)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicGridStatisticsDialog::setHistogramData(Rim3dView* view)
void RicGridStatisticsDialog::setHistogramData(RimGridView* view)
{
deletePlotItems(m_historgramPlot);
deletePlotItems(m_aggregatedPlot);

9
ApplicationCode/Commands/RicGridStatisticsDialog.h
View File

@@ -32,6 +32,7 @@ class QwtPlotMarker;
class QMainWindow;
class QToolBar;
class RimEclipseView;
class RimGridView;
//==================================================================================================
///
@@ -46,12 +47,12 @@ public:
~RicGridStatisticsDialog();
void setLabel(const QString& labelText);
void updateFromRimView(Rim3dView* rimView);
void updateFromRimView(RimGridView* rimView);
QImage screenShotImage();
private:
void setInfoText(Rim3dView* eclipseView);
void setHistogramData(Rim3dView* eclipseView);
void setInfoText(RimGridView* eclipseView);
void setHistogramData(RimGridView* eclipseView);
private:
void createAndConnectToolbarActions();
@@ -74,5 +75,5 @@ private:
QwtPlot* m_aggregatedPlot;
QDialogButtonBox* m_buttons;
caf::PdmPointer<Rim3dView> m_currentRimView;
caf::PdmPointer<RimGridView> m_currentRimView;
};

4
ApplicationCode/Commands/RicNewSliceRangeFilterFeature.cpp
View File

@@ -39,7 +39,7 @@ CAF_CMD_SOURCE_INIT(RicNewSliceRangeFilterFeature, "RicNewSliceRangeFilterFeatur
//--------------------------------------------------------------------------------------------------
bool RicNewSliceRangeFilterFeature::isCommandEnabled()
{
Rim3dView* view = RiaApplication::instance()->activeReservoirView();
RimGridView* view = RiaApplication::instance()->activeGridView();
if (!view) return false;
RimViewController* vc = view->viewController();
@@ -57,7 +57,7 @@ void RicNewSliceRangeFilterFeature::onActionTriggered(bool isChecked)
if (!userData.isNull() && userData.type() == QVariant::List)
{
Rim3dView* view = RiaApplication::instance()->activeReservoirView();
RimGridView* view = RiaApplication::instance()->activeGridView();
RimCellRangeFilterCollection* rangeFilterCollection = view->rangeFilterCollection();
RicRangeFilterNewExec* filterExec = new RicRangeFilterNewExec(rangeFilterCollection);

4
ApplicationCode/Commands/RicRangeFilterFeatureImpl.cpp
View File

@@ -40,7 +40,7 @@ bool RicRangeFilterFeatureImpl::isRangeFilterCommandAvailable()
RimCellRangeFilterCollection* rangeFilterCollection = findRangeFilterCollection();
if (!rangeFilterCollection) return false;
Rim3dView* view;
RimGridView* view;
rangeFilterCollection->firstAncestorOrThisOfType(view);
if (view)
{
@@ -86,7 +86,7 @@ RimCellRangeFilterCollection* RicRangeFilterFeatureImpl::findRangeFilterCollecti
selectedRangeFilter[0]->firstAncestorOrThisOfType(rangeFilterCollection);
}
Rim3dView* view = RiaApplication::instance()->activeReservoirView();
RimGridView* view = RiaApplication::instance()->activeGridView();
if (view)
{
rangeFilterCollection = view->rangeFilterCollection();

2
ApplicationCode/Commands/RicRangeFilterNewExec.cpp
View File

@@ -77,7 +77,7 @@ void RicRangeFilterNewExec::redo()
RiuMainWindow::instance()->selectAsCurrentItem(rangeFilter);
Rim3dView* view = nullptr;
RimGridView* view = nullptr;
m_cellRangeFilterCollection->firstAncestorOrThisOfTypeAsserted(view);
//Enable display of grid cells, to be able to show generated range filter

4
ApplicationCode/Commands/RicShowGridStatisticsFeature.cpp
View File

@@ -42,7 +42,7 @@ bool RicShowGridStatisticsFeature::isCommandEnabled()
{
if (RicWellLogTools::isWellPathOrSimWellSelectedInView()) return false;
return RiaApplication::instance()->activeReservoirView() != nullptr;
return RiaApplication::instance()->activeGridView() != nullptr;
}
//--------------------------------------------------------------------------------------------------
@@ -50,7 +50,7 @@ bool RicShowGridStatisticsFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicShowGridStatisticsFeature::onActionTriggered(bool isChecked)
{
Rim3dView * activeView = RiaApplication::instance()->activeReservoirView();
RimGridView * activeView = RiaApplication::instance()->activeGridView();
if (activeView)
{

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

@@ -71,10 +71,10 @@ bool RicLinkViewFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicLinkViewFeature::onActionTriggered(bool isChecked)
{
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
if (!activeView) return;
std::vector<Rim3dView*> views;
std::vector<RimGridView*> views;
views.push_back(activeView);
RicLinkVisibleViewsFeature::linkViews(views);

29
ApplicationCode/Commands/ViewLink/RicLinkVisibleViewsFeature.cpp
View File

@@ -47,16 +47,23 @@ bool RicLinkVisibleViewsFeature::isCommandEnabled()
{
RimProject* proj = RiaApplication::instance()->project();
std::vector<Rim3dView*> visibleViews;
std::vector<Rim3dView*> linkedviews;
std::vector<RimGridView*> linkedviews;
std::vector<RimGridView*> visibleGridViews;
proj->allVisibleViews(visibleViews);
for (Rim3dView* view : visibleViews)
{
RimGridView* gridView = dynamic_cast<RimGridView*>(view);
if (gridView) visibleGridViews.push_back(gridView);
}
if (proj->viewLinkerCollection() && proj->viewLinkerCollection()->viewLinker())
{
proj->viewLinkerCollection()->viewLinker()->allViews(linkedviews);
}
if (visibleViews.size() >= 2 && (linkedviews.size() < visibleViews.size())) return true;
if (visibleGridViews.size() >= 2 && (linkedviews.size() < visibleGridViews.size())) return true;
return false;
}
@@ -66,7 +73,7 @@ bool RicLinkVisibleViewsFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicLinkVisibleViewsFeature::onActionTriggered(bool isChecked)
{
std::vector<Rim3dView*> views;
std::vector<RimGridView*> views;
findNotLinkedVisibleViews(views);
linkViews(views);
@@ -85,7 +92,7 @@ void RicLinkVisibleViewsFeature::setupActionLook(QAction* actionToSetup)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicLinkVisibleViewsFeature::allLinkedViews(std::vector<Rim3dView*>& views)
void RicLinkVisibleViewsFeature::allLinkedViews(std::vector<RimGridView*>& views)
{
RimProject* proj = RiaApplication::instance()->project();
if (proj->viewLinkerCollection()->viewLinker())
@@ -97,15 +104,15 @@ void RicLinkVisibleViewsFeature::allLinkedViews(std::vector<Rim3dView*>& views)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicLinkVisibleViewsFeature::findNotLinkedVisibleViews(std::vector<Rim3dView*> &views)
void RicLinkVisibleViewsFeature::findNotLinkedVisibleViews(std::vector<RimGridView*> &views)
{
RimProject* proj = RiaApplication::instance()->project();
std::vector<Rim3dView*> alreadyLinkedViews;
std::vector<RimGridView*> alreadyLinkedViews;
allLinkedViews(alreadyLinkedViews);
std::vector<Rim3dView*> visibleViews;
proj->allVisibleViews(visibleViews);
std::vector<RimGridView*> visibleViews;
proj->allVisibleGridViews(visibleViews);
for (size_t i = 0; i < visibleViews.size(); i++)
{
@@ -128,7 +135,7 @@ void RicLinkVisibleViewsFeature::findNotLinkedVisibleViews(std::vector<Rim3dView
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicLinkVisibleViewsFeature::linkViews(std::vector<Rim3dView*>& views)
void RicLinkVisibleViewsFeature::linkViews(std::vector<RimGridView*>& views)
{
RimProject* proj = RiaApplication::instance()->project();
RimViewLinker* viewLinker = proj->viewLinkerCollection->viewLinker();
@@ -149,7 +156,7 @@ void RicLinkVisibleViewsFeature::linkViews(std::vector<Rim3dView*>& views)
propertyDialog.setWindowIcon(QIcon(":/chain.png"));
if (propertyDialog.exec() != QDialog::Accepted) return;
Rim3dView* masterView = featureUi.masterView();
RimGridView* masterView = featureUi.masterView();
viewLinker = new RimViewLinker;
proj->viewLinkerCollection()->viewLinker = viewLinker;
viewLinker->setMasterView(masterView);
@@ -157,7 +164,7 @@ void RicLinkVisibleViewsFeature::linkViews(std::vector<Rim3dView*>& views)
for (size_t i = 0; i < views.size(); i++)
{
Rim3dView* rimView = views[i];
RimGridView* rimView = views[i];
if (rimView == viewLinker->masterView()) continue;
viewLinker->addDependentView(rimView);

8
ApplicationCode/Commands/ViewLink/RicLinkVisibleViewsFeature.h
View File

@@ -23,7 +23,7 @@
#include <vector>
class Rim3dView;
class RimGridView;
//==================================================================================================
///
@@ -33,7 +33,7 @@ class RicLinkVisibleViewsFeature : public caf::CmdFeature
CAF_CMD_HEADER_INIT;
public:
static void linkViews(std::vector<Rim3dView*> &views);
static void linkViews(std::vector<RimGridView*> &views);
protected:
// Overrides
@@ -44,6 +44,6 @@ protected:
virtual void setupActionLook(QAction* actionToSetup);
private:
void findNotLinkedVisibleViews(std::vector<Rim3dView*> &views);
void allLinkedViews(std::vector<Rim3dView*>& views);
void findNotLinkedVisibleViews(std::vector<RimGridView*> &views);
void allLinkedViews(std::vector<RimGridView*>& views);
};

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

@@ -40,11 +40,11 @@ RicLinkVisibleViewsFeatureUi::RicLinkVisibleViewsFeatureUi(void)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicLinkVisibleViewsFeatureUi::setViews(const std::vector<Rim3dView*>& allViews)
void RicLinkVisibleViewsFeatureUi::setViews(const std::vector<RimGridView*>& allViews)
{
m_allViews = allViews;
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
// Set Active view as master view
for (size_t i = 0; i < allViews.size(); i++)
@@ -65,7 +65,7 @@ void RicLinkVisibleViewsFeatureUi::setViews(const std::vector<Rim3dView*>& allVi
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim3dView* RicLinkVisibleViewsFeatureUi::masterView()
RimGridView* RicLinkVisibleViewsFeatureUi::masterView()
{
return m_masterView;
}
@@ -73,13 +73,14 @@ Rim3dView* RicLinkVisibleViewsFeatureUi::masterView()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QList<caf::PdmOptionItemInfo> RicLinkVisibleViewsFeatureUi::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly)
QList<caf::PdmOptionItemInfo> RicLinkVisibleViewsFeatureUi::calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions,
bool * useOptionsOnly)
{
QList<caf::PdmOptionItemInfo> options;
if (fieldNeedingOptions == &m_masterView)
{
for (Rim3dView* v : m_allViews)
for (RimGridView* v : m_allViews)
{
RimCase* rimCase = nullptr;
v->firstAncestorOrThisOfType(rimCase);

13
ApplicationCode/Commands/ViewLink/RicLinkVisibleViewsFeatureUi.h
View File

@@ -25,7 +25,7 @@
#include <vector>
class Rim3dView;
class RimGridView;
//==================================================================================================
///
@@ -37,14 +37,15 @@ class RicLinkVisibleViewsFeatureUi : public caf::PdmObject
public:
RicLinkVisibleViewsFeatureUi(void);
void setViews(const std::vector<Rim3dView*>& allViews);
Rim3dView* masterView();
void setViews(const std::vector<RimGridView*>& allViews);
RimGridView* masterView();
protected:
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions, bool * useOptionsOnly);
virtual QList<caf::PdmOptionItemInfo> calculateValueOptions(const caf::PdmFieldHandle* fieldNeedingOptions,
bool * useOptionsOnly);
private:
caf::PdmPtrField<Rim3dView*> m_masterView;
caf::PdmPtrField<RimGridView*> m_masterView;
std::vector<Rim3dView*> m_allViews;
std::vector<RimGridView*> m_allViews;
};

6
ApplicationCode/Commands/ViewLink/RicSetMasterViewFeature.cpp
View File

@@ -39,7 +39,7 @@ CAF_CMD_SOURCE_INIT(RicSetMasterViewFeature, "RicSetMasterViewFeature");
//--------------------------------------------------------------------------------------------------
bool RicSetMasterViewFeature::isCommandEnabled()
{
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
if (!activeView) return false;
RimProject* proj = RiaApplication::instance()->project();
@@ -62,7 +62,7 @@ bool RicSetMasterViewFeature::isCommandEnabled()
//--------------------------------------------------------------------------------------------------
void RicSetMasterViewFeature::onActionTriggered(bool isChecked)
{
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
if (!activeView) return;
RimProject* proj = RiaApplication::instance()->project();
@@ -70,7 +70,7 @@ void RicSetMasterViewFeature::onActionTriggered(bool isChecked)
viewLinker->applyRangeFilterCollectionByUserChoice();
Rim3dView* previousMasterView = viewLinker->masterView();
RimGridView* previousMasterView = viewLinker->masterView();
viewLinker->setMasterView(activeView);
viewLinker->updateDependentViews();

2
ApplicationCode/Commands/ViewLink/RicShowAllLinkedViewsFeature.cpp
View File

@@ -58,7 +58,7 @@ void RicShowAllLinkedViewsFeature::onActionTriggered(bool isChecked)
for (size_t i = 0; i < linkedViews.size(); i++)
{
std::vector<Rim3dView*> views;
std::vector<RimGridView*> views;
linkedViews[i]->allViews(views);
for (size_t j = 0; j < views.size(); j++)

2
ApplicationCode/GeoMech/GeoMechVisualization/RivFemElmVisibilityCalculator.cpp
View File

@@ -258,7 +258,7 @@ void RivFemElmVisibilityCalculator::computeOverriddenCellVisibility(cvf::UByteAr
CVF_ASSERT(elmVisibilities != NULL);
CVF_ASSERT(femPart != NULL);
Rim3dView* masterView = masterViewLink->ownerViewLinker()->masterView();
RimGridView* masterView = masterViewLink->ownerViewLinker()->masterView();
cvf::ref<cvf::UByteArray> totCellVisibility = masterView->currentTotalCellVisibility();
int elmCount = femPart->elementCount();

2
ApplicationCode/ModelVisualization/RivReservoirViewPartMgr.cpp
View File

@@ -604,7 +604,7 @@ void RivReservoirViewPartMgr::computeOverriddenCellVisibility(cvf::UByteArray* c
CVF_ASSERT(masterViewLink);
Rim3dView* masterView = masterViewLink->ownerViewLinker()->masterView();
RimGridView* masterView = masterViewLink->ownerViewLinker()->masterView();
// get cell visibility
#if 1

893
ApplicationCode/ProjectDataModel/Rim2dIntersectionView.cpp Normal file
View File

@@ -0,0 +1,893 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- Statoil ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#if 0
#include "Rim2dIntersectionView.h"
#include "RiaApplication.h"
#include "RiaPreferences.h"
#include "Rim3dOverlayInfoConfig.h"
#include "RimCellRangeFilterCollection.h"
#include "RimEclipseCase.h"
#include "RimEclipseView.h"
#include "RimGridCollection.h"
#include "RimIntersectionCollection.h"
#include "RimMainPlotCollection.h"
#include "RimOilField.h"
#include "RimProject.h"
#include "RimPropertyFilterCollection.h"
#include "RimViewController.h"
#include "RimViewLinker.h"
#include "RimViewLinkerCollection.h"
#include "RimWellPathCollection.h"
#include "RiuMainWindow.h"
#include "RiuViewer.h"
#include "RiuTimeStepChangedHandler.h"
#include "cafDisplayCoordTransform.h"
#include "cafFrameAnimationControl.h"
#include "cafPdmObjectFactory.h"
#include "cvfCamera.h"
#include "cvfModel.h"
#include "cvfModelBasicList.h"
#include "cvfPart.h"
#include "cvfScene.h"
#include "cvfViewport.h"
#include <QDateTime>
#include <limits.h>
#include "cvfTransform.h"
namespace caf {
template<>
void caf::AppEnum< Rim2dIntersectionView::MeshModeType >::setUp()
{
addItem(Rim2dIntersectionView::FULL_MESH, "FULL_MESH", "All");
addItem(Rim2dIntersectionView::FAULTS_MESH, "FAULTS_MESH", "Faults only");
addItem(Rim2dIntersectionView::NO_MESH, "NO_MESH", "None");
setDefault(Rim2dIntersectionView::FULL_MESH);
}
template<>
void caf::AppEnum< Rim2dIntersectionView::SurfaceModeType >::setUp()
{
addItem(Rim2dIntersectionView::SURFACE, "SURFACE", "All");
addItem(Rim2dIntersectionView::NO_SURFACE, "NO_SURFACE", "None");
setDefault(Rim2dIntersectionView::SURFACE);
}
} // End namespace caf
CAF_PDM_XML_ABSTRACT_SOURCE_INIT(Rim2dIntersectionView, "GenericView"); // Do not use. Abstract class
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dIntersectionView::Rim2dIntersectionView(void)
{
RiaApplication* app = RiaApplication::instance();
RiaPreferences* preferences = app->preferences();
CVF_ASSERT(preferences);
CAF_PDM_InitField(&name, "UserDescription", QString(""), "Name", "", "", "");
CAF_PDM_InitField(&m_cameraPosition, "CameraPosition", cvf::Mat4d::IDENTITY, "", "", "", "");
m_cameraPosition.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&m_cameraPointOfInterest, "CameraPointOfInterest", cvf::Vec3d::ZERO, "", "", "", "");
m_cameraPointOfInterest.uiCapability()->setUiHidden(true);
double defaultScaleFactor = preferences->defaultScaleFactorZ;
CAF_PDM_InitField(&scaleZ, "GridZScale", defaultScaleFactor, "Z Scale", "", "Scales the scene in the Z direction", "");
cvf::Color3f defBackgColor = preferences->defaultViewerBackgroundColor();
CAF_PDM_InitField(&m_backgroundColor, "ViewBackgroundColor", defBackgColor, "Background", "", "", "");
CAF_PDM_InitField(&maximumFrameRate, "MaximumFrameRate", 10, "Maximum Frame Rate", "", "", "");
maximumFrameRate.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&hasUserRequestedAnimation, "AnimationMode", false, "Animation Mode", "", "", "");
hasUserRequestedAnimation.uiCapability()->setUiHidden(true);
CAF_PDM_InitField(&m_currentTimeStep, "CurrentTimeStep", 0, "Current Time Step", "", "", "");
m_currentTimeStep.uiCapability()->setUiHidden(true);
//CAF_PDM_InitFieldNoDefault(&m_overlayInfoConfig, "OverlayInfoConfig", "Info Box", "", "", "");
//m_overlayInfoConfig = new Rim3dOverlayInfoConfig();
//m_overlayInfoConfig->setReservoirView(this);
//m_overlayInfoConfig.uiCapability()->setUiHidden(true);
caf::AppEnum<Rim2dIntersectionView::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", "", "", "");
CAF_PDM_InitField(&m_disableLighting, "DisableLighting", false, "Disable Results Lighting", "", "Disable light model for scalar result colors", "");
m_previousGridModeMeshLinesWasFaults = false;
m_crossSectionVizModel = new cvf::ModelBasicList;
m_crossSectionVizModel->setName("CrossSectionModel");
m_highlightVizModel = new cvf::ModelBasicList;
m_highlightVizModel->setName("HighlightModel");
m_wellPathPipeVizModel = new cvf::ModelBasicList;
m_wellPathPipeVizModel->setName("WellPathPipeModel");
this->setAs3DViewMdiWindow();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim2dIntersectionView::~Rim2dIntersectionView(void)
{
RimProject* proj = RiaApplication::instance()->project();
removeMdiWindowFromMdiArea();
deleteViewWidget();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RiuViewer* Rim2dIntersectionView::viewer()
{
return m_viewer;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QWidget* Rim2dIntersectionView::createViewWidget(QWidget* mainWindowParent)
{
QGLFormat glFormat;
glFormat.setDirectRendering(RiaApplication::instance()->useShaders());
m_viewer = new RiuViewer(glFormat, NULL);
m_viewer->setOwnerReservoirView(this);
m_viewer->showAxisCross(false);
return m_viewer->layoutWidget();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::updateViewWidgetAfterCreation()
{
m_viewer->setDefaultPerspectiveNearPlaneDistance(10);
this->resetLegendsInViewer();
m_viewer->updateNavigationPolicy();
m_viewer->enablePerfInfoHud(RiaApplication::instance()->showPerformanceInfo());
m_viewer->mainCamera()->setViewMatrix(m_cameraPosition);
m_viewer->setPointOfInterest(m_cameraPointOfInterest());
m_viewer->enableParallelProjection(true);
m_viewer->mainCamera()->viewport()->setClearColor(cvf::Color4f(backgroundColor()));
this->updateAnnotationItems();
this->createHighlightDisplayModel();
m_viewer->update();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::updateMdiWindowTitle()
{
if (m_viewer)
{
QString windowTitle;
if (ownerCase())
{
windowTitle = QString("%1 - %2").arg(ownerCase()->caseUserDescription()).arg(name);
}
else
{
windowTitle = name;
}
m_viewer->layoutWidget()->setWindowTitle(windowTitle);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::deleteViewWidget()
{
if (m_viewer)
{
m_viewer->deleteLater();
m_viewer = nullptr;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup* viewGroup = uiOrdering.addNewGroup("Viewer");
viewGroup->add(&name);
viewGroup->add(&m_backgroundColor);
viewGroup->add(&m_disableLighting);
caf::PdmUiGroup* gridGroup = uiOrdering.addNewGroup("Grid Appearance");
gridGroup->add(&scaleZ);
gridGroup->add(&meshMode);
gridGroup->add(&surfaceMode);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QImage Rim2dIntersectionView::snapshotWindowContent()
{
if (m_viewer)
{
// Force update of scheduled display models before snapshotting
RiaApplication::instance()->slotUpdateScheduledDisplayModels();
m_viewer->repaint();
return m_viewer->snapshotImage();
}
return QImage();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::scheduleCreateDisplayModelAndRedraw()
{
RiaApplication::instance()->scheduleDisplayModelUpdateAndRedraw(this);
if (this->isMasterView())
{
RimViewLinker* viewLinker = this->assosiatedViewLinker();
if (viewLinker)
{
viewLinker->scheduleCreateDisplayModelAndRedrawForDependentViews();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::setCurrentTimeStepAndUpdate(int frameIndex)
{
setCurrentTimeStep(frameIndex);
this->updateCurrentTimeStep();
RimProject* project;
firstAncestorOrThisOfTypeAsserted(project);
project->mainPlotCollection()->updateCurrentTimeStepInPlots();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString Rim2dIntersectionView::timeStepName(int frameIdx) const
{
return this->ownerCase()->timeStepName(frameIdx);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::setCurrentTimeStep(int frameIndex)
{
const int oldTimeStep = m_currentTimeStep;
m_currentTimeStep = frameIndex;
clampCurrentTimestep();
if (m_currentTimeStep != oldTimeStep)
{
RiuTimeStepChangedHandler::instance()->handleTimeStepChanged(this);
}
this->hasUserRequestedAnimation = true;
if (this->propertyFilterCollection() && this->propertyFilterCollection()->hasActiveDynamicFilters())
{
m_currentReservoirCellVisibility = NULL;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::updateCurrentTimeStepAndRedraw()
{
this->updateCurrentTimeStep();
RimProject* project;
firstAncestorOrThisOfTypeAsserted(project);
project->mainPlotCollection()->updateCurrentTimeStepInPlots();
if (m_viewer) m_viewer->update();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::createDisplayModelAndRedraw()
{
if (m_viewer)
{
this->clampCurrentTimestep();
createDisplayModel();
createHighlightDisplayModel();
updateDisplayModelVisibility();
if (m_cameraPosition().isIdentity())
{
setDefaultView();
m_cameraPosition = m_viewer->mainCamera()->viewMatrix();
m_cameraPointOfInterest = m_viewer->pointOfInterest();
}
}
RiuMainWindow::instance()->refreshAnimationActions();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::setDefaultView()
{
if (m_viewer)
{
m_viewer->setDefaultView();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::endAnimation()
{
this->hasUserRequestedAnimation = false;
this->updateStaticCellColors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimWellPathCollection* Rim2dIntersectionView::wellPathCollection()
{
RimProject* proj = nullptr;
this->firstAncestorOrThisOfTypeAsserted(proj);
CVF_ASSERT(proj && proj->activeOilField() && proj->activeOilField()->wellPathCollection());
return proj->activeOilField()->wellPathCollection();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::setupBeforeSave()
{
if (m_viewer)
{
hasUserRequestedAnimation = m_viewer->isAnimationActive(); // JJS: This is not conceptually correct. The variable is updated as we go, and store the user intentions. But I guess that in practice...
m_cameraPosition = m_viewer->mainCamera()->viewMatrix();
m_cameraPointOfInterest = m_viewer->pointOfInterest();
}
}
//--------------------------------------------------------------------------------------------------
///
// Surf: No Fault Surf
// Mesh -------------
// No F F G
// Fault F F G
// Mesh G G G
//
//--------------------------------------------------------------------------------------------------
bool Rim2dIntersectionView::isGridVisualizationMode() const
{
return ( this->surfaceMode() == SURFACE
|| this->meshMode() == FULL_MESH);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::setMeshOnlyDrawstyle()
{
if (isGridVisualizationMode())
{
meshMode.setValueWithFieldChanged(FULL_MESH);
}
else
{
meshMode.setValueWithFieldChanged(FAULTS_MESH);
}
surfaceMode.setValueWithFieldChanged(NO_SURFACE);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::setMeshSurfDrawstyle()
{
if (isGridVisualizationMode())
{
surfaceMode.setValueWithFieldChanged(SURFACE);
meshMode.setValueWithFieldChanged(FULL_MESH);
}
else
{
surfaceMode.setValueWithFieldChanged(FAULTS);
meshMode.setValueWithFieldChanged(FAULTS_MESH);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::setFaultMeshSurfDrawstyle()
{
// Surf: No Fault Surf
// Mesh -------------
// No FF FF SF
// Fault FF FF SF
// Mesh SF SF SF
if (this->isGridVisualizationMode())
{
surfaceMode.setValueWithFieldChanged(SURFACE);
}
else
{
surfaceMode.setValueWithFieldChanged(FAULTS);
}
meshMode.setValueWithFieldChanged(FAULTS_MESH);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::setSurfOnlyDrawstyle()
{
if (isGridVisualizationMode())
{
surfaceMode.setValueWithFieldChanged(SURFACE);
}
else
{
surfaceMode.setValueWithFieldChanged(FAULTS);
}
meshMode.setValueWithFieldChanged(NO_MESH);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::showGridCells(bool enableGridCells)
{
if (!enableGridCells)
{
m_previousGridModeMeshLinesWasFaults = meshMode() == FAULTS_MESH;
if (surfaceMode() != NO_SURFACE) surfaceMode.setValueWithFieldChanged(FAULTS);
if (meshMode() != NO_MESH) meshMode.setValueWithFieldChanged(FAULTS_MESH);
}
else
{
if (surfaceMode() != NO_SURFACE) surfaceMode.setValueWithFieldChanged(SURFACE);
if (meshMode() != NO_MESH) meshMode.setValueWithFieldChanged(m_previousGridModeMeshLinesWasFaults ? FAULTS_MESH : FULL_MESH);
}
m_gridCollection->isActive = enableGridCells;
m_gridCollection->updateConnectedEditors();
m_gridCollection->updateUiIconFromState(enableGridCells);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::setSurfaceDrawstyle()
{
if (surfaceMode() != NO_SURFACE) surfaceMode.setValueWithFieldChanged(SURFACE);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::disableLighting(bool disable)
{
m_disableLighting = disable;
updateCurrentTimeStepAndRedraw();
updateConnectedEditors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Rim2dIntersectionView::isLightingDisabled() const
{
return m_disableLighting();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
RimViewWindow::fieldChangedByUi(changedField, oldValue, newValue);
if (changedField == &meshMode)
{
createDisplayModel();
updateDisplayModelVisibility();
RiuMainWindow::instance()->refreshDrawStyleActions();
RiuMainWindow::instance()->refreshAnimationActions();
}
else if (changedField == &isPerspectiveView)
{
if (m_viewer) m_viewer->enableParallelProjection(!isPerspectiveView());
}
else if (changedField == &scaleZ)
{
if (scaleZ < 1) scaleZ = 1;
this->updateGridBoxData();
// Regenerate well paths
RimOilField* oilFields = RiaApplication::instance()->project() ? RiaApplication::instance()->project()->activeOilField() : NULL;
RimWellPathCollection* wellPathCollection = (oilFields) ? oilFields->wellPathCollection() : NULL;
crossSectionCollection->updateIntersectionBoxGeometry();
if (m_viewer)
{
cvf::Vec3d poi = m_viewer->pointOfInterest();
cvf::Vec3d eye, dir, up;
eye = m_viewer->mainCamera()->position();
dir = m_viewer->mainCamera()->direction();
up = m_viewer->mainCamera()->up();
eye[2] = poi[2]*scaleZ()/this->scaleTransform()->worldTransform()(2, 2) + (eye[2] - poi[2]);
poi[2] = poi[2]*scaleZ()/this->scaleTransform()->worldTransform()(2, 2);
m_viewer->mainCamera()->setFromLookAt(eye, eye + dir, up);
m_viewer->setPointOfInterest(poi);
updateScaleTransform();
createDisplayModelAndRedraw();
m_viewer->update();
RimViewLinker* viewLinker = this->assosiatedViewLinker();
if (viewLinker)
{
viewLinker->updateScaleZ(this, scaleZ);
viewLinker->updateCamera(this);
}
}
RiuMainWindow::instance()->updateScaleValue();
}
else if (changedField == &surfaceMode)
{
createDisplayModel();
updateDisplayModelVisibility();
RiuMainWindow::instance()->refreshDrawStyleActions();
RiuMainWindow::instance()->refreshAnimationActions();
}
else if (changedField == &showGridBox)
{
createHighlightAndGridBoxDisplayModelWithRedraw();
}
else if (changedField == &m_disableLighting)
{
createDisplayModel();
RiuMainWindow::instance()->refreshDrawStyleActions();
RiuMainWindow::instance()->refreshAnimationActions();
}
else if (changedField == &name)
{
updateMdiWindowTitle();
if (viewController())
{
viewController()->updateDisplayNameAndIcon();
viewController()->updateConnectedEditors();
}
else
{
if (isMasterView())
{
assosiatedViewLinker()->updateUiNameAndIcon();
assosiatedViewLinker()->updateConnectedEditors();
}
}
}
else if (changedField == &m_currentTimeStep)
{
if (m_viewer)
{
m_viewer->update();
RimViewLinker* viewLinker = this->assosiatedViewLinker();
if (viewLinker)
{
viewLinker->updateTimeStep(this, m_currentTimeStep);
}
}
}
else if (changedField == &m_backgroundColor)
{
if (m_viewer != nullptr)
{
m_viewer->mainCamera()->viewport()->setClearColor(cvf::Color4f(backgroundColor()));
}
updateGridBoxData();
updateAnnotationItems();
}
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);
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::addWellPathsToModel(cvf::ModelBasicList* wellPathModelBasicList,
const cvf::BoundingBox& wellPathClipBoundingBox)
{
if (!this->ownerCase()) return;
cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
wellPathCollection()->appendStaticGeometryPartsToModel(wellPathModelBasicList,
this->ownerCase()->characteristicCellSize(),
wellPathClipBoundingBox,
transForm.p());
wellPathModelBasicList->updateBoundingBoxesRecursive();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::addDynamicWellPathsToModel(cvf::ModelBasicList* wellPathModelBasicList, const cvf::BoundingBox& wellPathClipBoundingBox)
{
if (!this->ownerCase()) return;
cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
QDateTime currentTimeStamp;
std::vector<QDateTime> timeStamps = ownerCase()->timeStepDates();
if (currentTimeStep() < static_cast<int>(timeStamps.size()))
{
currentTimeStamp = timeStamps[currentTimeStep()];
}
wellPathCollection()->appendDynamicGeometryPartsToModel(wellPathModelBasicList,
currentTimeStamp,
this->ownerCase()->characteristicCellSize(),
wellPathClipBoundingBox,
transForm.p());
wellPathModelBasicList->updateBoundingBoxesRecursive();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::setScaleZAndUpdate(double scaleZ)
{
this->scaleZ = scaleZ;
updateScaleTransform();
this->updateGridBoxData();
this->scheduleCreateDisplayModelAndRedraw();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimViewLinker* Rim2dIntersectionView::viewLinkerIfMasterView() const
{
RimViewLinker* viewLinker = NULL;
std::vector<caf::PdmObjectHandle*> reffingObjs;
this->objectsWithReferringPtrFields(reffingObjs);
for (size_t i = 0; i < reffingObjs.size(); ++i)
{
viewLinker = dynamic_cast<RimViewLinker*>(reffingObjs[i]);
if (viewLinker) break;
}
return viewLinker;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::updateAnnotationItems()
{
if (m_viewer)
{
m_viewer->updateAnnotationItems();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
//Rim3dOverlayInfoConfig* Rim2dIntersectionView::overlayInfoConfig() const
//{
// return m_overlayInfoConfig;
//}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::createHighlightDisplayModelWithRedraw()
{
createHighlightDisplayModel();
if (m_viewer)
{
m_viewer->update();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::createHighlightDisplayModel()
{
m_viewer->removeStaticModel(m_highlightVizModel.p());
m_highlightVizModel->removeAllParts();
cvf::Collection<cvf::Part> parts;
createPartCollectionFromSelection(&parts);
if (parts.size() > 0)
{
for (size_t i = 0; i < parts.size(); i++)
{
m_highlightVizModel->addPart(parts[i].p());
}
m_highlightVizModel->updateBoundingBoxesRecursive();
m_viewer->addStaticModelOnce(m_highlightVizModel.p());
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Rim2dIntersectionView::showActiveCellsOnly()
{
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::selectOverlayInfoConfig()
{
//RiuMainWindow::instance()->selectAsCurrentItem(m_overlayInfoConfig);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::zoomAll()
{
if (m_viewer)
{
m_viewer->zoomAll();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<caf::DisplayCoordTransform> Rim2dIntersectionView::displayCoordTransform() const
{
cvf::ref<caf::DisplayCoordTransform> coordTrans = new caf::DisplayCoordTransform;
cvf::Vec3d scale(1.0, 1.0, scaleZ);
coordTrans->setScale(scale);
RimCase* rimCase = ownerCase();
if (rimCase)
{
coordTrans->setTranslation(rimCase->displayModelOffset());
}
return coordTrans;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QWidget* Rim2dIntersectionView::viewWidget()
{
if ( m_viewer ) return m_viewer->layoutWidget();
else return nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::forceShowWindowOn()
{
m_showWindow.setValueWithFieldChanged(true);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::handleMdiWindowClosed()
{
RimViewWindow::handleMdiWindowClosed();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim2dIntersectionView::setMdiWindowGeometry(const RimMdiWindowGeometry& windowGeometry)
{
RimViewWindow::setMdiWindowGeometry(windowGeometry);
}
#endif

211
ApplicationCode/ProjectDataModel/Rim2dIntersectionView.h Normal file
View File

@@ -0,0 +1,211 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- Statoil ASA
//
// ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
// WARRANTY; without even the implied warranty of MERCHANTABILITY or
// FITNESS FOR A PARTICULAR PURPOSE.
//
// See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
// for more details.
//
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RiuViewerToViewInterface.h"
#include "RimViewWindow.h"
#include "cafAppEnum.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmChildField.h"
#include "cafPdmField.h"
#include "cafPdmFieldCvfColor.h"
#include "cafPdmFieldCvfMat4d.h"
#include "cafPdmFieldCvfVec3d.h"
#include "cafPdmObject.h"
#include "RivCellSetEnum.h"
#include "cvfArray.h"
#include "cvfBase.h"
#include "cvfCollection.h"
#include "cvfObject.h"
#include <QPointer>
class Rim3dOverlayInfoConfig;
class RimCase;
class RimCellRangeFilter;
class RimCellRangeFilterCollection;
class RimIntersectionCollection;
class RimGridCollection;
class RimPropertyFilterCollection;
class RimViewController;
class RimViewLinker;
class RiuViewer;
class RimWellPathCollection;
namespace cvf
{
class BoundingBox;
class ModelBasicList;
class Scene;
class String;
class Transform;
class Part;
}
namespace caf
{
class DisplayCoordTransform;
}
//==================================================================================================
///
///
//==================================================================================================
class Rim2dIntersectionView : public RimViewWindow, public RiuViewerToViewInterface
{
CAF_PDM_HEADER_INIT;
public:
Rim2dIntersectionView(void);
virtual ~Rim2dIntersectionView(void);
// Public fields:
caf::PdmField<QString> name;
caf::PdmField<double> scaleZ;
caf::PdmField<int> maximumFrameRate;
caf::PdmField<bool> hasUserRequestedAnimation;
// Draw style
enum MeshModeType { FULL_MESH, FAULTS_MESH, NO_MESH };
enum SurfaceModeType { SURFACE, NO_SURFACE };
caf::PdmField< caf::AppEnum< MeshModeType > > meshMode;
caf::PdmField< caf::AppEnum< SurfaceModeType > > surfaceMode;
RiuViewer* viewer();
void setMeshOnlyDrawstyle();
void setMeshSurfDrawstyle();
void setSurfOnlyDrawstyle();
void setFaultMeshSurfDrawstyle();
void setSurfaceDrawstyle();
void disableLighting(bool disable);
bool isLightingDisabled() const;
void showGridCells(bool enableGridCells);
bool isGridVisualizationMode() const;
void setScaleZAndUpdate(double scaleZ);
virtual bool showActiveCellsOnly();
virtual bool isUsingFormationNames() const = 0;
virtual QImage snapshotWindowContent() override;
virtual void zoomAll() override;
void forceShowWindowOn();
// Animation
int currentTimeStep() const { return m_currentTimeStep;}
void setCurrentTimeStep(int frameIdx);
void setCurrentTimeStepAndUpdate(int frameIdx) override;
// Updating
void updateCurrentTimeStepAndRedraw() override;
virtual void scheduleGeometryRegen(RivCellSetEnum geometryType) = 0;
void scheduleCreateDisplayModelAndRedraw();
void createDisplayModelAndRedraw();
void createHighlightDisplayModelWithRedraw();
void updateAnnotationItems();
cvf::ref<caf::DisplayCoordTransform> displayCoordTransform() const override;
virtual RimCase* ownerCase() const = 0;
//Rim3dOverlayInfoConfig* overlayInfoConfig() const;
protected:
void setDefaultView();
RimWellPathCollection* wellPathCollection();
void addWellPathsToModel(cvf::ModelBasicList* wellPathModelBasicList,
const cvf::BoundingBox& wellPathClipBoundingBox);
void addDynamicWellPathsToModel(cvf::ModelBasicList* wellPathModelBasicList,
const cvf::BoundingBox& wellPathClipBoundingBox);
void createHighlightDisplayModel();
// Abstract methods to implement in subclasses
virtual void createDisplayModel() = 0;
virtual void createPartCollectionFromSelection(cvf::Collection<cvf::Part>* parts) = 0;
virtual void updateDisplayModelVisibility() = 0;
virtual void clampCurrentTimestep() = 0;
virtual void updateCurrentTimeStep() = 0;
virtual void updateStaticCellColors() = 0;
virtual void updateScaleTransform() = 0;
virtual cvf::Transform* scaleTransform() = 0;
virtual void resetLegendsInViewer() = 0;
// Overridden PdmObject methods:
virtual caf::PdmFieldHandle* userDescriptionField() override { return &name; }
virtual void setupBeforeSave() override;
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
virtual void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
// Overridden ViewWindow methods:
virtual QWidget* createViewWidget(QWidget* mainWindowParent) override;
virtual void updateViewWidgetAfterCreation() override;
virtual void updateMdiWindowTitle() override;
virtual void deleteViewWidget() override;
virtual QWidget* viewWidget() override;
protected: // Fields
caf::PdmField<int> m_currentTimeStep;
//caf::PdmChildField<Rim3dOverlayInfoConfig*> m_overlayInfoConfig;
protected:
QPointer<RiuViewer> m_viewer;
cvf::ref<cvf::ModelBasicList> m_wellPathPipeVizModel;
cvf::ref<cvf::ModelBasicList> m_crossSectionVizModel;
cvf::ref<cvf::ModelBasicList> m_highlightVizModel;
private:
// Implementation of RiuViewerToViewInterface
virtual cvf::Color3f backgroundColor() const override { return m_backgroundColor();}
virtual void setCameraPosition(const cvf::Mat4d& cameraPosition) override { m_cameraPosition = cameraPosition; }
virtual void setCameraPointOfInterest(const cvf::Vec3d& cameraPointOfInterest) override { m_cameraPointOfInterest = cameraPointOfInterest;}
virtual QString timeStepName(int frameIdx) const override;
virtual void endAnimation() override;
virtual caf::PdmObjectHandle* implementingPdmObject() override { return this; }
virtual void handleMdiWindowClosed() override;
virtual void setMdiWindowGeometry(const RimMdiWindowGeometry& windowGeometry) override;
virtual void selectOverlayInfoConfig() override;
private:
bool m_previousGridModeMeshLinesWasFaults;
caf::PdmField<bool> m_disableLighting;
caf::PdmField<cvf::Mat4d> m_cameraPosition;
caf::PdmField<cvf::Vec3d> m_cameraPointOfInterest;
caf::PdmField< cvf::Color3f > m_backgroundColor;
};

2
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.cpp
View File

@@ -738,7 +738,7 @@ void Rim3dOverlayInfoConfig::defineUiOrdering(QString uiConfigName, caf::PdmUiOr
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim3dOverlayInfoConfig::setReservoirView(Rim3dView* ownerReservoirView)
void Rim3dOverlayInfoConfig::setReservoirView(RimGridView* ownerReservoirView)
{
m_viewDef = ownerReservoirView;
}

6
ApplicationCode/ProjectDataModel/Rim3dOverlayInfoConfig.h
View File

@@ -32,7 +32,7 @@
class RimEclipseView;
class RimGeoMechView;
class Rim3dView;
class RimGridView;
class RigStatisticsDataCache;
class RicGridStatisticsDialog;
@@ -67,7 +67,7 @@ public:
void update3DInfo();
void setReservoirView(Rim3dView* ownerView);
void setReservoirView(RimGridView* ownerView);
void setPosition(cvf::Vec2ui position);
@@ -120,7 +120,7 @@ private:
caf::PdmField<caf::AppEnum<StatisticsTimeRangeType> > m_statisticsTimeRange;
caf::PdmField<caf::AppEnum<StatisticsCellRangeType> > m_statisticsCellRange;
caf::PdmPointer<Rim3dView> m_viewDef;
caf::PdmPointer<RimGridView> m_viewDef;
cvf::Vec2ui m_position;

433
ApplicationCode/ProjectDataModel/Rim3dView.cpp
View File

@@ -118,11 +118,6 @@ Rim3dView::Rim3dView(void)
CAF_PDM_InitField(&m_currentTimeStep, "CurrentTimeStep", 0, "Current Time Step", "", "", "");
m_currentTimeStep.uiCapability()->setUiHidden(true);
CAF_PDM_InitFieldNoDefault(&m_overlayInfoConfig, "OverlayInfoConfig", "Info Box", "", "", "");
m_overlayInfoConfig = new Rim3dOverlayInfoConfig();
m_overlayInfoConfig->setReservoirView(this);
m_overlayInfoConfig.uiCapability()->setUiHidden(true);
caf::AppEnum<Rim3dView::MeshModeType> defaultMeshType = NO_MESH;
if (preferences->defaultGridLines) defaultMeshType = FULL_MESH;
CAF_PDM_InitField(&meshMode, "MeshMode", defaultMeshType, "Grid Lines", "", "", "");
@@ -132,26 +127,6 @@ Rim3dView::Rim3dView(void)
CAF_PDM_InitField(&m_disableLighting, "DisableLighting", false, "Disable Results Lighting", "", "Disable light model for scalar result colors", "");
CAF_PDM_InitFieldNoDefault(&m_rangeFilterCollection, "RangeFilters", "Range Filters", "", "", "");
m_rangeFilterCollection.uiCapability()->setUiHidden(true);
m_rangeFilterCollection = new RimCellRangeFilterCollection();
CAF_PDM_InitFieldNoDefault(&m_overrideRangeFilterCollection, "RangeFiltersControlled", "Range Filters (controlled)", "", "", "");
m_overrideRangeFilterCollection.uiCapability()->setUiHidden(true);
m_overrideRangeFilterCollection.xmlCapability()->setIOWritable(false);
m_overrideRangeFilterCollection.xmlCapability()->setIOReadable(false);
CAF_PDM_InitFieldNoDefault(&crossSectionCollection, "CrossSections", "Intersections", "", "", "");
crossSectionCollection.uiCapability()->setUiHidden(true);
crossSectionCollection = new RimIntersectionCollection();
CAF_PDM_InitFieldNoDefault(&m_gridCollection, "GridCollection", "GridCollection", "", "", "");
m_gridCollection.uiCapability()->setUiHidden(true);
m_gridCollection = new RimGridCollection();
m_previousGridModeMeshLinesWasFaults = false;
m_crossSectionVizModel = new cvf::ModelBasicList;
m_crossSectionVizModel->setName("CrossSectionModel");
@@ -169,36 +144,9 @@ Rim3dView::Rim3dView(void)
//--------------------------------------------------------------------------------------------------
Rim3dView::~Rim3dView(void)
{
RimProject* proj = RiaApplication::instance()->project();
if (proj && this->isMasterView())
{
delete proj->viewLinkerCollection->viewLinker();
proj->viewLinkerCollection->viewLinker = NULL;
proj->uiCapability()->updateConnectedEditors();
}
RimViewController* vController = this->viewController();
if (proj && vController)
{
vController->setManagedView(NULL);
vController->ownerViewLinker()->removeViewController(vController);
delete vController;
proj->uiCapability()->updateConnectedEditors();
}
delete this->m_overlayInfoConfig();
removeMdiWindowFromMdiArea();
deleteViewWidget();
delete m_rangeFilterCollection;
delete m_overrideRangeFilterCollection;
delete crossSectionCollection;
delete m_gridCollection;
}
//--------------------------------------------------------------------------------------------------
@@ -230,7 +178,6 @@ QWidget* Rim3dView::createViewWidget(QWidget* mainWindowParent)
return m_viewer->layoutWidget();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -277,7 +224,6 @@ void Rim3dView::updateMdiWindowTitle()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -306,8 +252,6 @@ void Rim3dView::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrd
gridGroup->add(&scaleZ);
gridGroup->add(&meshMode);
gridGroup->add(&surfaceMode);
}
//--------------------------------------------------------------------------------------------------
@@ -379,13 +323,11 @@ void Rim3dView::setCurrentTimeStep(int frameIndex)
if (m_currentTimeStep != oldTimeStep)
{
RiuTimeStepChangedHandler::instance()->handleTimeStepChanged(this);
this->onTimeStepChanged();
}
this->hasUserRequestedAnimation = true;
if (this->propertyFilterCollection() && this->propertyFilterCollection()->hasActiveDynamicFilters())
{
m_currentReservoirCellVisibility = NULL;
}
}
//--------------------------------------------------------------------------------------------------
@@ -426,7 +368,6 @@ void Rim3dView::createDisplayModelAndRedraw()
RiuMainWindow::instance()->refreshAnimationActions();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -438,7 +379,6 @@ void Rim3dView::setDefaultView()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -448,7 +388,6 @@ void Rim3dView::endAnimation()
this->updateStaticCellColors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -489,7 +428,6 @@ bool Rim3dView::isGridVisualizationMode() const
|| this->meshMode() == FULL_MESH);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -563,28 +501,6 @@ void Rim3dView::setSurfOnlyDrawstyle()
meshMode.setValueWithFieldChanged(NO_MESH);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim3dView::showGridCells(bool enableGridCells)
{
if (!enableGridCells)
{
m_previousGridModeMeshLinesWasFaults = meshMode() == FAULTS_MESH;
if (surfaceMode() != NO_SURFACE) surfaceMode.setValueWithFieldChanged(FAULTS);
if (meshMode() != NO_MESH) meshMode.setValueWithFieldChanged(FAULTS_MESH);
}
else
{
if (surfaceMode() != NO_SURFACE) surfaceMode.setValueWithFieldChanged(SURFACE);
if (meshMode() != NO_MESH) meshMode.setValueWithFieldChanged(m_previousGridModeMeshLinesWasFaults ? FAULTS_MESH : FULL_MESH);
}
m_gridCollection->isActive = enableGridCells;
m_gridCollection->updateConnectedEditors();
m_gridCollection->updateUiIconFromState(enableGridCells);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -634,7 +550,6 @@ void Rim3dView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const
if (scaleZ < 1) scaleZ = 1;
this->updateGridBoxData();
crossSectionCollection->updateIntersectionBoxGeometry();
if (m_viewer)
{
@@ -655,12 +570,7 @@ void Rim3dView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const
m_viewer->update();
RimViewLinker* viewLinker = this->assosiatedViewLinker();
if (viewLinker)
{
viewLinker->updateScaleZ(this, scaleZ);
viewLinker->updateCamera(this);
}
}
RiuMainWindow::instance()->updateScaleValue();
@@ -706,11 +616,7 @@ void Rim3dView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const
{
m_viewer->update();
RimViewLinker* viewLinker = this->assosiatedViewLinker();
if (viewLinker)
{
viewLinker->updateTimeStep(this, m_currentTimeStep);
}
}
}
else if (changedField == &m_backgroundColor)
@@ -776,50 +682,6 @@ void Rim3dView::addDynamicWellPathsToModel(cvf::ModelBasicList* wellPathModelBas
wellPathModelBasicList->updateBoundingBoxesRecursive();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimCellRangeFilterCollection* Rim3dView::rangeFilterCollection()
{
if (this->viewController() && this->viewController()->isRangeFiltersControlled() && m_overrideRangeFilterCollection)
{
return m_overrideRangeFilterCollection;
}
else
{
return m_rangeFilterCollection;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const RimCellRangeFilterCollection* Rim3dView::rangeFilterCollection() const
{
if (this->viewController() && this->viewController()->isRangeFiltersControlled() && m_overrideRangeFilterCollection)
{
return m_overrideRangeFilterCollection;
}
else
{
return m_rangeFilterCollection;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim3dView::setOverrideRangeFilterCollection(RimCellRangeFilterCollection* rfc)
{
if (m_overrideRangeFilterCollection()) delete m_overrideRangeFilterCollection();
m_overrideRangeFilterCollection = rfc;
this->scheduleGeometryRegen(RANGE_FILTERED);
this->scheduleGeometryRegen(RANGE_FILTERED_INACTIVE);
this->scheduleCreateDisplayModelAndRedraw();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -833,75 +695,6 @@ void Rim3dView::setScaleZAndUpdate(double scaleZ)
this->scheduleCreateDisplayModelAndRedraw();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimViewController* Rim3dView::viewController() const
{
RimViewController* viewController = NULL;
std::vector<caf::PdmObjectHandle*> reffingObjs;
this->objectsWithReferringPtrFields(reffingObjs);
for (size_t i = 0; i < reffingObjs.size(); ++i)
{
viewController = dynamic_cast<RimViewController*>(reffingObjs[i]);
if (viewController) break;
}
return viewController;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimViewLinker* Rim3dView::viewLinkerIfMasterView() const
{
RimViewLinker* viewLinker = NULL;
std::vector<caf::PdmObjectHandle*> reffingObjs;
this->objectsWithReferringPtrFields(reffingObjs);
for (size_t i = 0; i < reffingObjs.size(); ++i)
{
viewLinker = dynamic_cast<RimViewLinker*>(reffingObjs[i]);
if (viewLinker) break;
}
return viewLinker;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimViewLinker* Rim3dView::assosiatedViewLinker() const
{
RimViewLinker* viewLinker = this->viewLinkerIfMasterView();
if (!viewLinker)
{
RimViewController* viewController = this->viewController();
if (viewController)
{
viewLinker = viewController->ownerViewLinker();
}
}
return viewLinker;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::ref<cvf::UByteArray> Rim3dView::currentTotalCellVisibility()
{
if (m_currentReservoirCellVisibility.isNull())
{
m_currentReservoirCellVisibility = new cvf::UByteArray;
this->calculateCurrentTotalCellVisibility(m_currentReservoirCellVisibility.p(), m_currentTimeStep());
}
return m_currentReservoirCellVisibility;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -916,57 +709,6 @@ bool Rim3dView::isMasterView() const
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Rim3dView::hasOverridenRangeFilterCollection()
{
return m_overrideRangeFilterCollection() != NULL;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim3dView::replaceRangeFilterCollectionWithOverride()
{
RimCellRangeFilterCollection* overrideRfc = m_overrideRangeFilterCollection;
CVF_ASSERT(overrideRfc);
RimCellRangeFilterCollection* currentRfc = m_rangeFilterCollection;
if (currentRfc)
{
delete currentRfc;
}
// Must call removeChildObject() to make sure the object has no parent
// No parent is required when assigning a object into a field
m_overrideRangeFilterCollection.removeChildObject(overrideRfc);
m_rangeFilterCollection = overrideRfc;
this->uiCapability()->updateConnectedEditors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim3dView::removeModelByName(cvf::Scene* scene, const cvf::String& modelName)
{
std::vector<cvf::Model*> modelsToBeRemoved;
for (cvf::uint i = 0; i < scene->modelCount(); i++)
{
if (scene->model(i)->name() == modelName)
{
modelsToBeRemoved.push_back(scene->model(i));
}
}
for (size_t i = 0; i < modelsToBeRemoved.size(); i++)
{
scene->removeModel(modelsToBeRemoved[i]);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -994,14 +736,6 @@ void Rim3dView::updateAnnotationItems()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim3dOverlayInfoConfig* Rim3dView::overlayInfoConfig() const
{
return m_overlayInfoConfig;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1048,14 +782,6 @@ bool Rim3dView::showActiveCellsOnly()
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void Rim3dView::selectOverlayInfoConfig()
{
RiuMainWindow::instance()->selectAsCurrentItem(m_overlayInfoConfig);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1137,7 +863,7 @@ CAF_PDM_XML_ABSTRACT_SOURCE_INIT(RimGridView, "GenericGridView"); // Do not use.
//--------------------------------------------------------------------------------------------------
RimGridView::RimGridView()
{
#if 0
CAF_PDM_InitFieldNoDefault(&m_rangeFilterCollection, "RangeFilters", "Range Filters", "", "", "");
m_rangeFilterCollection.uiCapability()->setUiHidden(true);
m_rangeFilterCollection = new RimCellRangeFilterCollection();
@@ -1161,7 +887,6 @@ RimGridView::RimGridView()
m_overlayInfoConfig = new Rim3dOverlayInfoConfig();
m_overlayInfoConfig->setReservoirView(this);
m_overlayInfoConfig.uiCapability()->setUiHidden(true);
#endif
}
//--------------------------------------------------------------------------------------------------
@@ -1169,16 +894,33 @@ RimGridView::RimGridView()
//--------------------------------------------------------------------------------------------------
RimGridView::~RimGridView(void)
{
#if 0
RimProject* proj = RiaApplication::instance()->project();
if (proj && this->isMasterView())
{
delete proj->viewLinkerCollection->viewLinker();
proj->viewLinkerCollection->viewLinker = NULL;
proj->uiCapability()->updateConnectedEditors();
}
RimViewController* vController = this->viewController();
if (proj && vController)
{
vController->setManagedView(NULL);
vController->ownerViewLinker()->removeViewController(vController);
delete vController;
proj->uiCapability()->updateConnectedEditors();
}
delete this->m_overlayInfoConfig();
delete m_rangeFilterCollection;
delete m_overrideRangeFilterCollection;
delete crossSectionCollection;
delete m_gridCollection;
#endif
}
#if 0
//--------------------------------------------------------------------------------------------------
///
@@ -1202,34 +944,6 @@ void RimGridView::showGridCells(bool enableGridCells)
m_gridCollection->updateUiIconFromState(enableGridCells);
}
//--------------------------------------------------------------------------------------------------
///
// Surf: No Fault Surf
// Mesh -------------
// No F F G
// Fault F F G
// Mesh G G G
//
//--------------------------------------------------------------------------------------------------
bool RimGridView::isGridVisualizationMode() const
{
return ( this->surfaceMode() == SURFACE
|| this->meshMode() == FULL_MESH);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
if (changedField == &scaleZ)
{
crossSectionCollection->updateIntersectionBoxGeometry();
}
Rim3dView::fieldChangedByUi(changedField, oldValue, newValue);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1243,6 +957,7 @@ cvf::ref<cvf::UByteArray> RimGridView::currentTotalCellVisibility()
return m_currentReservoirCellVisibility;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1276,7 +991,7 @@ const RimCellRangeFilterCollection* RimGridView::rangeFilterCollection() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool Rim3dView::hasOverridenRangeFilterCollection()
bool RimGridView::hasOverridenRangeFilterCollection()
{
return m_overrideRangeFilterCollection() != NULL;
}
@@ -1335,21 +1050,6 @@ RimViewController* RimGridView::viewController() const
return viewController;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimGridView::isMasterView() const
{
RimViewLinker* viewLinker = this->assosiatedViewLinker();
if (viewLinker && this == viewLinker->masterView())
{
return true;
}
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1376,16 +1076,6 @@ Rim3dOverlayInfoConfig* RimGridView::overlayInfoConfig() const
return m_overlayInfoConfig;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridView::selectOverlayInfoConfig()
{
RiuMainWindow::instance()->selectAsCurrentItem(m_overlayInfoConfig);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1406,4 +1096,71 @@ void RimGridView::removeModelByName(cvf::Scene* scene, const cvf::String& modelN
}
}
#endif
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridView::onTimeStepChanged()
{
if (this->propertyFilterCollection() && this->propertyFilterCollection()->hasActiveDynamicFilters())
{
m_currentReservoirCellVisibility = NULL;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridView::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
if ( changedField == &scaleZ )
{
crossSectionCollection->updateIntersectionBoxGeometry();
}
Rim3dView::fieldChangedByUi(changedField, oldValue, newValue);
if ( changedField == &scaleZ )
{
RimViewLinker* viewLinker = this->assosiatedViewLinker();
if ( viewLinker )
{
viewLinker->updateScaleZ(this, scaleZ);
viewLinker->updateCamera(this);
}
}
else if ( changedField == &m_currentTimeStep )
{
RimViewLinker* viewLinker = this->assosiatedViewLinker();
if ( viewLinker )
{
viewLinker->updateTimeStep(this, m_currentTimeStep);
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimGridView::selectOverlayInfoConfig()
{
RiuMainWindow::instance()->selectAsCurrentItem(m_overlayInfoConfig);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimViewLinker* RimGridView::viewLinkerIfMasterView() const
{
RimViewLinker* viewLinker = NULL;
std::vector<caf::PdmObjectHandle*> reffingObjs;
this->objectsWithReferringPtrFields(reffingObjs);
for (size_t i = 0; i < reffingObjs.size(); ++i)
{
viewLinker = dynamic_cast<RimViewLinker*>(reffingObjs[i]);
if (viewLinker) break;
}
return viewLinker;
}

42
ApplicationCode/ProjectDataModel/Rim3dView.h
View File

@@ -93,8 +93,6 @@ public:
caf::PdmField< caf::AppEnum< MeshModeType > > meshMode;
caf::PdmField< caf::AppEnum< SurfaceModeType > > surfaceMode;
caf::PdmChildField<RimIntersectionCollection*> crossSectionCollection;
RiuViewer* viewer();
void setMeshOnlyDrawstyle();
@@ -105,14 +103,12 @@ public:
void disableLighting(bool disable);
bool isLightingDisabled() const;
void showGridCells(bool enableGridCells);
bool isGridVisualizationMode() const;
void setScaleZAndUpdate(double scaleZ);
virtual bool showActiveCellsOnly();
virtual bool isUsingFormationNames() const = 0;
cvf::ref<cvf::UByteArray> currentTotalCellVisibility();
virtual QImage snapshotWindowContent() override;
virtual void zoomAll() override;
@@ -132,22 +128,11 @@ public:
void updateGridBoxData();
void updateAnnotationItems();
virtual const RimPropertyFilterCollection* propertyFilterCollection() const = 0;
RimCellRangeFilterCollection* rangeFilterCollection();
const RimCellRangeFilterCollection* rangeFilterCollection() const;
bool hasOverridenRangeFilterCollection();
void setOverrideRangeFilterCollection(RimCellRangeFilterCollection* rfc);
void replaceRangeFilterCollectionWithOverride();
RimViewController* viewController() const override;
bool isMasterView() const;
RimViewLinker* assosiatedViewLinker() const override;
cvf::ref<caf::DisplayCoordTransform> displayCoordTransform() const override;
virtual RimCase* ownerCase() const = 0;
Rim3dOverlayInfoConfig* overlayInfoConfig() const;
protected:
@@ -160,8 +145,6 @@ protected:
void addDynamicWellPathsToModel(cvf::ModelBasicList* wellPathModelBasicList,
const cvf::BoundingBox& wellPathClipBoundingBox);
static void removeModelByName(cvf::Scene* scene, const cvf::String& modelName);
void createHighlightAndGridBoxDisplayModel();
// Abstract methods to implement in subclasses
@@ -175,35 +158,25 @@ protected:
virtual void clampCurrentTimestep() = 0;
virtual void updateCurrentTimeStep() = 0;
virtual void onTimeStepChanged() = 0;
virtual void updateStaticCellColors() = 0;
virtual void updateScaleTransform() = 0;
virtual cvf::Transform* scaleTransform() = 0;
virtual void resetLegendsInViewer() = 0;
virtual void calculateCurrentTotalCellVisibility(cvf::UByteArray* totalVisibility, int timeStep) = 0;
protected: // Fields
caf::PdmField<int> m_currentTimeStep;
caf::PdmChildField<Rim3dOverlayInfoConfig*> m_overlayInfoConfig;
caf::PdmChildField<RimCellRangeFilterCollection*> m_rangeFilterCollection;
caf::PdmChildField<RimCellRangeFilterCollection*> m_overrideRangeFilterCollection;
caf::PdmChildField<RimGridCollection*> m_gridCollection;
protected:
QPointer<RiuViewer> m_viewer;
cvf::ref<cvf::UByteArray> m_currentReservoirCellVisibility;
cvf::ref<cvf::ModelBasicList> m_wellPathPipeVizModel;
cvf::ref<cvf::ModelBasicList> m_crossSectionVizModel;
cvf::ref<cvf::ModelBasicList> m_highlightVizModel;
private:
RimViewLinker* viewLinkerIfMasterView() const;
// Overridden PdmObject methods:
virtual caf::PdmFieldHandle* userDescriptionField() override { return &name; }
@@ -231,10 +204,8 @@ private:
virtual caf::PdmObjectHandle* implementingPdmObject() override { return this; }
virtual void handleMdiWindowClosed() override;
virtual void setMdiWindowGeometry(const RimMdiWindowGeometry& windowGeometry) override;
virtual void selectOverlayInfoConfig() override;
private:
bool m_previousGridModeMeshLinesWasFaults;
caf::PdmField<bool> m_disableLighting;
caf::PdmField<cvf::Mat4d> m_cameraPosition;
caf::PdmField<cvf::Vec3d> m_cameraPointOfInterest;
@@ -249,12 +220,11 @@ class RimGridView : public Rim3dView
public:
RimGridView();
virtual ~RimGridView(void);
#if 0
#if 1
caf::PdmChildField<RimIntersectionCollection*> crossSectionCollection;
void showGridCells(bool enableGridCells);
bool isGridVisualizationMode() const;
cvf::ref<cvf::UByteArray> currentTotalCellVisibility();
@@ -267,14 +237,14 @@ public:
void replaceRangeFilterCollectionWithOverride();
RimViewController* viewController() const override;
bool isMasterView() const;
RimViewLinker* assosiatedViewLinker() const override;
Rim3dOverlayInfoConfig* overlayInfoConfig() const;
protected:
static void removeModelByName(cvf::Scene* scene, const cvf::String& modelName);
virtual void axisLabels(cvf::String* xLabel, cvf::String* yLabel, cvf::String* zLabel) = 0;
virtual void onTimeStepChanged() override;
virtual void calculateCurrentTotalCellVisibility(cvf::UByteArray* totalVisibility, int timeStep) = 0;
virtual void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;

2
ApplicationCode/ProjectDataModel/RimGridCollection.cpp
View File

@@ -57,7 +57,7 @@ void RimGridCollection::fieldChangedByUi(const caf::PdmFieldHandle* changedField
{
if (changedField == &isActive)
{
Rim3dView* rimView = NULL;
RimGridView* rimView = NULL;
this->firstAncestorOrThisOfType(rimView);
CVF_ASSERT(rimView);

26
ApplicationCode/ProjectDataModel/RimProject.cpp
View File

@@ -598,12 +598,12 @@ std::vector<RimSummaryCase*> RimProject::allSummaryCases() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimProject::allNotLinkedViews(std::vector<Rim3dView*>& views)
void RimProject::allNotLinkedViews(std::vector<RimGridView*>& views)
{
std::vector<RimCase*> cases;
allCases(cases);
std::vector<Rim3dView*> alreadyLinkedViews;
std::vector<RimGridView*> alreadyLinkedViews;
if (viewLinkerCollection->viewLinker())
{
viewLinkerCollection->viewLinker()->allViews(alreadyLinkedViews);
@@ -617,17 +617,21 @@ void RimProject::allNotLinkedViews(std::vector<Rim3dView*>& views)
std::vector<Rim3dView*> caseViews = rimCase->views();
for (size_t viewIdx = 0; viewIdx < caseViews.size(); viewIdx++)
{
RimGridView* gridView = dynamic_cast<RimGridView*>(caseViews[viewIdx]);
if (!gridView) continue;
bool isLinked = false;
for (size_t lnIdx = 0; lnIdx < alreadyLinkedViews.size(); lnIdx++)
{
if (caseViews[viewIdx] == alreadyLinkedViews[lnIdx])
if (gridView == alreadyLinkedViews[lnIdx])
{
isLinked = true;
}
}
if (!isLinked)
{
views.push_back(caseViews[viewIdx]);
views.push_back(gridView);
}
}
}
@@ -657,6 +661,20 @@ void RimProject::allVisibleViews(std::vector<Rim3dView*>& views)
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimProject::allVisibleGridViews(std::vector<RimGridView*>& views)
{
std::vector<Rim3dView*> visibleViews;
this->allVisibleViews(visibleViews);
for ( Rim3dView* view : visibleViews )
{
RimGridView* gridView = dynamic_cast<RimGridView*>(view);
if ( gridView ) views.push_back(gridView);
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

4
ApplicationCode/ProjectDataModel/RimProject.h
View File

@@ -48,6 +48,7 @@ class RimOilField;
class RimScriptCollection;
class RimSummaryCase;
class Rim3dView;
class RimGridView;
class RimViewLinker;
class RimViewLinkerCollection;
class RimWellPath;
@@ -106,8 +107,9 @@ public:
std::vector<RimSummaryCase*> allSummaryCases() const;
void allNotLinkedViews(std::vector<Rim3dView*>& views);
void allVisibleViews(std::vector<Rim3dView*>& views);
void allVisibleGridViews(std::vector<RimGridView*>& views);
void allNotLinkedViews(std::vector<RimGridView*>& views);
void createDisplayModelAndRedrawAllViews();

24
ApplicationCode/ProjectDataModel/RimViewController.cpp
View File

@@ -101,7 +101,7 @@ QList<caf::PdmOptionItemInfo> RimViewController::calculateValueOptions(const caf
if (fieldNeedingOptions == &m_managedView)
{
RimProject* proj = RiaApplication::instance()->project();
std::vector<Rim3dView*> views;
std::vector<RimGridView*> views;
proj->allNotLinkedViews(views);
// Add currently linked view to list
@@ -114,7 +114,7 @@ QList<caf::PdmOptionItemInfo> RimViewController::calculateValueOptions(const caf
this->firstAncestorOrThisOfType(viewLinker);
CVF_ASSERT(viewLinker);
for (Rim3dView* view : views)
for (RimGridView* view : views)
{
if (view != viewLinker->masterView())
{
@@ -212,7 +212,7 @@ void RimViewController::fieldChangedByUi(const caf::PdmFieldHandle* changedField
else if (changedField == &m_managedView)
{
PdmObjectHandle* prevValue = oldValue.value<caf::PdmPointer<PdmObjectHandle> >().rawPtr();
Rim3dView* previousManagedView = dynamic_cast<Rim3dView*>(prevValue);
RimGridView* previousManagedView = dynamic_cast<RimGridView*>(prevValue);
RimViewController::removeOverrides(previousManagedView);
setManagedView(m_managedView());
@@ -232,7 +232,7 @@ void RimViewController::fieldChangedByUi(const caf::PdmFieldHandle* changedField
//--------------------------------------------------------------------------------------------------
RimEclipseView* RimViewController::managedEclipseView() const
{
Rim3dView* rimView = m_managedView;
RimGridView* rimView = m_managedView;
return dynamic_cast<RimEclipseView*>(rimView);
}
@@ -242,7 +242,7 @@ RimEclipseView* RimViewController::managedEclipseView() const
//--------------------------------------------------------------------------------------------------
RimGeoMechView* RimViewController::managedGeoView() const
{
Rim3dView* rimView = m_managedView;
RimGridView* rimView = m_managedView;
return dynamic_cast<RimGeoMechView*>(rimView);
}
@@ -254,7 +254,7 @@ void RimViewController::updateOverrides()
{
RimViewLinker* viewLinker = ownerViewLinker();
Rim3dView* masterView = viewLinker->masterView();
RimGridView* masterView = viewLinker->masterView();
CVF_ASSERT(masterView);
@@ -343,7 +343,7 @@ void RimViewController::removeOverrides()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewController::removeOverrides(Rim3dView* view)
void RimViewController::removeOverrides(RimGridView* view)
{
if (view)
{
@@ -362,7 +362,7 @@ void RimViewController::removeOverrides(Rim3dView* view)
//--------------------------------------------------------------------------------------------------
void RimViewController::updateOptionSensitivity()
{
Rim3dView* mainView = nullptr;
RimGridView* mainView = nullptr;
{
RimViewLinker* linkedViews = nullptr;
@@ -448,7 +448,7 @@ void RimViewController::updateOptionSensitivity()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim3dView* RimViewController::managedView() const
RimGridView* RimViewController::managedView() const
{
return m_managedView;
}
@@ -456,7 +456,7 @@ Rim3dView* RimViewController::managedView() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewController::setManagedView(Rim3dView* view)
void RimViewController::setManagedView(RimGridView* view)
{
m_managedView = view;
@@ -644,7 +644,7 @@ const RigCaseToCaseCellMapper* RimViewController::cellMapper()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim3dView* RimViewController::masterView() const
RimGridView* RimViewController::masterView() const
{
return ownerViewLinker()->masterView();
}
@@ -1041,7 +1041,7 @@ void RimViewController::applyRangeFilterCollectionByUserChoice()
//--------------------------------------------------------------------------------------------------
bool RimViewController::askUserToRestoreOriginalRangeFilterCollection(const QString& viewName)
{
Rim3dView* activeView = RiaApplication::instance()->activeReservoirView();
RimGridView* activeView = RiaApplication::instance()->activeGridView();
QMessageBox msgBox(activeView->viewer()->layoutWidget());
msgBox.setIcon(QMessageBox::Question);

12
ApplicationCode/ProjectDataModel/RimViewController.h
View File

@@ -28,7 +28,7 @@
#include "RivCellSetEnum.h"
class Rim3dView;
class RimGridView;
class RimEclipseView;
class RimGeoMechView;
class RimViewLinker;
@@ -49,10 +49,10 @@ public:
bool isActive() const;
Rim3dView* managedView() const;
void setManagedView(Rim3dView* view);
RimGridView* managedView() const;
void setManagedView(RimGridView* view);
Rim3dView* masterView() const;
RimGridView* masterView() const;
RimViewLinker* ownerViewLinker() const;
const RigCaseToCaseCellMapper* cellMapper();
@@ -102,12 +102,12 @@ private:
RimEclipseView* managedEclipseView() const;
RimGeoMechView* managedGeoView() const;
static void removeOverrides(Rim3dView* view);
static void removeOverrides(RimGridView* view);
static bool askUserToRestoreOriginalRangeFilterCollection(const QString& viewName);
private:
caf::PdmField<QString> m_name;
caf::PdmPtrField<Rim3dView*> m_managedView;
caf::PdmPtrField<RimGridView*> m_managedView;
caf::PdmField<bool> m_isActive;
caf::PdmField<bool> m_syncCamera;

28
ApplicationCode/ProjectDataModel/RimViewLinker.cpp
View File

@@ -83,7 +83,7 @@ RimViewLinker::~RimViewLinker(void)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::updateTimeStep(Rim3dView* sourceView, int timeStep)
void RimViewLinker::updateTimeStep(RimGridView* sourceView, int timeStep)
{
CVF_ASSERT(sourceView);
@@ -247,7 +247,7 @@ void RimViewLinker::removeOverrides()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::allViewsForCameraSync(const Rim3dView* source, std::vector<Rim3dView*>& views) const
void RimViewLinker::allViewsForCameraSync(const RimGridView* source, std::vector<RimGridView*>& views) const
{
if (!isActive()) return;
@@ -283,7 +283,7 @@ void RimViewLinker::updateDependentViews()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimViewLinker::displayNameForView(Rim3dView* view)
QString RimViewLinker::displayNameForView(RimGridView* view)
{
QString displayName = "None";
@@ -303,7 +303,7 @@ QString RimViewLinker::displayNameForView(Rim3dView* view)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::setMasterView(Rim3dView* view)
void RimViewLinker::setMasterView(RimGridView* view)
{
RimViewController* previousViewController = view->viewController();
@@ -324,7 +324,7 @@ void RimViewLinker::setMasterView(Rim3dView* view)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Rim3dView* RimViewLinker::masterView() const
RimGridView* RimViewLinker::masterView() const
{
return m_masterView;
}
@@ -332,7 +332,7 @@ Rim3dView* RimViewLinker::masterView() const
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::allViews(std::vector<Rim3dView*>& views) const
void RimViewLinker::allViews(std::vector<RimGridView*>& views) const
{
views.push_back(m_masterView());
@@ -356,7 +356,7 @@ void RimViewLinker::initAfterRead()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::updateScaleZ(Rim3dView* sourceView, double scaleZ)
void RimViewLinker::updateScaleZ(RimGridView* sourceView, double scaleZ)
{
if (!isActive()) return;
@@ -371,7 +371,7 @@ void RimViewLinker::updateScaleZ(Rim3dView* sourceView, double scaleZ)
}
}
std::vector<Rim3dView*> views;
std::vector<RimGridView*> views;
allViewsForCameraSync(sourceView, views);
// Make sure scale factors are identical
@@ -454,7 +454,7 @@ void RimViewLinker::scheduleCreateDisplayModelAndRedrawForDependentViews()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::findNameAndIconFromView(QString* name, QIcon* icon, Rim3dView* view)
void RimViewLinker::findNameAndIconFromView(QString* name, QIcon* icon, RimGridView* view)
{
CVF_ASSERT(name && icon);
@@ -487,7 +487,7 @@ void RimViewLinker::findNameAndIconFromView(QString* name, QIcon* icon, Rim3dVie
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::updateCursorPosition(const Rim3dView* sourceView, const cvf::Vec3d& domainCoord)
void RimViewLinker::updateCursorPosition(const RimGridView* sourceView, const cvf::Vec3d& domainCoord)
{
RimViewController* sourceViewLink = sourceView->viewController();
if (sourceViewLink && !sourceViewLink->showCursor())
@@ -495,7 +495,7 @@ void RimViewLinker::updateCursorPosition(const Rim3dView* sourceView, const cvf:
return;
}
std::vector<Rim3dView*> viewsToUpdate;
std::vector<RimGridView*> viewsToUpdate;
allViewsForCameraSync(sourceView, viewsToUpdate);
for (Rim3dView* destinationView : viewsToUpdate)
@@ -521,7 +521,7 @@ void RimViewLinker::updateCursorPosition(const Rim3dView* sourceView, const cvf:
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::updateCamera(Rim3dView* sourceView)
void RimViewLinker::updateCamera(RimGridView* sourceView)
{
if (!sourceView->viewer()) return;
@@ -536,7 +536,7 @@ void RimViewLinker::updateCamera(Rim3dView* sourceView)
}
}
std::vector<Rim3dView*> viewsToUpdate;
std::vector<RimGridView*> viewsToUpdate;
allViewsForCameraSync(sourceView, viewsToUpdate);
RimViewManipulator::applySourceViewCameraOnDestinationViews(sourceView, viewsToUpdate);
@@ -545,7 +545,7 @@ void RimViewLinker::updateCamera(Rim3dView* sourceView)
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewLinker::addDependentView(Rim3dView* view)
void RimViewLinker::addDependentView(RimGridView* view)
{
CVF_ASSERT(view && view != m_masterView);

26
ApplicationCode/ProjectDataModel/RimViewLinker.h
View File

@@ -36,7 +36,7 @@ namespace cvf
class RimViewController;
class RiuViewer;
class Rim3dView;
class RimGridView;
class RimCellRangeFilter;
//==================================================================================================
@@ -53,18 +53,18 @@ public:
bool isActive() const;
void setMasterView(Rim3dView* view);
Rim3dView* masterView() const;
void setMasterView(RimGridView* view);
RimGridView* masterView() const;
void addDependentView(Rim3dView* view);
void addDependentView(RimGridView* view);
void updateDependentViews();
void removeViewController(RimViewController* viewController);
void updateOverrides();
void updateCamera(Rim3dView* sourceView);
void updateTimeStep(Rim3dView* sourceView, int timeStep);
void updateScaleZ(Rim3dView* sourceView, double scaleZ);
void updateCamera(RimGridView* sourceView);
void updateTimeStep(RimGridView* sourceView, int timeStep);
void updateScaleZ(RimGridView* sourceView, double scaleZ);
void updateCellResult();
@@ -74,32 +74,32 @@ public:
void scheduleGeometryRegenForDepViews(RivCellSetEnum geometryType);
void scheduleCreateDisplayModelAndRedrawForDependentViews();
void allViews(std::vector<Rim3dView*>& views) const;
void allViews(std::vector<RimGridView*>& views) const;
void updateUiNameAndIcon();
void addViewControllers(caf::PdmUiTreeOrdering& uiTreeOrdering) const;
static void applyIconEnabledState(caf::PdmObject* obj, const QIcon& icon, bool disable);
static void findNameAndIconFromView(QString* name, QIcon* icon, Rim3dView* view);
static void findNameAndIconFromView(QString* name, QIcon* icon, RimGridView* view);
void updateCursorPosition(const Rim3dView* sourceView, const cvf::Vec3d& domainCoord);
void updateCursorPosition(const RimGridView* sourceView, const cvf::Vec3d& domainCoord);
public:
static QString displayNameForView(Rim3dView* view);
static QString displayNameForView(RimGridView* view);
protected:
virtual caf::PdmFieldHandle* userDescriptionField() { return &m_name; }
virtual void initAfterRead();
private:
void allViewsForCameraSync(const Rim3dView* source, std::vector<Rim3dView*>& views) const;
void allViewsForCameraSync(const RimGridView* source, std::vector<RimGridView*>& views) const;
void removeOverrides();
private:
caf::PdmChildArrayField<RimViewController*> m_viewControllers;
caf::PdmPtrField<Rim3dView*> m_masterView;
caf::PdmPtrField<RimGridView*> m_masterView;
caf::PdmField<QString> m_name;
QIcon m_originalIcon;
};

4
ApplicationCode/ProjectDataModel/RimViewManipulator.cpp
View File

@@ -35,7 +35,7 @@
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimViewManipulator::applySourceViewCameraOnDestinationViews(Rim3dView* sourceView, std::vector<Rim3dView*>& destinationViews)
void RimViewManipulator::applySourceViewCameraOnDestinationViews(RimGridView* sourceView, std::vector<RimGridView*>& destinationViews)
{
bool setPointOfInterest = false;
cvf::Vec3d sourceCamUp;
@@ -72,7 +72,7 @@ void RimViewManipulator::applySourceViewCameraOnDestinationViews(Rim3dView* sour
sourceSceneBB.transform(trans);
}
for (Rim3dView* destinationView : destinationViews)
for (RimGridView* destinationView : destinationViews)
{
if (!destinationView) continue;

4
ApplicationCode/ProjectDataModel/RimViewManipulator.h
View File

@@ -24,12 +24,12 @@ namespace cvf {
class BoundingBox;
}
class Rim3dView;
class RimGridView;
class RimViewManipulator
{
public:
static void applySourceViewCameraOnDestinationViews(Rim3dView* sourceView, std::vector<Rim3dView*>& destinationViews);
static void applySourceViewCameraOnDestinationViews(RimGridView* sourceView, std::vector<RimGridView*>& destinationViews);
private:
static bool isBoundingBoxesOverlappingOrClose(const cvf::BoundingBox& sourceBB, const cvf::BoundingBox& destBB);

5
ApplicationCode/UserInterface/RiuMainWindow.cpp
View File

@@ -1430,8 +1430,9 @@ void RiuMainWindow::slotDrawStyleChanged(QAction* activatedAction)
void RiuMainWindow::slotToggleHideGridCellsAction(bool hideGridCells)
{
if (!RiaApplication::instance()->activeReservoirView()) return;
RiaApplication::instance()->activeReservoirView()->showGridCells(!hideGridCells);
RimGridView* rigv = RiaApplication::instance()->activeGridView();
if (rigv) rigv->showGridCells(!hideGridCells);
}

8
ApplicationCode/UserInterface/RiuViewer.cpp
View File

@@ -298,7 +298,7 @@ void RiuViewer::slotSetCurrentFrame(int frameIndex)
RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
if (viewLinker)
{
viewLinker->updateTimeStep(dynamic_cast<Rim3dView*>(m_rimView.p()), frameIndex);
viewLinker->updateTimeStep(dynamic_cast<RimGridView*>(m_rimView.p()), frameIndex);
}
}
}
@@ -630,7 +630,7 @@ void RiuViewer::navigationPolicyUpdate()
RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
if (viewLinker)
{
viewLinker->updateCamera(dynamic_cast<Rim3dView*>(m_rimView.p()));
viewLinker->updateCamera(dynamic_cast<RimGridView*>(m_rimView.p()));
}
}
}
@@ -740,7 +740,7 @@ void RiuViewer::mouseMoveEvent(QMouseEvent* mouseEvent)
cvf::ref<caf::DisplayCoordTransform> trans = m_rimView->displayCoordTransform();
cvf::Vec3d domainCoord = trans->transformToDomainCoord(displayCoord);
viewLinker->updateCursorPosition(dynamic_cast<Rim3dView*>(m_rimView.p()) , domainCoord);
viewLinker->updateCursorPosition(dynamic_cast<RimGridView*>(m_rimView.p()) , domainCoord);
}
}
}
@@ -756,7 +756,7 @@ void RiuViewer::leaveEvent(QEvent *)
if (m_rimView && m_rimView->assosiatedViewLinker())
{
RimViewLinker* viewLinker = m_rimView->assosiatedViewLinker();
viewLinker->updateCursorPosition(dynamic_cast<Rim3dView*>(m_rimView.p()), cvf::Vec3d::UNDEFINED);
viewLinker->updateCursorPosition(dynamic_cast<RimGridView*>(m_rimView.p()), cvf::Vec3d::UNDEFINED);
}
}