Polygonfilter updates2 (#7286)

* Make sure all contourmap copies are getting the correct case set for cell filters when creating/copying maps.

* Rewrite polyline part manager to be more generic, not just linked to annotations.
* Add new partmgr for cell filters to draw polygon filter outlines in both eclipse and geomech views
* Show lines/spheres for polygon filter outline
* Add color edit for line and spheres
* Add support for z plane lock in poygon filter outline
* Add new flags for enabling filter and/or polyline display

* Add K range filter to polygon filter

* Enable picking automatically when creating a new polygon filter

ApplicationLibCode/ProjectDataModel/Annotations/RimPolylinesAnnotationInView.cpp

@@ -19,8 +19,11 @@
 #include "RimPolylinesAnnotationInView.h"
 #include "RimAnnotationCollectionBase.h"
 #include "RimAnnotationGroupCollection.h"
+#include "RimAnnotationInViewCollection.h"
 #include "RimPolylinesAnnotation.h"
 
+#include "RigPolyLinesData.h"
+
 CAF_PDM_SOURCE_INIT( RimPolylinesAnnotationInView, "RimPolylinesAnnotationInView" );
 
 //--------------------------------------------------------------------------------------------------
@@ -122,3 +125,21 @@ caf::PdmFieldHandle* RimPolylinesAnnotationInView::userDescriptionField()
 {
     return m_sourceAnnotation ? m_sourceAnnotation->userDescriptionField() : nullptr;
 }
+
+cvf::ref<RigPolyLinesData> RimPolylinesAnnotationInView::polyLinesData() const
+{
+    auto retval = m_sourceAnnotation->polyLinesData();
+    if ( !isVisible() )
+    {
+        retval->setVisibility( false, false );
+    }
+
+    RimAnnotationInViewCollection* coll;
+    firstAncestorOrThisOfType( coll );
+    if ( coll )
+    {
+        retval->setZPlaneLock( coll->snapAnnotations(), coll->annotationPlaneZ() );
+    }
+
+    return retval;
+}

ApplicationLibCode/ProjectDataModel/Annotations/RimPolylinesAnnotationInView.h

@@ -20,6 +20,8 @@
 
 #include "RimAnnotationLineAppearance.h"
 
+#include "RimPolylinesDataInterface.h"
+
 #include "cafAppEnum.h"
 #include "cafPdmChildArrayField.h"
 #include "cafPdmField.h"
@@ -46,7 +48,7 @@ class RimPolylinesAnnotation;
 ///
 ///
 //==================================================================================================
-class RimPolylinesAnnotationInView : public caf::PdmObject
+class RimPolylinesAnnotationInView : public caf::PdmObject, public RimPolylinesDataInterface
 {
     CAF_PDM_HEADER_INIT;
 
@@ -60,6 +62,8 @@ public:
 
     bool isVisible() const;
 
+    cvf::ref<RigPolyLinesData> polyLinesData() const override;
+
 protected:
     void                 fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
     caf::PdmFieldHandle* objectToggleField() override;

ApplicationLibCode/ProjectDataModel/Annotations/RimPolylinesFromFileAnnotation.cpp

@@ -143,6 +143,11 @@ void RimPolylinesFromFileAnnotation::readPolyLinesFile( QString* errorMessage )
 //--------------------------------------------------------------------------------------------------
 cvf::ref<RigPolyLinesData> RimPolylinesFromFileAnnotation::polyLinesData()
 {
+    auto ap = appearance();
+    m_polyLinesData->setVisibility( m_showLines(), m_showSpheres() );
+    m_polyLinesData->setSphereAppearance( ap->sphereRadiusFactor(), ap->sphereColor() );
+    m_polyLinesData->setLineAppearance( ap->thickness(), ap->color(), m_closePolyline );
+
     return m_polyLinesData;
 }
 

ApplicationLibCode/ProjectDataModel/Annotations/RimUserDefinedPolylinesAnnotation.cpp

@@ -80,7 +80,12 @@ cvf::ref<RigPolyLinesData> RimUserDefinedPolylinesAnnotation::polyLinesData()
     {
         line.push_back( target->targetPointXYZ() );
     }
-    pld->setPolyLines( { line } );
+    pld->setPolyLine( line );
+
+    auto ap = appearance();
+    pld->setVisibility( m_showLines(), m_showSpheres() );
+    pld->setSphereAppearance( ap->sphereRadiusFactor(), ap->sphereColor() );
+    pld->setLineAppearance( ap->thickness(), ap->color(), m_closePolyline );
 
     return pld;
 }

ApplicationLibCode/ProjectDataModel/CMakeLists_files.cmake

@@ -166,6 +166,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimCustomObjectiveFunction.h
 ${CMAKE_CURRENT_LIST_DIR}/RimCustomObjectiveFunctionWeight.h
 ${CMAKE_CURRENT_LIST_DIR}/RimEquilibriumAxisAnnotation.h
 ${CMAKE_CURRENT_LIST_DIR}/RimTimeAxisAnnotation.h
+${CMAKE_CURRENT_LIST_DIR}/RimPolylinesDataInterface.h
 )
 
 

