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

Merge remote-tracking branch 'origin/dev' into grid-geometry-extraction

Browse Source
This commit is contained in:
Jørgen Herje
2024-03-14 08:31:07 +01:00
parent ae6131e92e b595487d23
commit 7ca4bd7ce3
205 changed files with 2463 additions and 658 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
ApplicationLibCode/ProjectDataModel/Annotations/RimPolylinesAnnotationInView.h
View File

@@ -28,7 +28,6 @@
#include "cafPdmObject.h"
#include "cafPdmPointer.h"
#include "cafPdmPtrField.h"
#include "cafPdmUiOrdering.h"
// Include to make Pdm work for cvf::Color
#include "cafPdmChildField.h"

1
ApplicationLibCode/ProjectDataModel/Annotations/RimPolylinesFromFileAnnotationInView.h
View File

@@ -26,7 +26,6 @@
#include "cafPdmObject.h"
#include "cafPdmPointer.h"
#include "cafPdmPtrField.h"
#include "cafPdmUiOrdering.h"
// Include to make Pdm work for cvf::Color
#include "cafPdmChildField.h"

1
ApplicationLibCode/ProjectDataModel/Annotations/RimReachCircleAnnotation.h
View File

@@ -23,7 +23,6 @@
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmPointer.h"
#include "cafPdmUiOrdering.h"
// Include to make Pdm work for cvf::Color
#include "cafPdmChildField.h"

1
ApplicationLibCode/ProjectDataModel/Annotations/RimReachCircleAnnotationInView.h
View File

@@ -26,7 +26,6 @@
#include "cafPdmObject.h"
#include "cafPdmPointer.h"
#include "cafPdmPtrField.h"
#include "cafPdmUiOrdering.h"
// Include to make Pdm work for cvf::Color
#include "cafPdmChildField.h"

1
ApplicationLibCode/ProjectDataModel/Annotations/RimTextAnnotation.h
View File

@@ -23,7 +23,6 @@
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmPointer.h"
#include "cafPdmUiOrdering.h"
// Include to make Pdm work for cvf::Color
#include "cafPdmChildField.h"

1
ApplicationLibCode/ProjectDataModel/Annotations/RimTextAnnotationInView.h
View File

@@ -24,7 +24,6 @@
#include "cafPdmObject.h"
#include "cafPdmPointer.h"
#include "cafPdmPtrField.h"
#include "cafPdmUiOrdering.h"
// Include to make Pdm work for cvf::Color
#include "cafPdmChildField.h"

1
ApplicationLibCode/ProjectDataModel/Annotations/RimUserDefinedPolylinesAnnotationInView.h
View File

@@ -26,7 +26,6 @@
#include "cafPdmObject.h"
#include "cafPdmPointer.h"
#include "cafPdmPtrField.h"
#include "cafPdmUiOrdering.h"
// Include to make Pdm work for cvf::Color
#include "cafPdmChildField.h"

57
ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilterCollection.cpp
View File

