#5217 Filter well measurements by quality

ApplicationCode/ModelVisualization/RivWellPathPartMgr.cpp

@@ -286,13 +286,16 @@ void RivWellPathPartMgr::appendWellMeasurementsToModel( cvf::ModelBasicList*
             double lowerBound = 0.0;
             double upperBound = 0.0;
             wellMeasurementInView->rangeValues( &lowerBound, &upperBound );
+            std::vector<int> qualityFilter = wellMeasurementInView->qualityFilter();
+
             std::vector<RimWellMeasurement*> wellMeasurements =
                 RimWellMeasurementFilter::filterMeasurements( wellMeasurementCollection->measurements(),
                                                               *wellPathCollection,
                                                               *m_rimWellPath,
                                                               measurementKinds,
                                                               lowerBound,
-                                                              upperBound );
+                                                              upperBound,
+                                                              qualityFilter );
 
             RivPipeGeometryGenerator geoGenerator;
             for ( RimWellMeasurement* wellMeasurement : wellMeasurements )

ApplicationCode/ProjectDataModel/RimWellMeasurementFilter.cpp

@@ -57,7 +57,8 @@ std::vector<RimWellMeasurement*>
                                                   const RimWellPath&                      wellPath,
                                                   const std::vector<QString>&             measurementKinds,
                                                   double                                  lowerBound,
-                                                  double                                  upperBound )
+                                                  double                                  upperBound,
+                                                  const std::vector<int>&                 qualityFilter )
 {
     std::vector<RimWellMeasurement*> filteredMeasurementsByKindsAndWellPath = filterMeasurements( measurements,
                                                                                                   wellPathCollection,
@@ -67,7 +68,8 @@ std::vector<RimWellMeasurement*>
     std::vector<RimWellMeasurement*> filteredMeasurements;
     for ( auto& measurement : filteredMeasurementsByKindsAndWellPath )
     {
-        if ( RimWellMeasurementFilter::isInsideRange( measurement->value(), lowerBound, upperBound ) )
+        if ( RimWellMeasurementFilter::isInsideRange( measurement->value(), lowerBound, upperBound ) &&
+             RimWellMeasurementFilter::hasQuality( measurement->quality(), qualityFilter ) )
         {
             filteredMeasurements.push_back( measurement );
         }
@@ -114,3 +116,11 @@ bool RimWellMeasurementFilter::isInsideRange( double value, double lowerBound, d
 
     return false;
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimWellMeasurementFilter::hasQuality( int quality, const std::vector<int>& qualityFilter )
+{
+    return std::find( qualityFilter.begin(), qualityFilter.end(), quality ) != qualityFilter.end();
+}

ApplicationCode/ProjectDataModel/RimWellMeasurementFilter.h

@@ -38,7 +38,8 @@ public:
                                                                 const RimWellPath&           rimWellPath,
                                                                 const std::vector<QString>&  measurementKinds,
                                                                 double                       lowerBound,
-                                                                double                       upperBound );
+                                                                double                       upperBound,
+                                                                const std::vector<int>&      qualityFilter );
 
     static std::vector<RimWellMeasurement*> filterMeasurements( const std::vector<RimWellMeasurement*>& measurements,
                                                                 const std::vector<QString>& measurementKinds );
@@ -47,4 +48,6 @@ private:
     RimWellMeasurementFilter();
 
     static bool isInsideRange( double value, double lowerBound, double upperBound );
+
+    static bool hasQuality( int quality, const std::vector<int>& qualityFilter );
 };

ApplicationCode/ProjectDataModel/RimWellMeasurementInView.cpp

@@ -65,6 +65,10 @@ RimWellMeasurementInView::RimWellMeasurementInView()
     CAF_PDM_InitField( &m_upperBound, "UpperBound", HUGE_VAL, "Max", "", "", "" );
     m_upperBound.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleSliderEditor::uiEditorTypeName() );
 
+    CAF_PDM_InitFieldNoDefault( &m_qualityFilter, "QualityFilter", "Quality Filter", "", "", "" );
+    m_qualityFilter.uiCapability()->setAutoAddingOptionFromValue( false );
+    m_qualityFilter.uiCapability()->setUiEditorTypeName( caf::PdmUiTreeSelectionEditor::uiEditorTypeName() );
+
     this->setName( "Well Measurement" );
 
     m_minimumResultValue = cvf::UNDEFINED_DOUBLE;
