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

#4260 Support changing IJK bounding box in sector model and remodel UI

Browse Source
This commit is contained in:
Gaute Lindkvist 2019-04-01 16:21:43 +02:00
parent e2278493ad
commit 209146ebae
17 changed files with 308 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
ApplicationCode/Application/RiaPreferences.h
View File

@ -110,5 +110,5 @@ private:
caf::PdmField<bool> m_showTestToolbar;
caf::PdmField<bool> m_includeFractureDebugInfoFile;
caf::PdmField<QString> m_holoLensExportFolder;
QStringList m_tabNames;
QStringList m_tabNames;
};

8
ApplicationCode/CommandFileInterface/RicfExportVisibleCells.cpp
View File

@ -98,7 +98,13 @@ void RicfExportVisibleCells::execute()
RiaViewRedrawScheduler::instance()->clearViewsScheduledForUpdate();
RicExportEclipseSectorModelUi exportSettings(eclipseView->eclipseCase()->eclipseCaseData());
cvf::UByteArray cellVisibility;
eclipseView->calculateCurrentTotalCellVisibility(&cellVisibility, eclipseView->currentTimeStep());
cvf::Vec3i min, max;
std::tie(min, max) = RicExportEclipseSectorModelFeature::getVisibleCellRange(eclipseView, cellVisibility);
RicExportEclipseSectorModelUi exportSettings(eclipseView->eclipseCase()->eclipseCaseData(), min, max);
buildExportSettings(exportFolder, &exportSettings);
RicExportEclipseSectorModelFeature::executeCommand(eclipseView, exportSettings, "exportVisibleCells");
}

2
ApplicationCode/Commands/CompletionExportCommands/RicExportCompletionsWellSegmentsFeature.cpp
View File