ApplicationLibCode/ProjectDataModel/CellFilters/CMakeLists_files.cmake

@@ -11,6 +11,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimGeoMechPropertyFilter.h
 ${CMAKE_CURRENT_LIST_DIR}/RimGeoMechPropertyFilterCollection.h
 ${CMAKE_CURRENT_LIST_DIR}/RimPolygonFilter.h
 ${CMAKE_CURRENT_LIST_DIR}/RimUserDefinedFilter.h
+${CMAKE_CURRENT_LIST_DIR}/RimCellFilterIntervalTool.h
 )
 
 set (SOURCE_GROUP_SOURCE_FILES
@@ -25,6 +26,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimGeoMechPropertyFilter.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimGeoMechPropertyFilterCollection.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimPolygonFilter.cpp
 ${CMAKE_CURRENT_LIST_DIR}/RimUserDefinedFilter.cpp
+${CMAKE_CURRENT_LIST_DIR}/RimCellFilterIntervalTool.cpp
 )
 
 list(APPEND CODE_HEADER_FILES

ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilter.cpp

@@ -112,13 +112,24 @@ void RimCellFilter::setActive( bool active )
 }
 
 //--------------------------------------------------------------------------------------------------
-///
+/// Is the filter turned on in the explorer tree?
 //--------------------------------------------------------------------------------------------------
 bool RimCellFilter::isActive() const
 {
     return m_isActive();
 }
 