@@ -24,6 +24,7 @@
#include "RimCellIndexFilter.h"
#include "RimCellRangeFilter.h"
#include "RimPolygonFilter.h"
#include "RimProject.h"
#include "RimUserDefinedFilter.h"
#include "RimUserDefinedIndexFilter.h"
#include "RimViewController.h"
@@ -32,8 +33,21 @@
#include "cafPdmFieldReorderCapability.h"
#include "cafPdmFieldScriptingCapability.h"
#include "cafPdmObjectScriptingCapability.h"
#include "cafPdmUiLabelEditor.h"
#include "cvfStructGridGeometryGenerator.h"
namespace caf
{
template <>
void caf::AppEnum<RimCellFilterCollection::CombineFilterModeType>::setUp()
{
addItem( RimCellFilterCollection::AND, "AND", "AND" );
addItem( RimCellFilterCollection::OR, "OR", "OR" );
setDefault( RimCellFilterCollection::AND );
}
} // namespace caf
CAF_PDM_SOURCE_INIT( RimCellFilterCollection, "CellFilterCollection", "RimCellFilterCollection", "CellRangeFilterCollection" );
//--------------------------------------------------------------------------------------------------
@@ -47,6 +61,12 @@ RimCellFilterCollection::RimCellFilterCollection()
CAF_PDM_InitScriptableField( &m_isActive, "Active", true, "Active" );
m_isActive.uiCapability()->setUiHidden( true );
CAF_PDM_InitFieldNoDefault( &m_combineFilterMode, "CombineFilterMode", "" );
CAF_PDM_InitField( &m_combineModeLabel, "CombineModeLabel", QString( "" ), "Combine Polygon and Range Filters Using Operation" );
m_combineModeLabel.uiCapability()->setUiEditorTypeName( caf::PdmUiLabelEditor::uiEditorTypeName() );
m_combineModeLabel.xmlCapability()->disableIO();
CAF_PDM_InitFieldNoDefault( &m_cellFilters, "CellFilters", "Filters" );
caf::PdmFieldReorderCapability::addToField( &m_cellFilters );
@@ -87,6 +107,14 @@ void RimCellFilterCollection::setActive( bool bActive )
updateIconState();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimCellFilterCollection::useAndOperation() const
{
return m_combineFilterMode() == RimCellFilterCollection::AND;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -124,6 +152,12 @@ void RimCellFilterCollection::initAfterRead()
m_cellFilters.push_back( filter );
}
// fallback to OR mode for older projects made without AND support
if ( RimProject::current()->isProjectFileVersionEqualOrOlderThan( "2023.12.0" ) )
{
m_combineFilterMode = RimCellFilterCollection::OR;
}
// Copy by xml serialization does not give a RimCase parent the first time initAfterRead is called here when creating a new a contour
// view from a 3d view. The second time we get called it is ok, so just skip setting up the filter connections if we have no case.
auto rimCase = firstAncestorOrThisOfType<RimCase>();
@@ -161,6 +195,17 @@ caf::PdmFieldHandle* RimCellFilterCollection::objectToggleField()
return &m_isActive;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCellFilterCollection::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{
uiOrdering.add( &m_combineModeLabel );
uiOrdering.add( &m_combineFilterMode );
uiOrdering.skipRemainingFields();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -182,6 +227,18 @@ void RimCellFilterCollection::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTr
updateIconState();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimCellFilterCollection::defineEditorAttribute( const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute )
{
caf::PdmUiLabelEditorAttribute* myAttr = dynamic_cast<caf::PdmUiLabelEditorAttribute*>( attribute );
if ( myAttr )
{
myAttr->m_useSingleWidgetInsteadOfLabelAndEditorWidget = true;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

17
ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilterCollection.h
View File

@@ -49,6 +49,12 @@ class RimCellFilterCollection : public caf::PdmObject
CAF_PDM_HEADER_INIT;
public:
enum CombineFilterModeType
{
OR,
AND
};
RimCellFilterCollection();
~RimCellFilterCollection() override;
@@ -68,6 +74,8 @@ public:
bool isActive() const;
void setActive( bool bActive );
bool useAndOperation() const;
void compoundCellRangeFilter( cvf::CellRangeFilter* cellRangeFilter, size_t gridIndex ) const;
void updateCellVisibilityByIndex( cvf::UByteArray* cellsIncluded, cvf::UByteArray* cellsExcluded, size_t gridIndex ) const;
@@ -87,7 +95,10 @@ public:
protected:
void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
void defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName ) override;
void defineEditorAttribute( const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute ) override;
caf::PdmFieldHandle* objectToggleField() override;
void initAfterRead() override;
@@ -97,8 +108,10 @@ private:
void setAutoName( RimCellFilter* pFilter );
void addFilter( RimCellFilter* pFilter );
caf::PdmChildArrayField<RimCellFilter*> m_cellFilters;
caf::PdmField<bool> m_isActive;
caf::PdmChildArrayField<RimCellFilter*> m_cellFilters;
caf::PdmField<bool> m_isActive;
caf::PdmField<QString> m_combineModeLabel;
caf::PdmField<caf::AppEnum<CombineFilterModeType>> m_combineFilterMode;
caf::PdmChildArrayField<RimCellRangeFilter*> m_rangeFilters_OBSOLETE;
};

2
ApplicationLibCode/ProjectDataModel/CellFilters/RimPolygonFilter.cpp
View File

@@ -330,7 +330,7 @@ void RimPolygonFilter::fieldChangedByUi( const caf::PdmFieldHandle* changedField
{
if ( changedField == &m_editPolygonButton )
{
RimPolygonTools::selectAndActivatePolygonInView( m_cellFilterPolygon(), this );
RimPolygonTools::activate3dEditOfPolygonInView( m_cellFilterPolygon(), this );
m_editPolygonButton = false;

1
ApplicationLibCode/ProjectDataModel/Completions/RimWellPathCompletionSettings.cpp
View File

@@ -27,7 +27,6 @@
#include "cafPdmFieldScriptingCapability.h"
#include "cafPdmObjectScriptingCapability.h"
#include "cafPdmUiLineEditor.h"
#include "cafPdmUiOrdering.h"
#include "cafPdmUiTreeOrdering.h"
namespace caf

1
ApplicationLibCode/ProjectDataModel/CorrelationPlots/RimCorrelationReportPlot.cpp
View File

@@ -33,7 +33,6 @@
#include "RiuQwtPlotWidget.h"
#include "cafAssert.h"
#include "cafPdmUiOrdering.h"
#include "cafPdmUiTreeOrdering.h"
#include <QDebug>

3
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationEnums.h
View File

@@ -39,7 +39,8 @@ enum class Boundary
{
FarSide,
Bottom,
Fault
Fault,
Reservoir
};
enum class ElementSets

2
ApplicationLibCode/ProjectDataModel/Faults/RimFaultReactivationModel.cpp
View File

@@ -113,7 +113,7 @@ RimFaultReactivationModel::RimFaultReactivationModel()
CAF_PDM_InitField( &m_minReservoirCellWidth, "MinReservoirCellWidth", 5.0, "Reservoir Cell Width" );
CAF_PDM_InitField( &m_cellWidthGrowFactor, "CellWidthGrowFactor", 1.15, "Cell Width Grow Factor" );
CAF_PDM_InitField( &m_useLocalCoordinates, "UseLocalCoordinates", false, "Use Local Coordinates" );
CAF_PDM_InitField( &m_useLocalCoordinates, "UseLocalCoordinates", true, "Use Local Coordinates" );
// Time Step Selection
CAF_PDM_InitFieldNoDefault( &m_timeStepFilter, "TimeStepFilter", "Available Time Steps" );

1
ApplicationLibCode/ProjectDataModel/Flow/RimWellRftEnsembleCurveSet.cpp
View File

@@ -31,7 +31,6 @@
#include "RiuQwtPlotWidget.h"
#include "cafPdmUiObjectHandle.h"
#include "cafPdmUiOrdering.h"
#include "cafPdmUiTreeOrdering.h"
#include "cafPdmUiTreeSelectionEditor.h"

1
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechCase.cpp
View File

@@ -63,6 +63,7 @@
#include "cvfVector3.h"
#include <QApplication>
#include <QFileInfo>
#include <array>

3
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechContourMapProjection.cpp
View File

@@ -161,7 +161,8 @@ cvf::ref<cvf::UByteArray> RimGeoMechContourMapProjection::getCellVisibility() co
cellRangeFilter,
&indexIncludeVis,
&indexExcludeVis,
view()->cellFilterCollection()->hasActiveIncludeIndexFilters() );
view()->cellFilterCollection()->hasActiveIncludeIndexFilters(),
view()->cellFilterCollection()->useAndOperation() );
}
if ( view()->propertyFilterCollection()->isActive() )
{

5
ApplicationLibCode/ProjectDataModel/GeoMech/RimGeoMechView.cpp
View File

@@ -1048,10 +1048,7 @@ void RimGeoMechView::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrderin
if ( surfaceInViewCollection() ) uiTreeOrdering.add( surfaceInViewCollection() );
if ( seismicSectionCollection()->shouldBeVisibleInTree() ) uiTreeOrdering.add( seismicSectionCollection() );
if ( RiaApplication::enableDevelopmentFeatures() )
{
uiTreeOrdering.add( m_polygonInViewCollection );
}
uiTreeOrdering.add( m_polygonInViewCollection );
uiTreeOrdering.skipRemainingChildren( true );
}

78
ApplicationLibCode/ProjectDataModel/Intersections/RimExtrudedCurveIntersection.cpp
View File

@@ -457,7 +457,7 @@ void RimExtrudedCurveIntersection::fieldChangedByUi( const caf::PdmFieldHandle*
if ( changedField == &m_simulationWell || changedField == &m_isActive || changedField == &m_type )
{
recomputeSimulationWellBranchData();
rebuildGeometryAndScheduleCreateDisplayModel();
}
if ( changedField == &m_simulationWell || changedField == &m_wellPath || changedField == &m_branchIndex ||
@@ -522,7 +522,7 @@ void RimExtrudedCurveIntersection::fieldChangedByUi( const caf::PdmFieldHandle*
if ( changedField == &m_editPolygonButton )
{
RimPolygonTools::selectAndActivatePolygonInView( m_projectPolygon(), this );
RimPolygonTools::activate3dEditOfPolygonInView( m_projectPolygon(), this );
m_editPolygonButton = false;
@@ -546,10 +546,14 @@ void RimExtrudedCurveIntersection::defineUiOrdering( QString uiConfigName, caf::
else if ( type() == CrossSectionEnum::CS_SIMULATION_WELL )
{
geometryGroup->add( &m_simulationWell );
updateSimulationWellCenterline();
if ( m_simulationWell() && m_simulationWellBranchCenterlines.size() > 1 )
if ( m_simulationWell() )
{
geometryGroup->add( &m_branchIndex );
auto branchCenterLines = simulationWellBranchCenterlines();
if ( branchCenterLines.size() > 1 )
{
geometryGroup->add( &m_branchIndex );
}
}
}
else if ( type() == CrossSectionEnum::CS_POLYLINE )
@@ -705,9 +709,8 @@ QList<caf::PdmOptionItemInfo> RimExtrudedCurveIntersection::calculateValueOption
}
else if ( fieldNeedingOptions == &m_branchIndex )
{
updateSimulationWellCenterline();
size_t branchCount = m_simulationWellBranchCenterlines.size();
auto branchCenterLines = simulationWellBranchCenterlines();
size_t branchCount = branchCenterLines.size();
options.push_back( caf::PdmOptionItemInfo( "All", -1 ) );
@@ -812,14 +815,16 @@ std::vector<std::vector<cvf::Vec3d>> RimExtrudedCurveIntersection::polyLines( cv
{
int branchIndexToUse = branchIndex();
if ( 0 <= branchIndexToUse && branchIndexToUse < static_cast<int>( m_simulationWellBranchCenterlines.size() ) )
auto branchCenterLines = simulationWellBranchCenterlines();
if ( 0 <= branchIndexToUse && branchIndexToUse < static_cast<int>( branchCenterLines.size() ) )
{
lines.push_back( m_simulationWellBranchCenterlines[branchIndexToUse] );
lines.push_back( branchCenterLines[branchIndexToUse] );
}
if ( branchIndexToUse == -1 )
{
lines = m_simulationWellBranchCenterlines;
lines = branchCenterLines;
}
}
}
@@ -900,27 +905,6 @@ std::vector<cvf::Vec3d> RimExtrudedCurveIntersection::polyLinesForExtrusionDirec
return m_customExtrusionPoints;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimExtrudedCurveIntersection::updateSimulationWellCenterline()
{
if ( m_isActive() && type() == CrossSectionEnum::CS_SIMULATION_WELL && m_simulationWell() )
{
if ( m_simulationWellBranchCenterlines.empty() )
{
auto simWells = m_simulationWell()->wellBranchesForVisualization();
const auto& [coords, wellCells] = RigSimulationWellCenterLineCalculator::extractBranchData( simWells );
m_simulationWellBranchCenterlines = coords;
}
}
else
{
m_simulationWellBranchCenterlines.clear();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1019,7 +1003,8 @@ int RimExtrudedCurveIntersection::branchIndex() const
return -1;
}
if ( m_branchIndex >= static_cast<int>( m_simulationWellBranchCenterlines.size() ) )
auto branchCenterLines = simulationWellBranchCenterlines();
if ( m_branchIndex >= static_cast<int>( branchCenterLines.size() ) )
{
return -1;
}
@@ -1279,20 +1264,6 @@ double RimExtrudedCurveIntersection::extentLength()
return m_extentLength();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimExtrudedCurveIntersection::recomputeSimulationWellBranchData()
{
if ( m_type() == CrossSectionEnum::CS_SIMULATION_WELL )
{
m_simulationWellBranchCenterlines.clear();
updateSimulationWellCenterline();
m_crossSectionPartMgr = nullptr;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -1426,3 +1397,16 @@ RimEclipseView* RimExtrudedCurveIntersection::eclipseView() const
{
return firstAncestorOrThisOfType<RimEclipseView>();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::vector<cvf::Vec3d>> RimExtrudedCurveIntersection::simulationWellBranchCenterlines() const
{
if ( !m_simulationWell() ) return {};
const auto simWells = m_simulationWell()->wellBranchesForVisualization();
const auto& [branchCenterLines, wellCells] = RigSimulationWellCenterLineCalculator::extractBranchData( simWells );
return branchCenterLines;
}

4
ApplicationLibCode/ProjectDataModel/Intersections/RimExtrudedCurveIntersection.h
View File

@@ -127,7 +127,6 @@ public:
void setLengthUp( double heightUp );
void setLengthDown( double heightDown );
double extentLength();
void recomputeSimulationWellBranchData();
bool hasDefiningPoints() const;
std::vector<RimSurfaceIntersectionCurve*> surfaceIntersectionCurves() const;
@@ -152,7 +151,6 @@ private:
RimSimWellInViewCollection* simulationWellCollection() const;
void updateAzimuthLine();
void updateSimulationWellCenterline();
void addExtents( std::vector<cvf::Vec3d>& polyLine ) const;
void updateName();
static double azimuthInRadians( cvf::Vec3d vec );
@@ -166,6 +164,8 @@ private:
RimEclipseView* eclipseView() const;
std::vector<std::vector<cvf::Vec3d>> simulationWellBranchCenterlines() const;
private:
caf::PdmField<QString> m_name;

11
ApplicationLibCode/ProjectDataModel/Intersections/RimIntersectionCollection.cpp
View File

@@ -295,17 +295,6 @@ std::vector<RimBoxIntersection*> RimIntersectionCollection::intersectionBoxes()
return m_intersectionBoxes.childrenByType();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimIntersectionCollection::recomputeSimWellBranchData()
{
for ( const auto& intersection : intersections() )
{
intersection->recomputeSimulationWellBranchData();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

1
ApplicationLibCode/ProjectDataModel/Intersections/RimIntersectionCollection.h
View File

@@ -68,7 +68,6 @@ public:
void syncronize2dIntersectionViews();
void scheduleCreateDisplayModelAndRedraw2dIntersectionViews();
void recomputeSimWellBranchData();
bool shouldApplyCellFiltersToIntersections() const;

80
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygon.cpp
View File

@@ -18,14 +18,19 @@
#include "RimPolygon.h"
#include "RiaApplication.h"
#include "RiaColorTools.h"
#include "RigPolyLinesData.h"
#include "RiaApplication.h"
#include "Rim3dView.h"
#include "RimPolygonAppearance.h"
#include "RimPolygonTools.h"
#include "RiuGuiTheme.h"
#include "cafCmdFeatureMenuBuilder.h"
#include "cafPdmUiColorEditor.h"
#include "cafPdmUiPushButtonEditor.h"
#include "cafPdmUiTreeAttributes.h"
@@ -36,6 +41,7 @@ CAF_PDM_SOURCE_INIT( RimPolygon, "RimPolygon" );
//--------------------------------------------------------------------------------------------------
RimPolygon::RimPolygon()
: objectChanged( this )
, coordinatesChanged( this )
{
CAF_PDM_InitObject( "Polygon", ":/PolylinesFromFile16x16.png" );
@@ -78,8 +84,14 @@ void RimPolygon::uiOrderingForLocalPolygon( QString uiConfigName, caf::PdmUiOrde
//--------------------------------------------------------------------------------------------------
void RimPolygon::appendMenuItems( caf::CmdFeatureMenuBuilder& menuBuilder ) const
{
menuBuilder << "RicDuplicatePolygonFeature";
menuBuilder << "RicNewPolygonIntersectionFeature";
menuBuilder << "RicNewPolygonFilterFeature";
menuBuilder << "Separator";
menuBuilder << "RicExportPolygonCsvFeature";
menuBuilder << "RicExportPolygonPolFeature";
menuBuilder << "Separator";
menuBuilder << "RicSimplifyPolygonFeature";
}
//--------------------------------------------------------------------------------------------------
@@ -88,8 +100,6 @@ void RimPolygon::appendMenuItems( caf::CmdFeatureMenuBuilder& menuBuilder ) cons
void RimPolygon::setPointsInDomainCoords( const std::vector<cvf::Vec3d>& points )
{
m_pointsInDomainCoords = points;
objectChanged.send();
}
//--------------------------------------------------------------------------------------------------
@@ -132,6 +142,30 @@ bool RimPolygon::isReadOnly() const
return m_isReadOnly();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygon::disableStorageOfPolygonPoints()
{
m_pointsInDomainCoords.xmlCapability()->setIOWritable( false );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Color3f RimPolygon::color() const
{
return m_appearance->lineColor();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygon::setColor( const cvf::Color3f& color )
{
m_appearance->setLineColor( color );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -158,13 +192,14 @@ void RimPolygon::fieldChangedByUi( const caf::PdmFieldHandle* changedField, cons
{
if ( changedField == &m_pointsInDomainCoords )
{
coordinatesChanged.send();
objectChanged.send();
}
if ( changedField == &m_editPolygonButton )
{
auto activeView = RiaApplication::instance()->activeReservoirView();
RimPolygonTools::selectAndActivatePolygonInView( this, activeView );
RimPolygonTools::activate3dEditOfPolygonInView( this, activeView );
m_editPolygonButton = false;
@@ -189,18 +224,51 @@ void RimPolygon::defineEditorAttribute( const caf::PdmFieldHandle* field, QStrin
{
if ( auto attrib = dynamic_cast<caf::PdmUiPushButtonEditorAttribute*>( attribute ) )
{
attrib->m_buttonText = "Edit in Active View";
if ( m_isReadOnly() )
{
attrib->m_buttonText = "Select in Active View";
}
else
{
attrib->m_buttonText = "Edit in Active View";
}
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygon::onColorTagClicked( const SignalEmitter* emitter, size_t index )
{
QColor sourceColor = RiaColorTools::toQColor( color() );
QColor newColor = caf::PdmUiColorEditor::getColor( sourceColor );
if ( newColor.isValid() && newColor != sourceColor )
{
setColor( RiaColorTools::fromQColorTo3f( newColor ) );
objectChanged.send();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygon::defineObjectEditorAttribute( QString uiConfigName, caf::PdmUiEditorAttribute* attribute )
{
if ( auto* treeItemAttribute = dynamic_cast<caf::PdmUiTreeViewItemAttribute*>( attribute ) )
{
auto tag = caf::PdmUiTreeViewItemAttribute::createTag( RiaColorTools::toQColor( color() ),
RiuGuiTheme::getColorByVariableName( "backgroundColor1" ),
"---" );
tag->clicked.connect( this, &RimPolygon::onColorTagClicked );
treeItemAttribute->tags.push_back( std::move( tag ) );
}
if ( m_isReadOnly )
{
caf::PdmUiTreeViewItemAttribute::createTagIfTreeViewItemAttribute( attribute, ":/padlock.svg" );
caf::PdmUiTreeViewItemAttribute::appendTagToTreeViewItemAttribute( attribute, ":/padlock.svg" );
}
}

12
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygon.h
View File

@@ -24,6 +24,7 @@
#include "cafPdmChildField.h"
#include "cafPdmFieldCvfVec3d.h"
#include "cvfColor3.h"
#include "cvfVector3.h"
class RimPolygonAppearance;
@@ -39,6 +40,7 @@ class RimPolygon : public RimNamedObject, public RimPolylinesDataInterface
public:
caf::Signal<> objectChanged;
caf::Signal<> coordinatesChanged;
public:
RimPolygon();
@@ -51,13 +53,19 @@ public:
void setReadOnly( bool isReadOnly );
bool isReadOnly() const;
void disableStorageOfPolygonPoints();
cvf::Color3f color() const;
void setColor( const cvf::Color3f& color );
cvf::ref<RigPolyLinesData> polyLinesData() const override;
void uiOrderingForLocalPolygon( QString uiConfigName, caf::PdmUiOrdering& uiOrdering );
void appendMenuItems( caf::CmdFeatureMenuBuilder& menuBuilder ) const override;
void defineObjectEditorAttribute( QString uiConfigName, caf::PdmUiEditorAttribute* attribute ) override;
void onColorTagClicked( const SignalEmitter* emitter, size_t index );
protected:
private:
void defineObjectEditorAttribute( 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;
void childFieldChangedByUi( const caf::PdmFieldHandle* changedChildField ) override;

20
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonAppearance.cpp
View File

@@ -85,8 +85,8 @@ RimPolygonAppearance::RimPolygonAppearance()
CAF_PDM_InitField( &m_lineThickness, "LineThickness", 3, "Line Thickness" );
CAF_PDM_InitField( &m_sphereRadiusFactor, "SphereRadiusFactor", 0.15, "Sphere Radius Factor" );
CAF_PDM_InitField( &m_lineColor, "LineColor", cvf::Color3f( cvf::Color3f::WHITE ), "Line Color" );
CAF_PDM_InitField( &m_sphereColor, "SphereColor", cvf::Color3f( cvf::Color3f::WHITE ), "Sphere Color" );
CAF_PDM_InitField( &m_lineColor, "LineColor", cvf::Color3f( cvf::Color3f::ORANGE ), "Line Color" );
CAF_PDM_InitField( &m_sphereColor, "SphereColor", cvf::Color3f( cvf::Color3f::ORANGE ), "Sphere Color" );
CAF_PDM_InitField( &m_polygonPlaneDepth, "PolygonPlaneDepth", 0.0, "Polygon Plane Depth" );
CAF_PDM_InitField( &m_lockPolygonToPlane, "LockPolygon", false, "Lock Polygon to Plane" );
@@ -123,6 +123,22 @@ bool RimPolygonAppearance::isClosed() const
return m_isClosed();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Color3f RimPolygonAppearance::lineColor() const
{
return m_lineColor();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonAppearance::setLineColor( const cvf::Color3f& color )
{
m_lineColor = color;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

3
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonAppearance.h
View File

@@ -37,6 +37,9 @@ public:
void setIsClosed( bool isClosed );
bool isClosed() const;
cvf::Color3f lineColor() const;
void setLineColor( const cvf::Color3f& color );
public:
RimPolygonAppearance();

62
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonCollection.cpp
View File

@@ -23,6 +23,8 @@
#include "RimPolygonFile.h"
#include "RimProject.h"
#include "cafCmdFeatureMenuBuilder.h"
CAF_PDM_SOURCE_INIT( RimPolygonCollection, "RimPolygonCollection" );
//--------------------------------------------------------------------------------------------------
@@ -30,7 +32,7 @@ CAF_PDM_SOURCE_INIT( RimPolygonCollection, "RimPolygonCollection" );
//--------------------------------------------------------------------------------------------------
RimPolygonCollection::RimPolygonCollection()
{
CAF_PDM_InitObject( "Polygons (Under construction)", ":/PolylinesFromFile16x16.png" );
CAF_PDM_InitObject( "Polygons", ":/PolylinesFromFile16x16.png" );
CAF_PDM_InitFieldNoDefault( &m_polygons, "Polygons", "Polygons" );
CAF_PDM_InitFieldNoDefault( &m_polygonFiles, "PolygonFiles", "Polygon Files" );
@@ -50,10 +52,20 @@ void RimPolygonCollection::loadData()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPolygon* RimPolygonCollection::appendUserDefinedPolygon()
RimPolygon* RimPolygonCollection::createUserDefinedPolygon()
{
auto newPolygon = new RimPolygon();
newPolygon->setName( "Polygon " + QString::number( userDefinedPolygons().size() + 1 ) );
return newPolygon;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPolygon* RimPolygonCollection::appendUserDefinedPolygon()
{
auto newPolygon = createUserDefinedPolygon();
addUserDefinedPolygon( newPolygon );
return newPolygon;
@@ -66,7 +78,7 @@ void RimPolygonCollection::addUserDefinedPolygon( RimPolygon* polygon )
{
m_polygons().push_back( polygon );
connectSignals( polygon );
connectPolygonSignals( polygon );
updateViewTreeItems();
scheduleRedrawViews();
@@ -90,6 +102,8 @@ void RimPolygonCollection::addPolygonFile( RimPolygonFile* polygonFile )
{
m_polygonFiles().push_back( polygonFile );
connectPolygonFileSignals( polygonFile );
updateViewTreeItems();
scheduleRedrawViews();
}
@@ -150,6 +164,15 @@ void RimPolygonCollection::childFieldChangedByUi( const caf::PdmFieldHandle* cha
scheduleRedrawViews();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonCollection::appendMenuItems( caf::CmdFeatureMenuBuilder& menuBuilder ) const
{
menuBuilder << "RicCreatePolygonFeature";
menuBuilder << "RicImportPolygonFileFeature";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -178,19 +201,39 @@ void RimPolygonCollection::scheduleRedrawViews()
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonCollection::connectSignals( RimPolygon* polygon )
void RimPolygonCollection::connectPolygonSignals( RimPolygon* polygon )
{
if ( polygon )
{
polygon->objectChanged.connect( this, &RimPolygonCollection::onObjectChanged );
polygon->objectChanged.connect( this, &RimPolygonCollection::onPolygonChanged );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonCollection::onObjectChanged( const caf::SignalEmitter* emitter )
void RimPolygonCollection::connectPolygonFileSignals( RimPolygonFile* polygonFile )
{
if ( polygonFile )
{
polygonFile->objectChanged.connect( this, &RimPolygonCollection::onPolygonFileChanged );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonCollection::onPolygonChanged( const caf::SignalEmitter* emitter )
{
scheduleRedrawViews();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonCollection::onPolygonFileChanged( const caf::SignalEmitter* emitter )
{
updateViewTreeItems();
scheduleRedrawViews();
}
@@ -201,6 +244,11 @@ void RimPolygonCollection::initAfterRead()
{
for ( auto& p : m_polygons() )
{
connectSignals( p );
connectPolygonSignals( p );
}
for ( auto& pf : m_polygonFiles() )
{
connectPolygonFileSignals( pf );
}
}

16
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonCollection.h
View File

@@ -36,6 +36,7 @@ public:
RimPolygonCollection();
void loadData();
RimPolygon* createUserDefinedPolygon();
RimPolygon* appendUserDefinedPolygon();
void addUserDefinedPolygon( RimPolygon* polygon );
void deleteUserDefinedPolygons();
@@ -46,15 +47,18 @@ public:
std::vector<RimPolygonFile*> polygonFiles() const;
std::vector<RimPolygon*> allPolygons() const;
void onChildDeleted( caf::PdmChildArrayFieldHandle* childArray, std::vector<caf::PdmObjectHandle*>& referringObjects ) override;
void childFieldChangedByUi( const caf::PdmFieldHandle* changedChildField ) override;
private:
void onChildDeleted( caf::PdmChildArrayFieldHandle* childArray, std::vector<caf::PdmObjectHandle*>& referringObjects ) override;
void childFieldChangedByUi( const caf::PdmFieldHandle* changedChildField ) override;
void appendMenuItems( caf::CmdFeatureMenuBuilder& menuBuilder ) const override;
void updateViewTreeItems();
void scheduleRedrawViews();
void connectSignals( RimPolygon* polygon );
void onObjectChanged( const caf::SignalEmitter* emitter );
void connectPolygonSignals( RimPolygon* polygon );
void connectPolygonFileSignals( RimPolygonFile* polygonFile );
void onPolygonChanged( const caf::SignalEmitter* emitter );
void onPolygonFileChanged( const caf::SignalEmitter* emitter );
private:
caf::PdmChildArrayField<RimPolygon*> m_polygons;

142
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonFile.cpp
View File

@@ -17,14 +17,25 @@
/////////////////////////////////////////////////////////////////////////////////
#include "RimPolygonFile.h"
#include "RiaLogging.h"
#include "RifPolygonReader.h"
#include "RimPolygon.h"
#include "cafCmdFeatureMenuBuilder.h"
#include "cafPdmUiTreeAttributes.h"
#include <QFileInfo>
CAF_PDM_SOURCE_INIT( RimPolygonFile, "RimPolygonFileFile" );
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPolygonFile::RimPolygonFile()
: objectChanged( this )
{
CAF_PDM_InitObject( "PolygonFile", ":/PolylinesFromFile16x16.png" );
@@ -34,12 +45,48 @@ RimPolygonFile::RimPolygonFile()
setDeletable( true );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonFile::setFileName( const QString& fileName )
{
m_fileName = fileName;
updateName();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonFile::loadData()
{
loadPolygonsFromFile();
auto polygonsFromFile = importDataFromFile( m_fileName().path() );
if ( m_polygons.size() == polygonsFromFile.size() )
{
for ( size_t i = 0; i < m_polygons.size(); i++ )
{
auto projectPoly = m_polygons()[i];
auto filePoly = polygonsFromFile[i];
projectPoly->setPointsInDomainCoords( filePoly->pointsInDomainCoords() );
delete filePoly;
}
}
else
{
m_polygons.deleteChildren();
m_polygons.setValue( polygonsFromFile );
}
if ( polygonsFromFile.empty() )
{
RiaLogging::warning( "No polygons found in file: " + m_fileName().path() );
}
else
{
RiaLogging::info( QString( "Imported %1 polygons from file: " ).arg( polygonsFromFile.size() ) + m_fileName().path() );
}
}
//--------------------------------------------------------------------------------------------------
@@ -50,11 +97,36 @@ std::vector<RimPolygon*> RimPolygonFile::polygons() const
return m_polygons.childrenByType();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimPolygonFile::name() const
{
QString nameCandidate = RimNamedObject::name();
if ( !nameCandidate.isEmpty() )
{
return nameCandidate;
}
auto fileName = m_fileName().path();
if ( fileName.isEmpty() )
{
return "Polygon File";
}
QFileInfo fileInfo( fileName );
return fileInfo.fileName();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonFile::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{
uiOrdering.add( nameField() );
uiOrdering.add( &m_fileName );
uiOrdering.skipRemainingFields();
}
//--------------------------------------------------------------------------------------------------
@@ -62,21 +134,71 @@ void RimPolygonFile::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering&
//--------------------------------------------------------------------------------------------------
void RimPolygonFile::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
{
loadPolygonsFromFile();
if ( changedField == &m_fileName )
{
updateName();
m_polygons.deleteChildren();
loadData();
}
objectChanged.send();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonFile::loadPolygonsFromFile()
std::vector<RimPolygon*> RimPolygonFile::importDataFromFile( const QString& fileName )
{
// m_polygons()->deletePolygons();
QString errorMessages;
auto filePolygons = RifPolygonReader::parsePolygonFile( fileName, &errorMessages );
auto polygon = new RimPolygon();
polygon->setName( "Polygon 1" );
m_polygons.push_back( polygon );
std::vector<RimPolygon*> polygons;
polygon = new RimPolygon();
polygon->setName( "Polygon 2" );
m_polygons.push_back( polygon );
for ( const auto& [polygonId, filePolygon] : filePolygons )
{
auto polygon = new RimPolygon();
polygon->disableStorageOfPolygonPoints();
polygon->setReadOnly( true );
int id = ( polygonId != -1 ) ? polygonId : static_cast<int>( polygons.size() + 1 );
polygon->setName( QString( "Polygon %1" ).arg( id ) );
polygon->setPointsInDomainCoords( filePolygon );
polygons.push_back( polygon );
}
if ( !errorMessages.isEmpty() )
{
RiaLogging::error( errorMessages );
}
return polygons;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonFile::updateName()
{
QFileInfo fileInfo( m_fileName().path() );
setName( fileInfo.fileName() );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonFile::appendMenuItems( caf::CmdFeatureMenuBuilder& menuBuilder ) const
{
menuBuilder << "RicReloadPolygonFileFeature";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonFile::defineObjectEditorAttribute( QString uiConfigName, caf::PdmUiEditorAttribute* attribute )
{
if ( m_polygons.empty() )
{
caf::PdmUiTreeViewItemAttribute::appendTagToTreeViewItemAttribute( attribute, ":/warning.svg" );
}
}

12
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonFile.h
View File

@@ -28,19 +28,29 @@ class RimPolygonFile : public RimNamedObject
{
CAF_PDM_HEADER_INIT;
public:
caf::Signal<> objectChanged;
public:
RimPolygonFile();
void setFileName( const QString& fileName );
void loadData();
std::vector<RimPolygon*> polygons() const;
QString name() const override;
protected:
void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
void appendMenuItems( caf::CmdFeatureMenuBuilder& menuBuilder ) const override;
void defineObjectEditorAttribute( QString uiConfigName, caf::PdmUiEditorAttribute* attribute ) override;
private:
void loadPolygonsFromFile();
static std::vector<RimPolygon*> importDataFromFile( const QString& fileName );
void updateName();
private:
caf::PdmField<caf::FilePath> m_fileName;

62
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonInView.cpp
View File

@@ -18,6 +18,8 @@
#include "RimPolygonInView.h"
#include "RiaColorTools.h"
#include "RigPolyLinesData.h"
#include "Rim3dView.h"
@@ -70,6 +72,7 @@ RimPolygonInView::RimPolygonInView()
m_targets.uiCapability()->setUiTreeChildrenHidden( true );
m_targets.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::TOP );
m_targets.uiCapability()->setCustomContextMenuEnabled( true );
m_targets.xmlCapability()->disableIO();
setUi3dEditorTypeName( RicPolyline3dEditor::uiEditorTypeName() );
}
@@ -89,6 +92,8 @@ void RimPolygonInView::setPolygon( RimPolygon* polygon )
{
m_polygon = polygon;
connectSignals();
updateTargetsFromPolygon();
}
@@ -231,6 +236,18 @@ void RimPolygonInView::updatePolygonFromTargets()
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonInView::connectSignals()
{
if ( m_polygon )
{
m_polygon->objectChanged.connect( this, &RimPolygonInView::onObjectChanged );
m_polygon->coordinatesChanged.connect( this, &RimPolygonInView::onCoordinatesChanged );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -322,9 +339,23 @@ void RimPolygonInView::defineObjectEditorAttribute( QString uiConfigName, caf::P
attrib->enablePicking = m_enablePicking;
}
if ( m_polygon() && m_polygon->isReadOnly() )
if ( m_polygon() )
{
caf::PdmUiTreeViewItemAttribute::createTagIfTreeViewItemAttribute( attribute, ":/padlock.svg" );
if ( auto* treeItemAttribute = dynamic_cast<caf::PdmUiTreeViewItemAttribute*>( attribute ) )
{
auto tag = caf::PdmUiTreeViewItemAttribute::createTag( RiaColorTools::toQColor( m_polygon->color() ),
RiuGuiTheme::getColorByVariableName( "backgroundColor1" ),
"---" );
tag->clicked.connect( m_polygon(), &RimPolygon::onColorTagClicked );
treeItemAttribute->tags.push_back( std::move( tag ) );
}
if ( m_polygon->isReadOnly() )
{
caf::PdmUiTreeViewItemAttribute::appendTagToTreeViewItemAttribute( attribute, ":/padlock.svg" );
}
}
}
@@ -346,6 +377,33 @@ void RimPolygonInView::appendMenuItems( caf::CmdFeatureMenuBuilder& menuBuilder
if ( m_polygon() ) m_polygon->appendMenuItems( menuBuilder );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonInView::onObjectChanged( const caf::SignalEmitter* emitter )
{
updateVisualization();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonInView::onCoordinatesChanged( const caf::SignalEmitter* emitter )
{
updateTargetsFromPolygon();
updateConnectedEditors();
updateVisualization();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonInView::initAfterRead()
{
connectSignals();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

6
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonInView.h
View File

@@ -51,6 +51,7 @@ public:
RimPolygon* polygon() const;
void setPolygon( RimPolygon* polygon );
void updateTargetsFromPolygon();
void appendPartsToModel( cvf::ModelBasicList* model, const caf::DisplayCoordTransform* scaleTransform, const cvf::BoundingBox& boundingBox );
void enablePicking( bool enable );
@@ -79,12 +80,15 @@ protected:
void defineEditorAttribute( const caf::PdmFieldHandle* field, QString uiConfigName, caf::PdmUiEditorAttribute* attribute ) override;
void defineCustomContextMenu( const caf::PdmFieldHandle* fieldNeedingMenu, QMenu* menu, QWidget* fieldEditorWidget ) override;
void appendMenuItems( caf::CmdFeatureMenuBuilder& menuBuilder ) const override;
void onObjectChanged( const caf::SignalEmitter* emitter );
void onCoordinatesChanged( const caf::SignalEmitter* emitter );
void initAfterRead() override;
private:
void updateNameField();
void updatePolygonFromTargets();
void updateTargetsFromPolygon();
void connectSignals();
private:
caf::PdmPtrField<RimPolygon*> m_polygon;

248
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonInViewCollection.cpp
View File

@@ -21,6 +21,7 @@
#include "Rim3dView.h"
#include "RimPolygon.h"
#include "RimPolygonCollection.h"
#include "RimPolygonFile.h"
#include "RimPolygonInView.h"
#include "RimTools.h"
@@ -31,58 +32,74 @@ CAF_PDM_SOURCE_INIT( RimPolygonInViewCollection, "RimPolygonInViewCollection" );
//--------------------------------------------------------------------------------------------------
RimPolygonInViewCollection::RimPolygonInViewCollection()
{
CAF_PDM_InitObject( "Polygons (Under construction)", ":/PolylinesFromFile16x16.png" );
CAF_PDM_InitObject( "Polygons", ":/PolylinesFromFile16x16.png" );
CAF_PDM_InitFieldNoDefault( &m_polygons, "Polygons", "Polygons" );
CAF_PDM_InitFieldNoDefault( &m_polygonsInView, "Polygons", "Polygons" );
CAF_PDM_InitFieldNoDefault( &m_collectionsInView, "Collections", "Collections" );
nameField()->uiCapability()->setUiHidden( true );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonInViewCollection::syncPolygonsInView()
void RimPolygonInViewCollection::updateFromPolygonCollection()
{
std::vector<RimPolygonInView*> existingPolygonsInView = m_polygons.childrenByType();
m_polygons.clearWithoutDelete();
auto polygonCollection = RimTools::polygonCollection();
if ( polygonCollection )
{
std::vector<RimPolygonInView*> newPolygonsInView;
for ( auto polygon : polygonCollection->allPolygons() )
{
auto it = std::find_if( existingPolygonsInView.begin(),
existingPolygonsInView.end(),
[polygon]( auto* polygonInView ) { return polygonInView->polygon() == polygon; } );
if ( it != existingPolygonsInView.end() )
{
newPolygonsInView.push_back( *it );
existingPolygonsInView.erase( it );
}
else
{
auto polygonInView = new RimPolygonInView();
polygonInView->setPolygon( polygon );
newPolygonsInView.push_back( polygonInView );
}
}
m_polygons.setValue( newPolygonsInView );
}
for ( auto polyInView : existingPolygonsInView )
{
delete polyInView;
}
updateAllViewItems();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimPolygonInView*> RimPolygonInViewCollection::polygonsInView() const
std::vector<RimPolygonInView*> RimPolygonInViewCollection::visiblePolygonsInView() const
{
return m_polygons.childrenByType();
if ( !m_isChecked ) return {};
std::vector<RimPolygonInView*> polys = m_polygonsInView.childrenByType();
for ( auto coll : m_collectionsInView )
{
if ( !coll->isChecked() ) continue;
auto other = coll->visiblePolygonsInView();
polys.insert( polys.end(), other.begin(), other.end() );
}
return polys;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<RimPolygonInView*> RimPolygonInViewCollection::allPolygonsInView() const
{
std::vector<RimPolygonInView*> polys = m_polygonsInView.childrenByType();
for ( auto coll : m_collectionsInView )
{
auto other = coll->visiblePolygonsInView();
polys.insert( polys.end(), other.begin(), other.end() );
}
return polys;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonInViewCollection::setPolygonFile( RimPolygonFile* polygonFile )
{
m_polygonFile = polygonFile;
updateName();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPolygonFile* RimPolygonInViewCollection::polygonFile() const
{
return m_polygonFile;
}
//--------------------------------------------------------------------------------------------------
@@ -90,11 +107,11 @@ std::vector<RimPolygonInView*> RimPolygonInViewCollection::polygonsInView() cons
//--------------------------------------------------------------------------------------------------
void RimPolygonInViewCollection::fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue )
{
RimCheckableObject::fieldChangedByUi( changedField, oldValue, newValue );
RimCheckableNamedObject::fieldChangedByUi( changedField, oldValue, newValue );
if ( changedField == &m_isChecked )
{
for ( auto poly : polygonsInView() )
for ( auto poly : visiblePolygonsInView() )
{
poly->updateConnectedEditors();
}
@@ -105,3 +122,152 @@ void RimPolygonInViewCollection::fieldChangedByUi( const caf::PdmFieldHandle* ch
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonInViewCollection::updateAllViewItems()
{
// Based on the same concept as RimSurfaceInViewCollection
syncCollectionsWithView();
syncPolygonsWithView();
updateConnectedEditors();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonInViewCollection::syncCollectionsWithView()
{
// Based on the same concept as RimSurfaceInViewCollection
auto colls = m_collectionsInView.childrenByType();
for ( auto coll : colls )
{
if ( !coll->polygonFile() )
{
m_collectionsInView.removeChild( coll );
delete coll;
}
}
if ( !m_polygonFile )
{
std::vector<RimPolygonInViewCollection*> orderedColls;
if ( auto polygonCollection = RimTools::polygonCollection() )
{
std::vector<RimPolygonInView*> newPolygonsInView;
for ( auto polygonFile : polygonCollection->polygonFiles() )
{
if ( polygonFile->polygons().empty() ) continue;
auto viewPolygonFile = getCollectionInViewForPolygonFile( polygonFile );
if ( viewPolygonFile == nullptr )
{
auto newColl = new RimPolygonInViewCollection();
newColl->setPolygonFile( polygonFile );
orderedColls.push_back( newColl );
}
else
{
viewPolygonFile->updateName();
orderedColls.push_back( viewPolygonFile );
}
}
}
m_collectionsInView.clearWithoutDelete();
for ( auto viewColl : orderedColls )
{
m_collectionsInView.push_back( viewColl );
viewColl->updateAllViewItems();
}
}
updateName();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonInViewCollection::syncPolygonsWithView()
{
std::vector<RimPolygonInView*> existingPolygonsInView = m_polygonsInView.childrenByType();
m_polygonsInView.clearWithoutDelete();
std::vector<RimPolygon*> polygons;
if ( m_polygonFile )
{
polygons = m_polygonFile->polygons();
}
else
{
auto polygonCollection = RimTools::polygonCollection();
polygons = polygonCollection->userDefinedPolygons();
}
std::vector<RimPolygonInView*> newPolygonsInView;
for ( auto polygon : polygons )
{
auto it = std::find_if( existingPolygonsInView.begin(),
existingPolygonsInView.end(),
[polygon]( auto* polygonInView ) { return polygonInView->polygon() == polygon; } );
if ( it != existingPolygonsInView.end() )
{
newPolygonsInView.push_back( *it );
existingPolygonsInView.erase( it );
( *it )->updateTargetsFromPolygon();
}
else
{
auto polygonInView = new RimPolygonInView();
polygonInView->setPolygon( polygon );
newPolygonsInView.push_back( polygonInView );
}
}
m_polygonsInView.setValue( newPolygonsInView );
for ( auto polyInView : existingPolygonsInView )
{
delete polyInView;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonInViewCollection::updateName()
{
QString name = "Polygons";
if ( m_polygonFile )
{
name = m_polygonFile->name();
}
setName( name );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimPolygonInViewCollection* RimPolygonInViewCollection::getCollectionInViewForPolygonFile( const RimPolygonFile* polygonFile ) const
{
for ( auto collInView : m_collectionsInView )
{
if ( collInView->polygonFile() == polygonFile )
{
return collInView;
}
}
return nullptr;
}

28
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonInViewCollection.h
View File

@@ -18,29 +18,47 @@
#pragma once
#include "RimCheckableObject.h"
#include "RimCheckableNamedObject.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmPointer.h"
class RimPolygonInView;
class RimPolygonFile;
class RimPolygon;
//==================================================================================================
///
///
//==================================================================================================
class RimPolygonInViewCollection : public RimCheckableObject
class RimPolygonInViewCollection : public RimCheckableNamedObject
{
CAF_PDM_HEADER_INIT;
public:
RimPolygonInViewCollection();
void syncPolygonsInView();
void updateFromPolygonCollection();
std::vector<RimPolygonInView*> polygonsInView() const;
std::vector<RimPolygonInView*> visiblePolygonsInView() const;
std::vector<RimPolygonInView*> allPolygonsInView() const;
private:
void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
void setPolygonFile( RimPolygonFile* polygonFile );
RimPolygonFile* polygonFile() const;
void updateAllViewItems();
void syncCollectionsWithView();
void syncPolygonsWithView();
void updateName();
RimPolygonInViewCollection* getCollectionInViewForPolygonFile( const RimPolygonFile* polygonFile ) const;
private:
caf::PdmChildArrayField<RimPolygonInView*> m_polygons;
caf::PdmChildArrayField<RimPolygonInView*> m_polygonsInView;
caf::PdmChildArrayField<RimPolygonInViewCollection*> m_collectionsInView;
caf::PdmPointer<RimPolygonFile> m_polygonFile;
};

114
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonTools.cpp
View File

@@ -18,6 +18,10 @@
#include "RimPolygonTools.h"
#include "RiaPreferences.h"
#include "RifCsvDataTableFormatter.h"
#include "RimGridView.h"
#include "RimOilField.h"
#include "RimPolygon.h"
@@ -28,10 +32,13 @@
#include "Riu3DMainWindowTools.h"
#include <QFile>
#include <QTextStream>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonTools::selectAndActivatePolygonInView( RimPolygon* polygon, caf::PdmObject* sourceObject )
void RimPolygonTools::activate3dEditOfPolygonInView( RimPolygon* polygon, caf::PdmObject* sourceObject )
{
auto polygonInView = findPolygonInView( polygon, sourceObject );
if ( polygonInView )
@@ -41,6 +48,109 @@ void RimPolygonTools::selectAndActivatePolygonInView( RimPolygon* polygon, caf::
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimPolygonTools::selectPolygonInView( RimPolygon* polygon, caf::PdmObject* sourceObject )
{
auto polygonInView = findPolygonInView( polygon, sourceObject );
if ( polygonInView )
{
Riu3DMainWindowTools::selectAsCurrentItem( polygonInView );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimPolygonTools::exportPolygonCsv( const RimPolygon* polygon, const QString& filePath )
{
if ( !polygon ) return false;
QFile file( filePath );
if ( !file.open( QIODevice::WriteOnly | QIODevice::Text ) )
{
return false;
}
QTextStream out( &file );
QString fieldSeparator = RiaPreferences::current()->csvTextExportFieldSeparator;
RifCsvDataTableFormatter formatter( out, fieldSeparator );
const int precision = 2;
std::vector<RifTextDataTableColumn> header;
header.emplace_back( "X", RifTextDataTableDoubleFormatting( RIF_FLOAT, precision ) );
header.emplace_back( "Y", RifTextDataTableDoubleFormatting( RIF_FLOAT, precision ) );
header.emplace_back( "Z", RifTextDataTableDoubleFormatting( RIF_FLOAT, precision ) );
formatter.header( header );
for ( const auto& point : polygon->pointsInDomainCoords() )
{
formatter.add( point.x() );
formatter.add( point.y() );
formatter.add( -point.z() );
formatter.rowCompleted();
}
formatter.tableCompleted();
file.close();
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimPolygonTools::exportPolygonPol( const RimPolygon* polygon, const QString& filePath )
{
if ( !polygon ) return false;
QFile file( filePath );
if ( !file.open( QIODevice::WriteOnly | QIODevice::Text ) ) return false;
QTextStream out( &file );
QString fieldSeparator = " ";
RifCsvDataTableFormatter formatter( out, fieldSeparator );
const int precision = 2;
std::vector<RifTextDataTableColumn> header;
header.emplace_back( " ", RifTextDataTableDoubleFormatting( RIF_FLOAT, precision ) );
header.emplace_back( " ", RifTextDataTableDoubleFormatting( RIF_FLOAT, precision ) );
header.emplace_back( " ", RifTextDataTableDoubleFormatting( RIF_FLOAT, precision ) );
formatter.header( header );
for ( const auto& point : polygon->pointsInDomainCoords() )
{
formatter.add( point.x() );
formatter.add( point.y() );
formatter.add( -point.z() );
formatter.rowCompleted();
}
const double endOfPolygon = 999.0;
formatter.add( endOfPolygon );
formatter.add( endOfPolygon );
formatter.add( endOfPolygon );
formatter.rowCompleted();
formatter.tableCompleted();
file.close();
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimPolygonTools::polygonCacheName()
{
return "POLYGON";
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@@ -55,7 +165,7 @@ RimPolygonInView* RimPolygonTools::findPolygonInView( RimPolygon* polygon, caf::
{
auto polyCollection = gridView->polygonInViewCollection();
for ( auto polygonInView : polyCollection->polygonsInView() )
for ( auto polygonInView : polyCollection->allPolygonsInView() )
{
if ( polygonInView && polygonInView->polygon() == polygon )
{

9
ApplicationLibCode/ProjectDataModel/Polygons/RimPolygonTools.h
View File

@@ -21,6 +21,8 @@
class RimPolygon;
class RimPolygonInView;
class QString;
namespace caf
{
class PdmObject;
@@ -29,7 +31,12 @@ class PdmObject;
class RimPolygonTools
{
public:
static void selectAndActivatePolygonInView( RimPolygon* polygon, caf::PdmObject* sourceObject );
static void activate3dEditOfPolygonInView( RimPolygon* polygon, caf::PdmObject* sourceObject );
static void selectPolygonInView( RimPolygon* polygon, caf::PdmObject* sourceObject );
static bool exportPolygonCsv( const RimPolygon* polygon, const QString& filePath );
static bool exportPolygonPol( const RimPolygon* polygon, const QString& filePath );
static QString polygonCacheName();
private:
static RimPolygonInView* findPolygonInView( RimPolygon* polygon, caf::PdmObject* sourceObject );

1
ApplicationLibCode/ProjectDataModel/ProcessControl/RimProcess.cpp
View File

@@ -23,6 +23,7 @@
#include "cafPdmFieldCapability.h"
#include <QApplication>
#include <QProcess>
#include <QProcessEnvironment>

11
ApplicationLibCode/ProjectDataModel/Rim3dView.cpp
View File

@@ -1706,18 +1706,19 @@ void Rim3dView::appendMeasurementToModel()
{
if ( !nativeOrOverrideViewer() ) return;
cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
if ( frameScene )
const cvf::String name = "Measurement";
cvf::Scene* scene = nativeOrOverrideViewer()->currentScene( isUsingOverrideViewer() );
if ( scene )
{
cvf::String name = "Measurement";
this->removeModelByName( frameScene, name );
Rim3dView::removeModelByName( scene, name );
cvf::ref<cvf::ModelBasicList> model = new cvf::ModelBasicList;
model->setName( name );
addMeasurementToModel( model.p() );
frameScene->addModel( model.p() );
scene->addModel( model.p() );
}
}

6
ApplicationLibCode/ProjectDataModel/RimContextCommandBuilder.cpp
View File

@@ -23,7 +23,6 @@
#include "PlotTemplates/RimPlotTemplateFileItem.h"
#include "PlotTemplates/RimPlotTemplateFolderItem.h"
#include "Polygons/RimPolygonCollection.h"
#include "Rim3dOverlayInfoConfig.h"
#include "Rim3dWellLogCurveCollection.h"
#include "Rim3dWellLogExtractionCurve.h"
@@ -1139,11 +1138,6 @@ caf::CmdFeatureMenuBuilder RimContextCommandBuilder::commandsFromSelection()
{
menuBuilder << "RicAddGridCalculationFeature";
}
else if ( dynamic_cast<RimPolygonCollection*>( firstUiItem ) )
{
menuBuilder << "RicNewPolygonFeature";
menuBuilder << "RicNewPolygonFileFeature";
}
if ( dynamic_cast<Rim3dView*>( firstUiItem ) )
{

4
ApplicationLibCode/ProjectDataModel/RimEclipseResultCase.cpp
View File

@@ -49,7 +49,6 @@
#include "RimEclipseInputPropertyCollection.h"
#include "RimEclipseView.h"
#include "RimFlowDiagSolution.h"
#include "RimIntersectionCollection.h"
#include "RimMockModelSettings.h"
#include "RimProject.h"
#include "RimReservoirCellResultsStorage.h"
@@ -62,9 +61,11 @@
#include "cafProgressInfo.h"
#include "cafUtils.h"
#include <QApplication>
#include <QDir>
#include <QFile>
#include <QFileInfo>
#include <fstream>
#include <string>
@@ -660,7 +661,6 @@ void RimEclipseResultCase::fieldChangedByUi( const caf::PdmFieldHandle* changedF
{
resView->scheduleSimWellGeometryRegen();
resView->scheduleCreateDisplayModelAndRedraw();
resView->intersectionCollection()->recomputeSimWellBranchData();
}
}

7
ApplicationLibCode/ProjectDataModel/RimEclipseView.cpp
View File

@@ -1981,16 +1981,13 @@ void RimEclipseView::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrderin
if ( faultReactivationModelCollection()->shouldBeVisibleInTree() ) uiTreeOrdering.add( faultReactivationModelCollection() );
uiTreeOrdering.add( annotationCollection() );
uiTreeOrdering.add( intersectionCollection() );
uiTreeOrdering.add( m_polygonInViewCollection );
if ( surfaceInViewCollection() ) uiTreeOrdering.add( surfaceInViewCollection() );
if ( seismicSectionCollection()->shouldBeVisibleInTree() ) uiTreeOrdering.add( seismicSectionCollection() );
if ( RiaApplication::enableDevelopmentFeatures() )
{
uiTreeOrdering.add( m_polygonInViewCollection );
}
uiTreeOrdering.add( annotationCollection() );
uiTreeOrdering.skipRemainingChildren( true );
}

12
ApplicationLibCode/ProjectDataModel/RimGridCalculation.cpp
View File

@@ -609,10 +609,13 @@ std::vector<double> RimGridCalculation::getDataForResult( const QString&
values[i] = resultAccessor->cellScalarGlobIdx( activeReservoirCells[i] );
}
auto categoriesToExclude = { RiaDefines::ResultCatType::GENERATED };
if ( m_releaseMemoryAfterDataIsExtracted )
{
auto categoriesToExclude = { RiaDefines::ResultCatType::GENERATED };
sourceCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->freeAllocatedResultsData( categoriesToExclude, timeStepToUse );
sourceCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->freeAllocatedResultsData( categoriesToExclude, timeStepToUse );
sourceCase->results( RiaDefines::PorosityModelType::MATRIX_MODEL )->freeAllocatedResultsData( categoriesToExclude, timeStepToUse );
sourceCase->results( RiaDefines::PorosityModelType::FRACTURE_MODEL )->freeAllocatedResultsData( categoriesToExclude, timeStepToUse );
}
return values;
}
@@ -782,6 +785,9 @@ bool RimGridCalculation::calculateForCases( const std::vector<RimEclipseCase*>&
m_expression().contains( "min" ) || m_expression().contains( "max" ) ||
m_expression().contains( "count" );
// If multiple cases are present, release memory after data is extracted to avoid memory issues.
m_releaseMemoryAfterDataIsExtracted = isMultipleCasesPresent;
if ( isMultipleCasesPresent )
{
QString txt = "Starting calculation '" + description() + "' for " + QString::number( calculationCases.size() ) + " cases.";

2
ApplicationLibCode/ProjectDataModel/RimGridCalculation.h
View File

@@ -155,4 +155,6 @@ private:
caf::PdmField<bool> m_editNonVisibleResultAddress;
caf::PdmField<bool> m_applyToAllCases_OBSOLETE;
bool m_releaseMemoryAfterDataIsExtracted = false;
};

13
ApplicationLibCode/ProjectDataModel/RimGridView.cpp
View File

@@ -405,16 +405,9 @@ void RimGridView::appendPolygonPartsToModel( caf::DisplayCoordTransform* scaleTr
m_polygonVizModel->removeAllParts();
std::vector<RimPolygonInView*> polygonsInView;
if ( m_polygonInViewCollection && m_polygonInViewCollection->isChecked() )
if ( m_polygonInViewCollection )
{
auto candidates = m_polygonInViewCollection->polygonsInView();
for ( auto polygonInView : candidates )
{
if ( polygonInView->isChecked() )
{
polygonsInView.push_back( polygonInView );
}
}
polygonsInView = m_polygonInViewCollection->visiblePolygonsInView();
}
if ( cellFilterCollection() && cellFilterCollection()->isActive() )
@@ -534,7 +527,7 @@ void RimGridView::updateViewTreeItems( RiaDefines::ItemIn3dView itemType )
if ( bitmaskEnum.AnyOf( RiaDefines::ItemIn3dView::POLYGON ) )
{
m_polygonInViewCollection->syncPolygonsInView();
m_polygonInViewCollection->updateFromPolygonCollection();
}
updateConnectedEditors();

17
ApplicationLibCode/ProjectDataModel/RimPlotCurve.cpp
View File

@@ -1162,7 +1162,7 @@ void RimPlotCurve::setParentPlotNoReplot( RiuPlotWidget* plotWidget )
}
auto color = RiaColorTools::toQColor( m_curveAppearance->color() );
m_plotCurve = m_parentPlot->createPlotCurve( this, "" );
m_plotCurve = m_parentPlot->createPlotCurve( this, m_curveName );
m_plotCurve->updateErrorBarsAppearance( m_showErrorBars, color );
// PERFORMANCE NOTE
@@ -1262,19 +1262,10 @@ void RimPlotCurve::defineObjectEditorAttribute( QString uiConfigName, caf::PdmUi
if ( auto* treeItemAttribute = dynamic_cast<caf::PdmUiTreeViewItemAttribute*>( attribute ) )
{
treeItemAttribute->tags.clear();
auto tag = caf::PdmUiTreeViewItemAttribute::createTag();
// Blend with background for a nice look
auto backgroundColor = RiuGuiTheme::getColorByVariableName( "backgroundColor1" );
auto color = RiaColorTools::toQColor( m_curveAppearance->color() );
auto sourceWeight = 100;
double transparency = 0.3;
int backgroundWeight = std::max( 1, static_cast<int>( sourceWeight * 10 * transparency ) );
auto blendedColor = RiaColorTools::blendQColors( backgroundColor, color, backgroundWeight, sourceWeight );
tag->bgColor = blendedColor;
tag->fgColor = RiaColorTools::toQColor( m_curveAppearance->color() );
tag->text = "---";
auto tag = caf::PdmUiTreeViewItemAttribute::createTag( RiaColorTools::toQColor( m_curveAppearance->color() ),
RiuGuiTheme::getColorByVariableName( "backgroundColor1" ),
"---" );
tag->clicked.connect( this, &RimPlotCurve::onColorTagClicked );

6
ApplicationLibCode/ProjectDataModel/RimProject.cpp
View File

@@ -1524,6 +1524,7 @@ void RimProject::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, Q
if ( oilField->analysisModels() ) uiTreeOrdering.add( oilField->analysisModels() );
if ( oilField->geoMechModels() ) uiTreeOrdering.add( oilField->geoMechModels() );
if ( oilField->wellPathCollection() ) uiTreeOrdering.add( oilField->wellPathCollection() );
if ( oilField->polygonCollection() ) uiTreeOrdering.add( oilField->polygonCollection() );
if ( oilField->surfaceCollection() ) uiTreeOrdering.add( oilField->surfaceCollection() );
if ( oilField->seismicDataCollection() )
{
@@ -1534,11 +1535,6 @@ void RimProject::defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, Q
if ( oilField->formationNamesCollection() ) uiTreeOrdering.add( oilField->formationNamesCollection() );
if ( oilField->completionTemplateCollection() ) uiTreeOrdering.add( oilField->completionTemplateCollection() );
if ( oilField->annotationCollection() ) uiTreeOrdering.add( oilField->annotationCollection() );
if ( RiaApplication::enableDevelopmentFeatures() )
{
if ( oilField->polygonCollection() ) uiTreeOrdering.add( oilField->polygonCollection() );
}
}
uiTreeOrdering.add( colorLegendCollection() );

6
ApplicationLibCode/ProjectDataModel/RimSimWellInViewCollection.cpp
View File

@@ -31,7 +31,6 @@
#include "RimEclipseContourMapView.h"
#include "RimEclipseResultCase.h"
#include "RimEclipseView.h"
#include "RimIntersectionCollection.h"
#include "RimProject.h"
#include "RimSimWellFractureCollection.h"
#include "RimSimWellInView.h"
@@ -483,10 +482,7 @@ void RimSimWellInViewCollection::fieldChangedByUi( const caf::PdmFieldHandle* ch
if ( &wellPipeCoordType == changedField || &isAutoDetectingBranches == changedField )
{
if ( m_reservoirView )
{
m_reservoirView->intersectionCollection()->recomputeSimWellBranchData();
}
if ( m_reservoirView ) m_reservoirView->scheduleCreateDisplayModelAndRedraw();
for ( RimSimWellInView* w : wells )
{

1
ApplicationLibCode/ProjectDataModel/RimStimPlanLegendConfig.cpp
View File

@@ -20,7 +20,6 @@
#include "RimRegularLegendConfig.h"
#include "cafPdmUiOrdering.h"
#include "cafPdmUiTreeOrdering.h"
CAF_PDM_SOURCE_INIT( RimStimPlanLegendConfig, "RimStimPlanLegendConfig" );

1
ApplicationLibCode/ProjectDataModel/Summary/RimSummaryCaseMainCollection.cpp
View File

@@ -47,6 +47,7 @@
#include "cafProgressInfo.h"
#include <QCoreApplication>
#include <QDir>
CAF_PDM_SOURCE_INIT( RimSummaryCaseMainCollection, "SummaryCaseCollection" );

29
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogCsvFile.cpp
View File

@@ -117,22 +117,25 @@ std::vector<std::pair<double, double>> RimWellLogCsvFile::findMdAndChannelValues
std::vector<RimWellLogCsvFile*> wellLogFiles = wellPath.descendantsIncludingThisOfType<RimWellLogCsvFile>();
for ( RimWellLogCsvFile* wellLogFile : wellLogFiles )
{
RigWellLogCsvFile* fileData = wellLogFile->wellLogFileData();
std::vector<double> channelValues = fileData->values( channelName );
if ( !channelValues.empty() )
RigWellLogCsvFile* fileData = wellLogFile->wellLogFileData();
if ( fileData )
{
if ( unitString )
std::vector<double> channelValues = fileData->values( channelName );
if ( !channelValues.empty() )
{
*unitString = fileData->wellLogChannelUnitString( channelName );
if ( unitString )
{
*unitString = fileData->wellLogChannelUnitString( channelName );
}
std::vector<double> depthValues = fileData->depthValues();
CVF_ASSERT( depthValues.size() == channelValues.size() );
std::vector<std::pair<double, double>> depthValuePairs;
for ( size_t i = 0; i < depthValues.size(); ++i )
{
depthValuePairs.push_back( std::make_pair( depthValues[i], channelValues[i] ) );
}
return depthValuePairs;
}
std::vector<double> depthValues = fileData->depthValues();
CVF_ASSERT( depthValues.size() == channelValues.size() );
std::vector<std::pair<double, double>> depthValuePairs;
for ( size_t i = 0; i < depthValues.size(); ++i )
{
depthValuePairs.push_back( std::make_pair( depthValues[i], channelValues[i] ) );
}
return depthValuePairs;
}
}
return std::vector<std::pair<double, double>>();

1
ApplicationLibCode/ProjectDataModel/WellLog/RimWellLogCurveCommonDataSource.h
View File

@@ -24,7 +24,6 @@
#include "cafPdmField.h"
#include "cafPdmObject.h"
#include "cafPdmPtrField.h"
#include "cafPdmUiOrdering.h"
#include "cafTristate.h"
#include <QDateTime>