@@ -104,6 +108,8 @@ void RimWellMeasurementInView::defineUiOrdering( QString uiConfigName, caf::PdmU
         filterGroup.add( &m_upperBound );
     }
 
+    uiOrdering.add( &m_qualityFilter );
+
     uiOrdering.skipRemainingFields();
 }
 
@@ -154,6 +160,14 @@ void RimWellMeasurementInView::rangeValues( double* lowerBound, double* upperBou
     *upperBound = m_upperBound;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+std::vector<int> RimWellMeasurementInView::qualityFilter() const
+{
+    return m_qualityFilter;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -296,6 +310,26 @@ QList<caf::PdmOptionItemInfo>
             }
         }
     }
+    else if ( fieldNeedingOptions == &m_qualityFilter )
+    {
+        RimWellPathCollection* wellPathCollection = RimTools::wellPathCollection();
+        if ( wellPathCollection )
+        {
+            std::vector<RimWellMeasurement*> measurements = wellPathCollection->measurementCollection()->measurements();
+
+            // Find possible quality values for a given measurement kind
+            std::set<int> qualityValues;
+            for ( const auto& measurement : measurements )
+            {
+                if ( measurement->kind() == m_measurementKind ) qualityValues.insert( measurement->quality() );
+            }
+
+            for ( const auto& quality : qualityValues )
+            {
+                options.push_back( caf::PdmOptionItemInfo( QString::number( quality ), quality ) );
+            }
+        }
+    }
 
     return options;
 }
@@ -356,3 +390,27 @@ void RimWellMeasurementInView::setAllWellsSelected()
         }
     }
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimWellMeasurementInView::setAllQualitiesSelected()
+{
+    RimWellPathCollection* wellPathCollection = RimTools::wellPathCollection();
+    if ( wellPathCollection )
+    {
+        std::vector<RimWellMeasurement*> measurements = wellPathCollection->measurementCollection()->measurements();
+
+        // Find possible quality values for a given measurement kind
+        std::set<int> qualityValues;
+        for ( const auto& measurement : measurements )
+        {
+            if ( measurement->kind() == m_measurementKind ) qualityValues.insert( measurement->quality() );
+        }
+
+        for ( const auto& quality : qualityValues )
+        {
+            m_qualityFilter.v().push_back( quality );
+        }
+    }
+}

ApplicationCode/ProjectDataModel/RimWellMeasurementInView.h

@@ -46,12 +46,14 @@ public:
     void                    setMeasurementKind( const QString& measurementKind );
     bool                    isWellChecked( const QString& wellName ) const;
     void                    setAllWellsSelected();
+    void                    setAllQualitiesSelected();
 
     void updateLegendRangesTextAndVisibility( RiuViewer* nativeOrOverrideViewer, bool isUsingOverrideViewer );
 
     bool hasCategoryResult() const;
 
-    void rangeValues( double* lowerBound, double* upperBound ) const;
+    void             rangeValues( double* lowerBound, double* upperBound ) const;
+    std::vector<int> qualityFilter() const;
 
 protected:
     void defineUiTreeOrdering( caf::PdmUiTreeOrdering& uiTreeOrdering, QString uiConfigName = "" ) override;
@@ -79,6 +81,7 @@ private:
     caf::PdmField<std::vector<QString>>         m_wells;
     caf::PdmField<double>                       m_lowerBound;
     caf::PdmField<double>                       m_upperBound;
+    caf::PdmField<std::vector<int>>             m_qualityFilter;
 
     double m_minimumResultValue;
     double m_maximumResultValue;

ApplicationCode/ProjectDataModel/RimWellMeasurementInViewCollection.cpp

@@ -135,6 +135,7 @@ void RimWellMeasurementInViewCollection::syncWithChangesInWellMeasurementCollect
             measurementInView->setName( kind );
             measurementInView->setMeasurementKind( kind );
             measurementInView->setAllWellsSelected();
+            measurementInView->setAllQualitiesSelected();
 
             m_measurementsInView.push_back( measurementInView );
         }