+//--------------------------------------------------------------------------------------------------
+/// Is the cell filter doing active filtering, or is it just showning outline, etc. in the view
+/// - isActive == true -> filter enabled in explorer
+/// - isFilterEnabled == true -> filter enabled in explorer and is actually filtering cells, too
+/// Default implementation just returns the isActive state.
+//--------------------------------------------------------------------------------------------------
+bool RimCellFilter::isFilterEnabled() const
+{
+    return m_isActive();
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilter.h

@@ -56,6 +56,8 @@ public:
     bool isActive() const;
     void setActive( bool active );
 
+    virtual bool isFilterEnabled() const;
+
     caf::AppEnum<FilterModeType> filterMode() const;
     QString                      modeString() const;
 

ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilterCollection.cpp

@@ -18,12 +18,10 @@
 
 #include "RimCellFilterCollection.h"
 
-#include "RigPolyLinesData.h"
 #include "Rim3dView.h"
 #include "RimCase.h"
 #include "RimCellFilter.h"
 #include "RimCellRangeFilter.h"
-#include "RimGeoMechView.h"
 #include "RimPolygonFilter.h"
 #include "RimUserDefinedFilter.h"
 #include "RimViewController.h"
@@ -88,6 +86,18 @@ void RimCellFilterCollection::setActive( bool bActive )
     updateIconState();
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimCellFilterCollection::setCase( RimCase* theCase )
+{
+    for ( RimCellFilter* filter : m_cellFilters )
+    {
+        RimPolygonFilter* polyFilter = dynamic_cast<RimPolygonFilter*>( filter );
+        if ( polyFilter ) polyFilter->setCase( theCase );
+    }
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -205,7 +215,7 @@ bool RimCellFilterCollection::hasActiveFilters() const
 
     for ( const auto& filter : m_cellFilters )
     {
-        if ( filter->isActive() ) return true;
+        if ( filter->isFilterEnabled() ) return true;
     }
 
     return false;
@@ -220,7 +230,7 @@ bool RimCellFilterCollection::hasActiveIncludeFilters() const
 
     for ( const auto& filter : m_cellFilters )
     {
-        if ( filter->isActive() && filter->filterMode() == RimCellFilter::INCLUDE ) return true;
+        if ( filter->isFilterEnabled() && filter->filterMode() == RimCellFilter::INCLUDE ) return true;
     }
 
     return false;
@@ -233,8 +243,8 @@ RimPolygonFilter* RimCellFilterCollection::addNewPolygonFilter( RimCase* srcCase
 {
     RimPolygonFilter* pFilter = new RimPolygonFilter();
     pFilter->setCase( srcCase );
-    pFilter->setActive( false );
     addFilter( pFilter );
+    pFilter->enablePicking( true );
     onFilterUpdated( pFilter );
     return pFilter;
 }
@@ -361,7 +371,7 @@ void RimCellFilterCollection::compoundCellRangeFilter( cvf::CellRangeFilter* cel
 
     for ( RimCellFilter* filter : m_cellFilters )
     {
-        if ( filter->isActive() && static_cast<size_t>( filter->gridIndex() ) == gridIndex )
+        if ( filter->isFilterEnabled() && static_cast<size_t>( filter->gridIndex() ) == gridIndex )
         {
             filter->updateCompundFilter( cellRangeFilter );
         }

ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilterCollection.h

@@ -68,6 +68,8 @@ public:
 
     void connectToFilterUpdates( RimCellFilter* filter );
 
+    void setCase( RimCase* theCase );
+
 protected:
     // Overridden methods
     void                 fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;

ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilterIntervalTool.cpp

@@ -0,0 +1,125 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2021 Equinor ASA
+//
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+//
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#include "RimCellFilterIntervalTool.h"
+
+#include <QStringList>
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimCellFilterInterval::RimCellFilterInterval( size_t minIncludeVal, size_t maxIncludeVal )
+    : m_minIncludeVal( minIncludeVal )
+    , m_maxIncludeVal( maxIncludeVal )
+{
+    m_valid = maxIncludeVal >= minIncludeVal;
+    m_valid = m_valid && minIncludeVal > 0;
+}
+
+RimCellFilterInterval::RimCellFilterInterval( size_t includeVal )
+    : m_minIncludeVal( includeVal )
+    , m_maxIncludeVal( includeVal )
+{
+    m_valid = includeVal > 0;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimCellFilterInterval::~RimCellFilterInterval()
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimCellFilterInterval::isIncluded( size_t val ) const
+{
+    if ( ( val >= m_minIncludeVal ) && ( val <= m_maxIncludeVal ) ) return m_valid;
+    return false;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimCellFilterIntervalTool::RimCellFilterIntervalTool( bool includeAllByDefault )
+    : m_includeAllByDefault( includeAllByDefault )
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+RimCellFilterIntervalTool::~RimCellFilterIntervalTool()
+{
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimCellFilterIntervalTool::isNumberIncluded( size_t number ) const
+{
+    if ( m_intervals.size() == 0 ) return m_includeAllByDefault;
+
+    number = number + 1;
+
+    for ( const auto& interval : m_intervals )
+    {
+        if ( interval.isIncluded( number ) ) return true;
+    }
+    return false;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+size_t RimCellFilterIntervalTool::numberFromPart( QString strVal ) const
+{
+    return strVal.toUInt();
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+// Define a range with the comma separated format A,B,C-D, etc.,  i.e. 1,4,5-8
+// Only positive numbers are supported.
+//--------------------------------------------------------------------------------------------------
+void RimCellFilterIntervalTool::setInterval( bool enabled, QString intervalText )
+{
+    m_intervals.clear();
+
+    if ( !enabled ) return;
+
+    QStringList parts = intervalText.split( ',', QString::SkipEmptyParts );
+
+    for ( auto& part : parts )
+    {
+        QStringList minmax = part.split( '-', QString::SkipEmptyParts );
+        switch ( minmax.size() )
+        {
+            case 1:
+                m_intervals.push_back( RimCellFilterInterval( numberFromPart( minmax[0] ) ) );
+                break;
+            case 2:
+                m_intervals.push_back( RimCellFilterInterval( numberFromPart( minmax[0] ), numberFromPart( minmax[1] ) ) );
+                break;
+
+            default:
+                break;
+        }
+    }
+}

ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilterIntervalTool.h

@@ -0,0 +1,55 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2021 Equinor ASA
+//
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+//
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include <QString>
+#include <list>
+
+class RimCellFilterInterval
+{
+public:
+    RimCellFilterInterval( size_t minIncludeVal, size_t maxIncludeVal );
+    RimCellFilterInterval( size_t includeVal );
+    ~RimCellFilterInterval();
+
+    bool isIncluded( size_t val ) const;
+
+private:
+    size_t m_minIncludeVal;
+    size_t m_maxIncludeVal;
+    bool   m_valid;
+};
+
+class RimCellFilterIntervalTool
+{
+public:
+    RimCellFilterIntervalTool( bool includeAllByDefault = true );
+    ~RimCellFilterIntervalTool();
+
+    void setInterval( bool enabled, QString intervalText );
+    bool isNumberIncluded( size_t number ) const;
+
+private:
+    size_t numberFromPart( QString strVal ) const;
+
+    bool    m_includeAllByDefault;
+    QString m_intervalText;
+
+    std::list<RimCellFilterInterval> m_intervals;
+};

ApplicationLibCode/ProjectDataModel/CellFilters/RimPolygonFilter.cpp

@@ -25,6 +25,7 @@
 #include "RigFemPartGrid.h"
 #include "RigGeoMechCaseData.h"
 #include "RigMainGrid.h"
+#include "RigPolyLinesData.h"
 
 #include "Rim3dView.h"
 #include "RimCase.h"
@@ -38,14 +39,20 @@
 
 #include "RiuViewerCommands.h"
 
+#include "RiaStdStringTools.h"
+
 #include "cafCmdFeatureMenuBuilder.h"
+#include "cafPdmUiLineEditor.h"
 #include "cafPdmUiPushButtonEditor.h"
 #include "cafPdmUiTableViewEditor.h"
 #include "cafPdmUiTreeOrdering.h"
+#include <cafPdmUiDoubleSliderEditor.h>
 
 #include "cvfBoundingBox.h"
 #include "cvfStructGrid.h"
 
+#include <QValidator>
+
 namespace caf
 {
 template <>
@@ -67,6 +74,42 @@ void caf::AppEnum<RimPolygonFilter::PolygonIncludeType>::setUp()
 
 } // namespace caf
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+class ThicknessValidator : public QValidator
+{
+public:
+    State validate( QString& input, int& pos ) const override
+    {
+        if ( input.isEmpty() ) return State::Intermediate;
+
+        int val = RiaStdStringTools::toInt( input.toStdString() );
+        if ( val > 0 && val < 8 )
+            return State::Acceptable;
+        else
+            return State::Invalid;
+    }
+};
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+class RadiusValidator : public QValidator
+{
+public:
+    State validate( QString& input, int& pos ) const override
+    {
+        if ( input.isEmpty() ) return State::Intermediate;
+
+        double val = RiaStdStringTools::toDouble( input.toStdString() );
+        if ( val > 0.001 && val <= 2.0 )
+            return State::Acceptable;
+        else
+            return State::Invalid;
+    }
+};
+
 CAF_PDM_SOURCE_INIT( RimPolygonFilter, "PolygonFilter", "PolyLineFilter" );
 
 //--------------------------------------------------------------------------------------------------
@@ -74,6 +117,7 @@ CAF_PDM_SOURCE_INIT( RimPolygonFilter, "PolygonFilter", "PolyLineFilter" );
 //--------------------------------------------------------------------------------------------------
 RimPolygonFilter::RimPolygonFilter()
     : m_pickTargetsEventHandler( new RicPolylineTargetsPickEventHandler( this ) )
+    , m_intervalTool( true )
 {
     CAF_PDM_InitObject( "Polyline Filter", ":/CellFilter_Polygon.png", "", "" );
 
@@ -94,6 +138,26 @@ RimPolygonFilter::RimPolygonFilter()
     CAF_PDM_InitFieldNoDefault( &m_srcCase, "Case", "Case", "", "", "" );
     m_srcCase.uiCapability()->setUiHidden( true );
 
+    CAF_PDM_InitField( &m_showLines, "ShowLines", true, "Show Lines", "", "", "" );
+    CAF_PDM_InitField( &m_showSpheres, "ShowSpheres", false, "Show Spheres", "", "", "" );
+
+    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_enableFiltering, "EnableFiltering", false, "Enable Filter", "", "", "" );
+
+    CAF_PDM_InitField( &m_enableKFilter, "EnableKFilter", false, "Enable K Range Filter", "", "", "" );
+    CAF_PDM_InitFieldNoDefault( &m_kFilterStr, "KRangeFilter", "K Range Filter", "", "", "" );
+
+    CAF_PDM_InitField( &m_polygonPlaneDepth, "PolygonPlaneDepth", 0.0, "Polygon Plane Depth", "", "", "" );
+    CAF_PDM_InitField( &m_lockPolygonToPlane, "LockPolygon", false, "Lock Polygon to Plane", "", "", "" );
+
+    m_polygonPlaneDepth.uiCapability()->setUiEditorTypeName( caf::PdmUiDoubleSliderEditor::uiEditorTypeName() );
+    m_polygonPlaneDepth.uiCapability()->setUiLabelPosition( caf::PdmUiItemInfo::LabelPosType::TOP );
+
     this->setUi3dEditorTypeName( RicPolyline3dEditor::uiEditorTypeName() );
     this->uiCapability()->setUiTreeChildrenHidden( true );
 
@@ -142,12 +206,40 @@ void RimPolygonFilter::setCase( RimCase* srcCase )
     m_srcCase = srcCase;
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimPolygonFilter::enableFilter( bool bEnable )
+{
+    m_enableFiltering = bEnable;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void RimPolygonFilter::enableKFilter( bool bEnable )
+{
+    m_enableKFilter = bEnable;
+}
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+bool RimPolygonFilter::isFilterEnabled() const
+{
+    return m_isActive() && m_enableFiltering;
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
 QString RimPolygonFilter::fullName() const
 {
-    return QString( "%1  [%2 cells]" ).arg( RimCellFilter::fullName(), QString::number( m_cells.size() ) );
+    if ( m_enableFiltering )
+    {
+        return QString( "%1  [%2 cells]" ).arg( RimCellFilter::fullName(), QString::number( m_cells.size() ) );
+    }
+    return QString( "%1  [off]" ).arg( RimCellFilter::fullName() );
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -203,8 +295,7 @@ void RimPolygonFilter::defineEditorAttribute( const caf::PdmFieldHandle* field,
             }
         }
     }
-
-    if ( field == &m_targets )
+    else if ( field == &m_targets )
     {
         auto tvAttribute = dynamic_cast<caf::PdmUiTableViewEditorAttribute*>( attribute );
         if ( tvAttribute )
@@ -218,6 +309,41 @@ void RimPolygonFilter::defineEditorAttribute( const caf::PdmFieldHandle* field,
             }
         }
     }
+    else if ( field == &m_lineThickness )
+    {
+        auto myAttr = dynamic_cast<caf::PdmUiLineEditorAttribute*>( attribute );
+        if ( myAttr )
+        {
+            myAttr->validator = new ThicknessValidator();
+        }
+    }
+    else if ( field == &m_lineThickness )
+    {
+        auto myAttr = dynamic_cast<caf::PdmUiLineEditorAttribute*>( attribute );
+        if ( myAttr )
+        {
+            myAttr->validator = new RadiusValidator();
+        }
+    }
+    else if ( field == &m_polygonPlaneDepth )
+    {
+        auto* attr = dynamic_cast<caf::PdmUiDoubleSliderEditorAttribute*>( attribute );
+
+        if ( attr )
+        {
+            if ( m_srcCase )
+            {
+                auto bb         = m_srcCase->allCellsBoundingBox();
+                attr->m_minimum = -bb.max().z();
+                attr->m_maximum = -bb.min().z();
+            }
+            else
+            {
+                attr->m_minimum = 0;
+                attr->m_maximum = 10000;
+            }
+        }
+    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -239,16 +365,54 @@ void RimPolygonFilter::defineCustomContextMenu( const caf::PdmFieldHandle* field
 //--------------------------------------------------------------------------------------------------
 void RimPolygonFilter::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
 {
-    RimCellFilter::defineUiOrdering( uiConfigName, uiOrdering );
+    uiOrdering.add( &m_name );
 
-    uiOrdering.add( &m_polyFilterMode );
-    uiOrdering.add( &m_polyIncludeType );
-    uiOrdering.add( &m_targets );
-    uiOrdering.add( &m_enablePicking );
+    auto group = uiOrdering.addNewGroup( "General" );
+    group->add( &m_filterMode );
+    group->add( &m_enableFiltering );
+    group->add( &m_showLines );
+    group->add( &m_showSpheres );
+
+    auto group1 = uiOrdering.addNewGroup( "Polygon Selection" );
+    group1->add( &m_polyFilterMode );
+    group1->add( &m_polyIncludeType );
+    group1->add( &m_targets );
+    group1->add( &m_enablePicking );
 
     m_polyIncludeType.uiCapability()->setUiName( "Cells to " + modeString() );
 
+    auto group2 = uiOrdering.addNewGroup( "Appearance" );
+    if ( m_showLines )
+    {
+        group2->add( &m_lineThickness );
+        group2->add( &m_lineColor );
+    }
+    if ( m_showSpheres )
+    {
+        group2->add( &m_sphereRadiusFactor );
+        group2->add( &m_sphereColor );
+    }
+    group2->add( &m_lockPolygonToPlane );
+    if ( m_lockPolygonToPlane ) group2->add( &m_polygonPlaneDepth );
+    group2->setCollapsedByDefault( true );
+
+    auto group3 = uiOrdering.addNewGroup( "Advanced Filter Settings" );
+    group3->add( &m_enableKFilter );
+    group3->add( &m_kFilterStr );
+    group3->add( &m_gridIndex );
+    group3->add( &m_propagateToSubGrids );
+    group3->setCollapsedByDefault( true );
+
     uiOrdering.skipRemainingFields( true );
+
+    bool readOnlyState = isFilterControlled();
+
+    std::vector<caf::PdmFieldHandle*> objFields;
+    this->fields( objFields );
+    for ( auto& objField : objFields )
+    {
+        objField->uiCapability()->setUiReadOnly( readOnlyState );
+    }
 }
 
 //--------------------------------------------------------------------------------------------------
@@ -264,7 +428,7 @@ void RimPolygonFilter::fieldChangedByUi( const caf::PdmFieldHandle* changedField
 
         if ( m_enablePicking() )
         {
-            setActive( false );
+            enableFilter( false );
             filterChanged.send();
         }
     }
@@ -308,6 +472,8 @@ void RimPolygonFilter::updateCompundFilter( cvf::CellRangeFilter* cellRangeFilte
 {
     CVF_ASSERT( cellRangeFilter );
 
+    if ( !m_enableFiltering ) return;
+
     if ( m_cells.size() == 0 ) updateCells();
 
     const auto grid = selectedGrid();
@@ -369,20 +535,25 @@ void RimPolygonFilter::updateCellsDepthEclipse( const std::vector<cvf::Vec3d>& p
 {
     // we should look in depth using Z coordinate
     // loop over all cells
-    for ( size_t i = 0; i < grid->cellCount(); i++ )
+    for ( size_t n = 0; n < grid->cellCount(); n++ )
     {
         // valid cell?
-        RigCell cell = grid->cellByGridAndGridLocalCellIdx( gridIndex(), i );
+        RigCell cell = grid->cellByGridAndGridLocalCellIdx( gridIndex(), n );
         if ( cell.isInvalid() ) continue;
 
         // get corner coordinates
         std::array<cvf::Vec3d, 8> hexCorners;
-        grid->cellCornerVertices( i, hexCorners.data() );
+        grid->cellCornerVertices( n, hexCorners.data() );
+
+        // get cell ijk for k filter
+        size_t i, j, k;
+        grid->ijkFromCellIndex( n, &i, &j, &k );
+        if ( !m_intervalTool.isNumberIncluded( k ) ) continue;
 
         // check if the polygon includes the cell
         if ( cellInsidePolygon2D( cell.center(), hexCorners, points ) )
         {
-            m_cells.push_back( i );
+            m_cells.push_back( n );
         }
     }
 }
@@ -460,6 +631,8 @@ void RimPolygonFilter::updateCellsKIndexEclipse( const std::vector<cvf::Vec3d>&
 
         for ( size_t k = 0; k < grid->cellCountK(); k++ )
         {
+            if ( !m_intervalTool.isNumberIncluded( k ) ) continue;
+
             // get the cell index
             size_t newIdx = grid->cellIndexFromIJK( ci, cj, k );
             // valid cell?
@@ -505,6 +678,8 @@ void RimPolygonFilter::updateCellsDepthGeoMech( const std::vector<cvf::Vec3d>& p
         {
             for ( size_t k = 0; k < grid->cellCountK(); k++ )
             {
+                if ( !m_intervalTool.isNumberIncluded( k ) ) continue;
+
                 size_t cellIdx = grid->cellIndexFromIJK( i, j, k );
 
                 cvf::Vec3d vertices[8];
@@ -608,6 +783,8 @@ void RimPolygonFilter::updateCellsKIndexGeoMech( const std::vector<cvf::Vec3d>&
 
         for ( size_t k = 0; k < grid->cellCountK(); k++ )
         {
+            if ( !m_intervalTool.isNumberIncluded( k ) ) continue;
+
             // get the cell index
             size_t newIdx = grid->cellIndexFromIJK( ci, cj, k );
             m_cells.push_back( newIdx );
@@ -643,6 +820,9 @@ void RimPolygonFilter::updateCells()
     // reset
     m_cells.clear();
 
+    // get optional k-cell filter
+    m_intervalTool.setInterval( m_enableKFilter, m_kFilterStr );
+
     // get polyline as vector
     std::vector<cvf::Vec3d> points;
     for ( auto& target : m_targets )
@@ -668,3 +848,32 @@ void RimPolygonFilter::updateCells()
         updateCellsForGeoMech( points, gCase );
     }
 }
+
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+cvf::ref<RigPolyLinesData> RimPolygonFilter::polyLinesData() const
+{
+    cvf::ref<RigPolyLinesData> pld = new RigPolyLinesData;
+    std::vector<cvf::Vec3d>    line;
+    for ( const RimPolylineTarget* target : m_targets )
+    {
+        line.push_back( target->targetPointXYZ() );
+    }
+    pld->setPolyLine( line );
+
+    pld->setLineAppearance( m_lineThickness, m_lineColor, true );
+    pld->setSphereAppearance( m_sphereRadiusFactor, m_sphereColor );
+    pld->setZPlaneLock( m_lockPolygonToPlane, -m_polygonPlaneDepth );
+
+    if ( isActive() )
+    {
+        pld->setVisibility( m_showLines, m_showSpheres );
+    }
+    else
+    {
+        pld->setVisibility( false, false );
+    }
+
+    return pld;
+}

ApplicationLibCode/ProjectDataModel/CellFilters/RimPolygonFilter.h

@@ -19,16 +19,21 @@
 #pragma once
 
 #include "RimCellFilter.h"
+#include "RimCellFilterIntervalTool.h"
 #include "RimPolylinePickerInterface.h"
+#include "RimPolylinesDataInterface.h"
 
 #include "cafAppEnum.h"
 #include "cafPdmChildArrayField.h"
 #include "cafPdmField.h"
+#include "cafPdmFieldCvfColor.h"
 #include "cafPdmFieldCvfVec3d.h"
 #include "cafPdmObject.h"
 #include "cafPdmPtrField.h"
 #include "cafPickEventHandler.h"
 
+#include "cvfColor3.h"
+
 #include <list>
 #include <memory>
 
@@ -39,12 +44,13 @@ class RimEclipseCase;
 class RimGeoMechCase;
 class RigMainGrid;
 class RigFemPartGrid;
+class RigPolylinesData;
 
 //==================================================================================================
 ///
 ///
 //==================================================================================================
-class RimPolygonFilter : public RimCellFilter, public RimPolylinePickerInterface
+class RimPolygonFilter : public RimCellFilter, public RimPolylinePickerInterface, public RimPolylinesDataInterface
 {
     CAF_PDM_HEADER_INIT;
 
@@ -66,6 +72,10 @@ public:
     ~RimPolygonFilter() override;
 
     void setCase( RimCase* srcCase );
+    void enableFilter( bool bEnable );
+    void enableKFilter( bool bEnable );
+
+    bool isFilterEnabled() const override;
 
     void updateVisualization() override;
     void updateEditorsAndVisualization() override;
@@ -79,6 +89,8 @@ public:
 
     void updateCompundFilter( cvf::CellRangeFilter* cellRangeFilter ) override;
 
+    cvf::ref<RigPolyLinesData> polyLinesData() const override;
+
 protected:
     void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
     void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;
@@ -108,8 +120,21 @@ private:
     caf::PdmField<caf::AppEnum<PolygonFilterModeType>> m_polyFilterMode;
     caf::PdmField<caf::AppEnum<PolygonIncludeType>>    m_polyIncludeType;
     caf::PdmPtrField<RimCase*>                         m_srcCase;
+    caf::PdmField<bool>                                m_enableFiltering;
+    caf::PdmField<bool>                                m_enableKFilter;
+    caf::PdmField<bool>                                m_showLines;
+    caf::PdmField<bool>                                m_showSpheres;
+    caf::PdmField<QString>                             m_kFilterStr;
+    caf::PdmField<int>                                 m_lineThickness;
+    caf::PdmField<double>                              m_sphereRadiusFactor;
+    caf::PdmField<cvf::Color3f>                        m_lineColor;
+    caf::PdmField<cvf::Color3f>                        m_sphereColor;
+    caf::PdmField<double>                              m_polygonPlaneDepth;
+    caf::PdmField<bool>                                m_lockPolygonToPlane;
 
     std::shared_ptr<RicPolylineTargetsPickEventHandler> m_pickTargetsEventHandler;
 
     std::list<size_t> m_cells;
+
+    RimCellFilterIntervalTool m_intervalTool;
 };

ApplicationLibCode/ProjectDataModel/Rim3dView.cpp

@@ -43,6 +43,7 @@
 #include "RimWellPathCollection.h"
 
 #include "RivAnnotationsPartMgr.h"
+#include "RivCellFilterPartMgr.h"
 #include "RivMeasurementPartMgr.h"
 #include "RivWellPathsPartMgr.h"
 
@@ -170,8 +171,9 @@ Rim3dView::Rim3dView( void )
 
     m_wellPathsPartManager   = new RivWellPathsPartMgr( this );
     m_annotationsPartManager = new RivAnnotationsPartMgr( this );
-
+    m_cellfilterPartManager  = new RivCellFilterPartMgr( this );
     m_measurementPartManager = new RivMeasurementPartMgr( this );
+
     this->setAs3DViewMdiWindow();
 }
 
@@ -570,12 +572,14 @@ void Rim3dView::updateDisplayModelForCurrentTimeStepAndRedraw()
         this->onUpdateDisplayModelForCurrentTimeStep();
         appendAnnotationsToModel();
         appendMeasurementToModel();
+        appendCellFiltersToModel();
 
         if ( Rim3dView* depView = prepareComparisonView() )
         {
             depView->onUpdateDisplayModelForCurrentTimeStep();
             depView->appendAnnotationsToModel();
             depView->appendMeasurementToModel();
+            depView->appendCellFiltersToModel();
 
             restoreComparisonView();
         }
@@ -991,6 +995,19 @@ void Rim3dView::addAnnotationsToModel( cvf::ModelBasicList* annotationsModel )
     annotationsModel->updateBoundingBoxesRecursive();
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void Rim3dView::addCellFiltersToModel( cvf::ModelBasicList* cellFilterModel )
+{
+    if ( !this->ownerCase() ) return;
+
+    cvf::ref<caf::DisplayCoordTransform> transForm = displayCoordTransform();
+    m_cellfilterPartManager->appendGeometryPartsToModel( cellFilterModel, transForm.p(), ownerCase()->allCellsBoundingBox() );
+
+    cellFilterModel->updateBoundingBoxesRecursive();
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------
@@ -1529,6 +1546,28 @@ void Rim3dView::appendAnnotationsToModel()
     }
 }
 
+//--------------------------------------------------------------------------------------------------
+///
+//--------------------------------------------------------------------------------------------------
+void Rim3dView::appendCellFiltersToModel()
+{
+    if ( !nativeOrOverrideViewer() ) return;
+
+    cvf::Scene* frameScene = nativeOrOverrideViewer()->frame( m_currentTimeStep, isUsingOverrideViewer() );
+    if ( frameScene )
+    {
+        cvf::String name = "CellFilters";
+        this->removeModelByName( frameScene, name );
+
+        cvf::ref<cvf::ModelBasicList> model = new cvf::ModelBasicList;
+        model->setName( name );
+
+        addCellFiltersToModel( model.p() );
+
+        frameScene->addModel( model.p() );
+    }
+}
+
 //--------------------------------------------------------------------------------------------------
 ///
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/Rim3dView.h

@@ -46,6 +46,7 @@ class RiuViewer;
 class RivAnnotationsPartMgr;
 class RivMeasurementPartMgr;
 class RivWellPathsPartMgr;
+class RivCellFilterPartMgr;
 class RimViewNameConfig;
 
 namespace cvf
@@ -192,6 +193,7 @@ protected:
                                      const cvf::BoundingBox& wellPathClipBoundingBox );
     void addAnnotationsToModel( cvf::ModelBasicList* annotationsModel );
     void addMeasurementToModel( cvf::ModelBasicList* measureModel );
+    void addCellFiltersToModel( cvf::ModelBasicList* cellFilterModel );
 
     // Override viewer
 
@@ -277,6 +279,7 @@ private:
     void createHighlightAndGridBoxDisplayModel();
     void appendAnnotationsToModel();
     void appendMeasurementToModel();
+    void appendCellFiltersToModel();
 
     // Pure private methods : Override viewer and comparison view
 
@@ -308,4 +311,5 @@ private:
     cvf::ref<cvf::ModelBasicList>   m_highlightVizModel;
     cvf::ref<RivAnnotationsPartMgr> m_annotationsPartManager;
     cvf::ref<RivMeasurementPartMgr> m_measurementPartManager;
+    cvf::ref<RivCellFilterPartMgr>  m_cellfilterPartManager;
 };

ApplicationLibCode/ProjectDataModel/RimEclipseView.cpp

@@ -1518,6 +1518,7 @@ void RimEclipseView::setEclipseCase( RimEclipseCase* reservoir )
     m_eclipseCase = reservoir;
     cellResult()->setEclipseCase( reservoir );
     faultResultSettings()->customFaultResult()->setEclipseCase( reservoir );
+    cellFilterCollection()->setCase( reservoir );
 
     cellEdgeResult()->setEclipseCase( reservoir );
 }

ApplicationLibCode/ProjectDataModel/RimGeoMechView.cpp

@@ -434,6 +434,7 @@ void RimGeoMechView::setGeoMechCase( RimGeoMechCase* gmCase )
 {
     m_geomechCase = gmCase;
     cellResult()->setGeoMechCase( gmCase );
+    cellFilterCollection()->setCase( gmCase );
 }
 
 //--------------------------------------------------------------------------------------------------

ApplicationLibCode/ProjectDataModel/RimPolylinesDataInterface.h

@@ -0,0 +1,29 @@
+/////////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (C) 2021 Equinor ASA
+//
+//  ResInsight is free software: you can redistribute it and/or modify
+//  it under the terms of the GNU General Public License as published by
+//  the Free Software Foundation, either version 3 of the License, or
+//  (at your option) any later version.
+//
+//  ResInsight is distributed in the hope that it will be useful, but WITHOUT ANY
+//  WARRANTY; without even the implied warranty of MERCHANTABILITY or
+//  FITNESS FOR A PARTICULAR PURPOSE.
+//
+//  See the GNU General Public License at <http://www.gnu.org/licenses/gpl.html>
+//  for more details.
+//
+/////////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+#include "cvfObject.h"
+
+class RigPolyLinesData;
+
+class RimPolylinesDataInterface
+{
+public:
+    virtual cvf::ref<RigPolyLinesData> polyLinesData() const = 0;
+};

ApplicationLibCode/ProjectDataModel/RimViewController.cpp

@@ -1037,6 +1037,7 @@ void RimViewController::updateCellFilterOverrides( const RimCellFilter* changedF
                     {
                         RimGeoMechCase* gCase = depGeomView->geoMechCase();
                         polyDstFilter->setCase( gCase );
+                        polyDstFilter->enableKFilter( false );
                     }
                 }
             }
@@ -1068,6 +1069,7 @@ void RimViewController::updateCellFilterOverrides( const RimCellFilter* changedF
                     {
                         RimEclipseCase* eCase = depEclView->eclipseCase();
                         polyDstFilter->setCase( eCase );
+                        polyDstFilter->enableKFilter( false );
                     }
                 }
             }