@ -93,7 +93,7 @@ void RicExportCompletionsWellSegmentsFeature::onActionTriggered(bool isChecked)
exportSettings.folder = defaultDir;
caf::PdmUiPropertyViewDialog propertyDialog(Riu3DMainWindowTools::mainWindowWidget(), &exportSettings, "Export Well Segments", "");
RicExportFeatureImpl::configureForExport(&propertyDialog);
RicExportFeatureImpl::configureForExport(propertyDialog.dialogButtonBox());
if (propertyDialog.exec() == QDialog::Accepted)
{

2
ApplicationCode/Commands/CompletionExportCommands/RicWellPathExportCompletionDataFeature.cpp
View File

@ -129,7 +129,7 @@ void RicWellPathExportCompletionDataFeature::prepareExportSettingsAndExportCompl
}
caf::PdmUiPropertyViewDialog propertyDialog(Riu3DMainWindowTools::mainWindowWidget(), exportSettings, dialogTitle, "");
RicExportFeatureImpl::configureForExport(&propertyDialog);
RicExportFeatureImpl::configureForExport(propertyDialog.dialogButtonBox());
if (propertyDialog.exec() == QDialog::Accepted)
{

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

@ -68,7 +68,7 @@ void RicExportCarfin::onActionTriggered(bool isChecked)
exportCarfinObject->setCase(rimCase);
caf::PdmUiPropertyViewDialog propertyDialog(nullptr, exportCarfinObject, "Export CARFIN to Eclipse Data", "");
RicExportFeatureImpl::configureForExport(&propertyDialog);
RicExportFeatureImpl::configureForExport(propertyDialog.dialogButtonBox());
if (propertyDialog.exec() == QDialog::Accepted)
{

38
ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelFeature.cpp
View File

@ -38,6 +38,7 @@
#include "RigMainGrid.h"
#include "Riu3DMainWindowTools.h"
#include "RiuPropertyViewTabWidget.h"
#include "cafPdmUiPropertyViewDialog.h"
#include "cafProgressInfo.h"
@ -58,9 +59,16 @@ void RicExportEclipseSectorModelFeature::openDialogAndExecuteCommand(RimEclipseV
RigEclipseCaseData* caseData = view->eclipseCase()->eclipseCaseData();
RicExportEclipseSectorModelUi exportSettings(caseData);
caf::PdmUiPropertyViewDialog propertyDialog(Riu3DMainWindowTools::mainWindowWidget(), &exportSettings, "Export Eclipse Sector Model", "");
RicExportFeatureImpl::configureForExport(&propertyDialog);
cvf::UByteArray cellVisibility;
view->calculateCurrentTotalCellVisibility(&cellVisibility, view->currentTimeStep());
cvf::Vec3i min, max;
std::tie(min, max) = getVisibleCellRange(view, cellVisibility);
RicExportEclipseSectorModelUi exportSettings(caseData, min, max);
RiuPropertyViewTabWidget propertyDialog(Riu3DMainWindowTools::mainWindowWidget(), &exportSettings, "Export Eclipse Sector Model", exportSettings.tabNames());
RicExportFeatureImpl::configureForExport(propertyDialog.dialogButtonBox());
if (propertyDialog.exec() == QDialog::Accepted)
{
@ -84,15 +92,17 @@ void RicExportEclipseSectorModelFeature::executeCommand(RimEclipseView* view,
caf::ProgressInfo progress(gridProgressPercentage + resultProgressPercentage + faultsProgressPercentage,
"Export Eclipse Sector Model");
cvf::Vec3st refinement(exportSettings.cellCountI(), exportSettings.cellCountJ(), exportSettings.cellCountK());
cvf::Vec3st refinement(exportSettings.refinementCountI(), exportSettings.refinementCountJ(), exportSettings.refinementCountK());
CVF_ASSERT(refinement.x() > 0u && refinement.y() > 0u && refinement.z() > 0u);
cvf::UByteArray cellVisibility;
view->calculateCurrentTotalCellVisibility(&cellVisibility, view->currentTimeStep());
getVisibleCellRange(view, cellVisibility);
cvf::Vec3st min(exportSettings.min());
cvf::Vec3st max(exportSettings.max());
cvf::Vec3st min, max;
std::tie(min, max) = getVisibleCellRange(view, cellVisibility);
if (exportSettings.exportGrid())
{
const cvf::UByteArray* cellVisibilityForActnum = exportSettings.makeInvisibleCellsInactive() ? &cellVisibility : nullptr;
@ -215,14 +225,14 @@ void RicExportEclipseSectorModelFeature::executeCommand(RimEclipseView* view,
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::pair<cvf::Vec3st, cvf::Vec3st> RicExportEclipseSectorModelFeature::getVisibleCellRange(RimEclipseView* view, const cvf::UByteArray& cellVisibillity)
std::pair<cvf::Vec3i, cvf::Vec3i> RicExportEclipseSectorModelFeature::getVisibleCellRange(RimEclipseView* view, const cvf::UByteArray& cellVisibillity)
{
const RigMainGrid* mainGrid = view->eclipseCase()->mainGrid();
cvf::Vec3st max = cvf::Vec3st::ZERO;
cvf::Vec3st min = cvf::Vec3st(mainGrid->cellCountI() - 1,
mainGrid->cellCountJ() - 1,
mainGrid->cellCountK() - 1);
cvf::Vec3i max = cvf::Vec3i::ZERO;
cvf::Vec3i min = cvf::Vec3i(int(mainGrid->cellCountI() - 1),
int(mainGrid->cellCountJ() - 1),
int(mainGrid->cellCountK() - 1));
size_t cellCount = mainGrid->cellCount();
for (size_t index = 0; index < cellCount; ++index)
@ -233,8 +243,8 @@ std::pair<cvf::Vec3st, cvf::Vec3st> RicExportEclipseSectorModelFeature::getVisib
mainGrid->ijkFromCellIndex(index, &ijk[0], &ijk[1], &ijk[2]);
for (int n = 0; n < 3; ++n)
{
min[n] = std::min(min[n], ijk[n]);
max[n] = std::max(max[n], ijk[n]);
min[n] = std::min(min[n], (int) ijk[n]);
max[n] = std::max(max[n], (int) ijk[n]);
}
}
}
@ -263,7 +273,7 @@ void RicExportEclipseSectorModelFeature::onActionTriggered(bool isChecked)
//--------------------------------------------------------------------------------------------------
void RicExportEclipseSectorModelFeature::setupActionLook(QAction* actionToSetup)
{
actionToSetup->setText("Export Visible Cells as Eclipse Sector Model");
actionToSetup->setText("Export Eclipse Sector Model");
}
//--------------------------------------------------------------------------------------------------

2
ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelFeature.h
View File

@ -39,7 +39,7 @@ public :
const RicExportEclipseSectorModelUi& exportSettings,
const QString& logPrefix);
static std::pair<cvf::Vec3st, cvf::Vec3st> getVisibleCellRange(RimEclipseView* view, const cvf::UByteArray& cellVisibility);
static std::pair<cvf::Vec3i, cvf::Vec3i> getVisibleCellRange(RimEclipseView* view, const cvf::UByteArray& cellVisibility);
protected:
bool isCommandEnabled() override;
void onActionTriggered(bool isChecked) override;

260
ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelUi.cpp
View File

@ -19,8 +19,10 @@
#include "RicExportEclipseSectorModelUi.h"
#include "RiaApplication.h"
#include "RigActiveCellInfo.h"
#include "RigCaseCellResultsData.h"
#include "RigEclipseCaseData.h"
#include "RigMainGrid.h"
#include "RimEclipseResultDefinition.h"
@ -46,18 +48,33 @@ void RicExportEclipseSectorModelUi::ResultExportOptionsEnum::setUp()
addItem(RicExportEclipseSectorModelUi::EXPORT_NO_RESULTS, "NO_RESULTS", "Do not export");
addItem(RicExportEclipseSectorModelUi::EXPORT_TO_GRID_FILE, "TO_GRID_FILE", "Append to grid file");
addItem(RicExportEclipseSectorModelUi::EXPORT_TO_SINGLE_SEPARATE_FILE, "TO_SINGLE_RESULT_FILE", "Export to single file");
addItem(RicExportEclipseSectorModelUi::EXPORT_TO_SEPARATE_FILE_PER_RESULT, "TO_SEPARATE_RESULT_FILES", "Export to a separate file per property");
addItem(RicExportEclipseSectorModelUi::EXPORT_TO_SEPARATE_FILE_PER_RESULT, "TO_SEPARATE_RESULT_FILES", "Export to a separate file per parameter");
setDefault(RicExportEclipseSectorModelUi::EXPORT_TO_SEPARATE_FILE_PER_RESULT);
}
template<>
void RicExportEclipseSectorModelUi::GridBoxSelectionEnum::setUp()
{
addItem(RicExportEclipseSectorModelUi::VISIBLE_CELLS_BOX, "VISIBLE_CELLS", "Box Containing all Visible Cells");
addItem(RicExportEclipseSectorModelUi::ACTIVE_CELLS_BOX, "ACTIVE_CELLS", "Box Containing all Active Cells");
addItem(RicExportEclipseSectorModelUi::FULL_GRID_BOX, "FULL_GRID", "Full Grid");
addItem(RicExportEclipseSectorModelUi::MANUAL_SELECTION, "MANUAL_SELECTION", "Manual Selection");
setDefault(RicExportEclipseSectorModelUi::VISIBLE_CELLS_BOX);
}
} // namespace caf
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RicExportEclipseSectorModelUi::RicExportEclipseSectorModelUi(RigEclipseCaseData* caseData)
RicExportEclipseSectorModelUi::RicExportEclipseSectorModelUi(RigEclipseCaseData* caseData /*= nullptr*/,
const cvf::Vec3i& visibleMin /*= cvf::Vec3i::ZERO*/,
const cvf::Vec3i& visibleMax /*= cvf::Vec3i::ZERO*/)
: m_caseData(caseData)
, m_visibleMin(visibleMin)
, m_visibleMax(visibleMax)
{
CAF_PDM_InitObject("Export Visible Cells as Eclipse Input Grid", "", "", "");
@ -67,22 +84,37 @@ RicExportEclipseSectorModelUi::RicExportEclipseSectorModelUi(RigEclipseCaseData*
CAF_PDM_InitField(&exportInLocalCoordinates, "ExportInLocalCoords", false, "Export in Local Coordinates", "", "Remove UTM location on export", "");
CAF_PDM_InitField(&makeInvisibleCellsInactive, "InvisibleCellActnum", false, "Make Invisible Cells Inactive", "", "", "");
CAF_PDM_InitFieldNoDefault(&exportGridBox, "GridBoxSelection", "Cells to Export", "", "", "");
QString minIJKLabel = "Min I, J, K";
CAF_PDM_InitField(&minI, "MinI", m_visibleMin.x() + 1, minIJKLabel, "", "", "");
CAF_PDM_InitField(&minJ, "MinJ", m_visibleMin.y() + 1, "", "", "", "");
minJ.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
CAF_PDM_InitField(&minK, "MinK", m_visibleMin.z() + 1, "", "", "", "");
minK.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
QString maxIJKLabel = "Max I, J, K";
CAF_PDM_InitField(&maxI, "MaxI", m_visibleMax.x() + 1, maxIJKLabel, "", "", "");
CAF_PDM_InitField(&maxJ, "MaxJ", m_visibleMax.y() + 1, "", "", "", "");
maxJ.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
CAF_PDM_InitField(&maxK, "MaxK", m_visibleMax.z() + 1, "", "", "", "");
maxK.uiCapability()->setUiLabelPosition(caf::PdmUiItemInfo::HIDDEN);
CAF_PDM_InitFieldNoDefault(&exportFaults, "ExportFaults", "Export Fault Data", "", "", "");
exportFaults = EXPORT_TO_SINGLE_SEPARATE_FILE;
CAF_PDM_InitField(&exportFaultsFilename, "ExportFaultsFilename", QString(), "Faults File Name", "", "", "");
exportFaultsFilename.uiCapability()->setUiEditorTypeName(caf::PdmUiFilePathEditor::uiEditorTypeName());
QString ijkLabel = "Cell Count I, J, K";
CAF_PDM_InitField(&refinementCountI, "RefinementCountI", 1, ijkLabel, "", "", "");
CAF_PDM_InitField(&refinementCountJ, "RefinementCountJ", 1, "", "", "", "");
CAF_PDM_InitField(&refinementCountK, "RefinementCountK", 1, "", "", "", "");
CAF_PDM_InitFieldNoDefault(&exportParameters, "ExportResults", "Export Properties", "", "", "");
CAF_PDM_InitField(&exportParametersFilename, "ExportResultsFilename", QString(), "Properties File Name", "", "", "");
CAF_PDM_InitFieldNoDefault(&exportParameters, "ExportParams", "Export Parameters", "", "", "");
CAF_PDM_InitField(&exportParametersFilename, "ExportParamsFilename", QString(), "File Name", "", "", "");
exportParametersFilename.uiCapability()->setUiEditorTypeName(caf::PdmUiFilePathEditor::uiEditorTypeName());
CAF_PDM_InitFieldNoDefault(&selectedKeywords, "ExportMainKeywords", "Main Keywords", "", "", "");
QString ijkLabel = "Cell Count I, J, K";
CAF_PDM_InitField(&cellCountI, "CellCountI", 1, ijkLabel, "", "", "");
CAF_PDM_InitField(&cellCountJ, "CellCountJ", 1, "", "", "", "");
CAF_PDM_InitField(&cellCountK, "CellCountK", 1, "", "", "", "");
CAF_PDM_InitFieldNoDefault(&selectedKeywords, "ExportMainKeywords", "Keywords to Export", "", "", "");
exportGridFilename = defaultGridFileName();
exportParametersFilename = defaultResultsFileName();
@ -95,6 +127,8 @@ RicExportEclipseSectorModelUi::RicExportEclipseSectorModelUi(RigEclipseCaseData*
selectedKeywords.v().push_back(keyword);
}
}
m_tabNames << "Grid Data";
m_tabNames << "Parameters";
}
//--------------------------------------------------------------------------------------------------
@ -104,11 +138,58 @@ RicExportEclipseSectorModelUi::~RicExportEclipseSectorModelUi()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const QStringList& RicExportEclipseSectorModelUi::tabNames() const
{
return m_tabNames;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec3i RicExportEclipseSectorModelUi::min() const
{
return cvf::Vec3i(minI() - 1, minJ() - 1, minK() - 1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Vec3i RicExportEclipseSectorModelUi::max() const
{
return cvf::Vec3i(maxI() - 1, maxJ() - 1, maxK() - 1);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicExportEclipseSectorModelUi::setMin(const cvf::Vec3i& min)
{
minI = min.x() + 1; minJ = min.y() + 1; minK = min.z() + 1;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicExportEclipseSectorModelUi::setMax(const cvf::Vec3i& max)
{
maxI = max.x() + 1; maxJ = max.y() + 1; maxK = max.z() + 1;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicExportEclipseSectorModelUi::defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute * attribute)
{
if (!m_caseData) return;
const RigMainGrid* mainGrid = m_caseData->mainGrid();
cvf::Vec3i gridDimensions(int(mainGrid->cellCountI()), int(mainGrid->cellCountJ()), int(mainGrid->cellCountK()));
caf::PdmUiLineEditorAttribute* lineEditorAttr = dynamic_cast<caf::PdmUiLineEditorAttribute*>(attribute);
if (field == &exportParametersFilename || field == &exportGridFilename || field == &exportFaultsFilename)
{
caf::PdmUiFilePathEditorAttribute* myAttr = dynamic_cast<caf::PdmUiFilePathEditorAttribute*>(attribute);
@ -125,13 +206,33 @@ void RicExportEclipseSectorModelUi::defineEditorAttribute(const caf::PdmFieldHan
myAttr->m_heightHint = 280;
}
}
else if (field == &cellCountI || field == &cellCountJ || field == &cellCountK)
else if (field == &refinementCountI || field == &refinementCountJ || field == &refinementCountK)
{
caf::PdmUiLineEditorAttribute* myAttr = dynamic_cast<caf::PdmUiLineEditorAttribute*>(attribute);
if (myAttr)
if (lineEditorAttr)
{
QIntValidator* validator = new QIntValidator(1, 10, nullptr);
myAttr->validator = validator;
lineEditorAttr->validator = validator;
}
}
else if (field == &minI || field == &maxI)
{
if (lineEditorAttr)
{
lineEditorAttr->validator = new QIntValidator(1, (int)gridDimensions.x(), nullptr);
}
}
else if (field == &minJ || field == &maxJ)
{
if (lineEditorAttr)
{
lineEditorAttr->validator = new QIntValidator(1, (int)gridDimensions.y(), nullptr);
}
}
else if (field == &minK || field == &maxK)
{
if (lineEditorAttr)
{
lineEditorAttr->validator = new QIntValidator(1, (int)gridDimensions.z(), nullptr);
}
}
}
@ -141,48 +242,70 @@ void RicExportEclipseSectorModelUi::defineEditorAttribute(const caf::PdmFieldHan
//--------------------------------------------------------------------------------------------------
void RicExportEclipseSectorModelUi::defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering)
{
caf::PdmUiGroup* gridGroup = uiOrdering.addNewGroup("Grid Export");
gridGroup->add(&exportGrid);
gridGroup->add(&exportGridFilename);
exportGridFilename.uiCapability()->setUiReadOnly(!exportGrid());
gridGroup->add(&exportInLocalCoordinates);
exportInLocalCoordinates.uiCapability()->setUiReadOnly(!exportGrid());
gridGroup->add(&makeInvisibleCellsInactive);
makeInvisibleCellsInactive.uiCapability()->setUiReadOnly(!exportGrid());
gridGroup->add(&exportFaults);
if (exportFaults() != EXPORT_NO_RESULTS)
if (uiConfigName == m_tabNames[0])
{
if (exportFaults() == EXPORT_TO_SINGLE_SEPARATE_FILE)
caf::PdmUiGroup* gridGroup = uiOrdering.addNewGroup("Grid Export");
gridGroup->add(&exportGrid);
gridGroup->add(&exportGridFilename);
exportGridFilename.uiCapability()->setUiReadOnly(!exportGrid());
gridGroup->add(&exportInLocalCoordinates);
exportInLocalCoordinates.uiCapability()->setUiReadOnly(!exportGrid());
gridGroup->add(&makeInvisibleCellsInactive);
caf::PdmUiGroup* gridBoxGroup = uiOrdering.addNewGroup("Grid Box Selection");
gridBoxGroup->add(&exportGridBox, { true, 4, 1 });
gridBoxGroup->add(&minI, { true, 2, 1 });
gridBoxGroup->add(&minJ, false);
gridBoxGroup->add(&minK, false);
gridBoxGroup->add(&maxI, { true, 2, 1 });
gridBoxGroup->add(&maxJ, false);
gridBoxGroup->add(&maxK, false);
minI.uiCapability()->setUiReadOnly(exportGridBox() != MANUAL_SELECTION);
minJ.uiCapability()->setUiReadOnly(exportGridBox() != MANUAL_SELECTION);
minK.uiCapability()->setUiReadOnly(exportGridBox() != MANUAL_SELECTION);
maxI.uiCapability()->setUiReadOnly(exportGridBox() != MANUAL_SELECTION);
maxJ.uiCapability()->setUiReadOnly(exportGridBox() != MANUAL_SELECTION);
maxK.uiCapability()->setUiReadOnly(exportGridBox() != MANUAL_SELECTION);
caf::PdmUiGroup* gridRefinement = uiOrdering.addNewGroup("Grid Refinement");
gridRefinement->add(&refinementCountI, {true, 2, 1});
gridRefinement->add(&refinementCountJ, {false});
gridRefinement->add(&refinementCountK, {false});
refinementCountI.uiCapability()->setUiReadOnly(!exportGrid());
refinementCountJ.uiCapability()->setUiReadOnly(!exportGrid());
refinementCountK.uiCapability()->setUiReadOnly(!exportGrid());
caf::PdmUiGroup* faultsGroup = uiOrdering.addNewGroup("Faults");
faultsGroup->add(&exportFaults);
if (exportFaults() != EXPORT_NO_RESULTS)
{
gridGroup->add(&exportFaultsFilename);
if (exportFaults() == EXPORT_TO_SINGLE_SEPARATE_FILE)
{
faultsGroup->add(&exportFaultsFilename);
}
}
}
caf::PdmUiGroup* gridRefinement = gridGroup->addNewGroup("Grid Refinement");
gridRefinement->add(&cellCountI, {true, 2, 1});
gridRefinement->add(&cellCountJ, {false});
gridRefinement->add(&cellCountK, {false});
cellCountI.uiCapability()->setUiReadOnly(!exportGrid());
cellCountJ.uiCapability()->setUiReadOnly(!exportGrid());
cellCountK.uiCapability()->setUiReadOnly(!exportGrid());
caf::PdmUiGroup* resultsGroup = uiOrdering.addNewGroup("Property Export");
resultsGroup->add(&exportParameters);
if (exportParameters() != EXPORT_NO_RESULTS)
else if (uiConfigName == m_tabNames[1])
{
if (exportParameters() == EXPORT_TO_SINGLE_SEPARATE_FILE)
caf::PdmUiGroup* resultsGroup = uiOrdering.addNewGroup("Parameter Export");
resultsGroup->add(&exportParameters);
if (exportParameters() != EXPORT_NO_RESULTS)
{
resultsGroup->add(&exportParametersFilename);
if (exportParameters() == EXPORT_TO_SINGLE_SEPARATE_FILE)
{
resultsGroup->add(&exportParametersFilename);
}
}
if (exportParameters() != EXPORT_NO_RESULTS)
{
resultsGroup->add(&selectedKeywords);
}
}
if (exportParameters() != EXPORT_NO_RESULTS)
{
resultsGroup->add(&selectedKeywords);
}
uiOrdering.skipRemainingFields(true);
}
@ -191,7 +314,46 @@ void RicExportEclipseSectorModelUi::defineUiOrdering(QString uiConfigName, caf::
//--------------------------------------------------------------------------------------------------
void RicExportEclipseSectorModelUi::fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue)
{
if (changedField == &exportGridFilename)
if (changedField == &exportGrid)
{
if (!exportGrid())
{
if (exportFaults() == EXPORT_TO_GRID_FILE)
{
exportFaults = EXPORT_TO_SINGLE_SEPARATE_FILE;
}
if (exportParameters() == EXPORT_TO_GRID_FILE)
{
exportParameters = EXPORT_TO_SEPARATE_FILE_PER_RESULT;
}
this->updateConnectedEditors();
}
}
else if (changedField == &exportGridBox)
{
if (exportGridBox == ACTIVE_CELLS_BOX)
{
cvf::Vec3st minActive, maxActive;
m_caseData->activeCellInfo(RiaDefines::MATRIX_MODEL)->IJKBoundingBox(minActive, maxActive);
setMin(cvf::Vec3i(minActive));
setMax(cvf::Vec3i(maxActive));
}
else if (exportGridBox == VISIBLE_CELLS_BOX)
{
setMin(m_visibleMin);
setMax(m_visibleMax);
}
else if (exportGridBox == FULL_GRID_BOX)
{
const RigMainGrid* mainGrid = m_caseData->mainGrid();
cvf::Vec3i gridDimensions(int(mainGrid->cellCountI() - 1), int(mainGrid->cellCountJ() - 1), int(mainGrid->cellCountK() - 1));
setMin(cvf::Vec3i(1, 1, 1));
setMax(gridDimensions);
}
this->updateConnectedEditors();
}
else if (changedField == &exportGridFilename)
{
QFileInfo info(exportGridFilename());
QDir dirPath = info.absoluteDir();

45
ApplicationCode/Commands/ExportCommands/RicExportEclipseSectorModelUi.h
View File

@ -18,10 +18,13 @@
#pragma once
#include "cafAppEnum.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmChildArrayField.h"
#include "cafAppEnum.h"
#include "cvfBase.h"
#include "cvfVector3.h"
#include <QString>
#include <QStringList>
@ -47,9 +50,26 @@ class RicExportEclipseSectorModelUi : public caf::PdmObject
};
typedef caf::AppEnum<ResultExportOptions> ResultExportOptionsEnum;
enum GridBoxSelection
{
VISIBLE_CELLS_BOX,
ACTIVE_CELLS_BOX,
FULL_GRID_BOX,
MANUAL_SELECTION
};
typedef caf::AppEnum<GridBoxSelection> GridBoxSelectionEnum;
public:
RicExportEclipseSectorModelUi(RigEclipseCaseData* caseData = nullptr);
RicExportEclipseSectorModelUi(RigEclipseCaseData* caseData = nullptr,
const cvf::Vec3i& visibleMin = cvf::Vec3i::ZERO,
const cvf::Vec3i& visibleMax = cvf::Vec3i::ZERO);
~RicExportEclipseSectorModelUi() override;
const QStringList& tabNames() const;
cvf::Vec3i min() const;
cvf::Vec3i max() const;
void setMin(const cvf::Vec3i& min);
void setMax(const cvf::Vec3i& max);
caf::PdmField<bool> exportGrid;
caf::PdmField<QString> exportGridFilename;
@ -64,11 +84,20 @@ public:
caf::PdmField<std::vector<QString>> selectedKeywords;
caf::PdmField<int> cellCountI;
caf::PdmField<int> cellCountJ;
caf::PdmField<int> cellCountK;
caf::PdmField<GridBoxSelectionEnum> exportGridBox;
caf::PdmField<int> refinementCountI;
caf::PdmField<int> refinementCountJ;
caf::PdmField<int> refinementCountK;
protected:
caf::PdmField<int> minI;
caf::PdmField<int> maxI;
caf::PdmField<int> minJ;
caf::PdmField<int> maxJ;
caf::PdmField<int> minK;
caf::PdmField<int> maxK;
void defineEditorAttribute(const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute) override;
void defineUiOrdering(QString uiConfigName, caf::PdmUiOrdering& uiOrdering) override;
void fieldChangedByUi(const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue) override;
@ -80,6 +109,10 @@ protected:
QString defaultGridFileName() const;
QString defaultResultsFileName() const;
QString defaultFaultsFileName() const;
private:
RigEclipseCaseData* m_caseData;
cvf::Vec3i m_visibleMin;
cvf::Vec3i m_visibleMax;
QStringList m_tabNames;
};

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

@ -77,7 +77,7 @@ void RicExportToLasFileFeature::onActionTriggered(bool isChecked)
}
caf::PdmUiPropertyViewDialog propertyDialog(nullptr, &featureUi, "Export Curve Data to LAS file(s)", "", QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
RicExportFeatureImpl::configureForExport(&propertyDialog);
RicExportFeatureImpl::configureForExport(propertyDialog.dialogButtonBox());
propertyDialog.resize(QSize(400, 330));
if (propertyDialog.exec() == QDialog::Accepted &&

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

@ -101,7 +101,7 @@ void RicSaveEclipseInputPropertyFeature::onActionTriggered(bool isChecked)
}
caf::PdmUiPropertyViewDialog propertyDialog(Riu3DMainWindowTools::mainWindowWidget(), &exportSettings, "Export Eclipse Property to Text File", "");
RicExportFeatureImpl::configureForExport(&propertyDialog);
RicExportFeatureImpl::configureForExport(propertyDialog.dialogButtonBox());
if (propertyDialog.exec() == QDialog::Accepted)
{

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

@ -53,7 +53,7 @@ void RicSaveEclipseInputVisibleCellsFeature::openDialogAndExecuteCommand(RimEcli
RicSaveEclipseInputVisibleCellsUi exportSettings;
caf::PdmUiPropertyViewDialog propertyDialog(Riu3DMainWindowTools::mainWindowWidget(), &exportSettings, "Export FLUXNUM/MULTNUM", "");
RicExportFeatureImpl::configureForExport(&propertyDialog);
RicExportFeatureImpl::configureForExport(propertyDialog.dialogButtonBox());
if (propertyDialog.exec() == QDialog::Accepted)
{

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

@ -91,7 +91,7 @@ void RicSaveEclipseResultAsInputPropertyExec::redo()
}
caf::PdmUiPropertyViewDialog propertyDialog(Riu3DMainWindowTools::mainWindowWidget(), &exportSettings, "Export Binary Eclipse Data to Text File", "");
RicExportFeatureImpl::configureForExport(&propertyDialog);
RicExportFeatureImpl::configureForExport(propertyDialog.dialogButtonBox());
if (propertyDialog.exec() == QDialog::Accepted)
{

6
ApplicationCode/Commands/RicExportFeatureImpl.cpp
View File

@ -18,17 +18,13 @@
#include "RicExportFeatureImpl.h"
#include "cafPdmUiPropertyViewDialog.h"
#include <QDialogButtonBox>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RicExportFeatureImpl::configureForExport(caf::PdmUiPropertyViewDialog* propertyViewDialog)
void RicExportFeatureImpl::configureForExport(QDialogButtonBox* dialogButtonBox)
{
QDialogButtonBox* dialogButtonBox = propertyViewDialog->dialogButtonBox();
dialogButtonBox->clear();
dialogButtonBox->addButton("Export", QDialogButtonBox::AcceptRole);

6
ApplicationCode/Commands/RicExportFeatureImpl.h
View File

@ -18,9 +18,7 @@
#pragma once
namespace caf {
class PdmUiPropertyViewDialog;
}
class QDialogButtonBox;
//==================================================================================================
///
@ -28,5 +26,5 @@ namespace caf {
class RicExportFeatureImpl
{
public:
static void configureForExport(caf::PdmUiPropertyViewDialog* propertyViewDialog);
static void configureForExport(QDialogButtonBox* propertyViewDialog);
};

16
ApplicationCode/UserInterface/RiuPropertyViewTabWidget.cpp
View File

@ -63,11 +63,11 @@ RiuPropertyViewTabWidget::RiuPropertyViewTabWidget(QWidget* parent, caf::PdmObje
dialogLayout->addWidget(tabWidget);
// Buttons
QDialogButtonBox* buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
connect(buttonBox, SIGNAL(accepted()), this, SLOT(accept()));
connect(buttonBox, SIGNAL(rejected()), this, SLOT(reject()));
m_dialogButtonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
connect(m_dialogButtonBox, SIGNAL(accepted()), this, SLOT(accept()));
connect(m_dialogButtonBox, SIGNAL(rejected()), this, SLOT(reject()));
dialogLayout->addWidget(buttonBox);
dialogLayout->addWidget(m_dialogButtonBox);
}
//--------------------------------------------------------------------------------------------------
@ -101,3 +101,11 @@ QSize RiuPropertyViewTabWidget::sizeHint() const
return maxSizeHint;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QDialogButtonBox* RiuPropertyViewTabWidget::dialogButtonBox()
{
return m_dialogButtonBox;
}

4
ApplicationCode/UserInterface/RiuPropertyViewTabWidget.h
View File

@ -26,6 +26,7 @@ namespace caf {
class PdmUiPropertyView;
}
class QDialogButtonBox;
class QWidget;
class QString;
class QStringList;
@ -37,7 +38,8 @@ public:
~RiuPropertyViewTabWidget() override;
QSize sizeHint() const override;
QDialogButtonBox* dialogButtonBox();
private:
std::vector<caf::PdmUiPropertyView*> m_pageWidgets;
QDialogButtonBox* m_dialogButtonBox;
};