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

Polygonfilter updates2 (#7286)

Browse Source 
* 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
This commit is contained in:
jonjenssen 2021-01-26 13:08:21 +01:00 committed by GitHub
parent 4866794f2b
commit 05aceef936
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
32 changed files with 1218 additions and 348 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
ApplicationLibCode/Commands/RicNewContourMapViewFeature.cpp
View File

@ -36,6 +36,7 @@
#include "RimGeoMechView.h" #include "RimGeoMechView.h"
#include "RimRegularLegendConfig.h" #include "RimRegularLegendConfig.h"
#include "RimCellFilterCollection.h"
#include "RimFaultInViewCollection.h" #include "RimFaultInViewCollection.h"
#include "RimSimWellInViewCollection.h" #include "RimSimWellInViewCollection.h"
#include "RimSurfaceInViewCollection.h" #include "RimSurfaceInViewCollection.h"
@ -127,6 +128,7 @@ void RicNewContourMapViewFeature::onActionTriggered( bool isChecked )
if ( eclipseCase ) if ( eclipseCase )
{ {
eclipseCase->updateConnectedEditors(); eclipseCase->updateConnectedEditors();
eclipseContourMap->cellFilterCollection()->setCase( eclipseCase );
} }
caf::SelectionManager::instance()->setSelectedItem( eclipseContourMap ); caf::SelectionManager::instance()->setSelectedItem( eclipseContourMap );
@ -145,6 +147,7 @@ void RicNewContourMapViewFeature::onActionTriggered( bool isChecked )
if ( geoMechCase ) if ( geoMechCase )
{ {
geoMechCase->updateConnectedEditors(); geoMechCase->updateConnectedEditors();
eclipseContourMap->cellFilterCollection()->setCase( geoMechCase );
caf::SelectionManager::instance()->setSelectedItem( geoMechContourMap ); caf::SelectionManager::instance()->setSelectedItem( geoMechContourMap );
geoMechContourMap->createDisplayModelAndRedraw(); geoMechContourMap->createDisplayModelAndRedraw();
geoMechContourMap->zoomAll(); geoMechContourMap->zoomAll();

6
ApplicationLibCode/ModelVisualization/CMakeLists_files.cmake
View File

@ -49,7 +49,6 @@ ${CMAKE_CURRENT_LIST_DIR}/RivContourMapProjectionPartMgr.h
${CMAKE_CURRENT_LIST_DIR}/RivAnnotationsPartMgr.h ${CMAKE_CURRENT_LIST_DIR}/RivAnnotationsPartMgr.h
${CMAKE_CURRENT_LIST_DIR}/RivTextAnnotationPartMgr.h ${CMAKE_CURRENT_LIST_DIR}/RivTextAnnotationPartMgr.h
${CMAKE_CURRENT_LIST_DIR}/RivReachCircleAnnotationPartMgr.h ${CMAKE_CURRENT_LIST_DIR}/RivReachCircleAnnotationPartMgr.h
${CMAKE_CURRENT_LIST_DIR}/RivPolylineAnnotationPartMgr.h
${CMAKE_CURRENT_LIST_DIR}/RivReachCircleAnnotationSourceInfo.h ${CMAKE_CURRENT_LIST_DIR}/RivReachCircleAnnotationSourceInfo.h
${CMAKE_CURRENT_LIST_DIR}/RivPolylinesAnnotationSourceInfo.h ${CMAKE_CURRENT_LIST_DIR}/RivPolylinesAnnotationSourceInfo.h
${CMAKE_CURRENT_LIST_DIR}/RivPolylineGenerator.h ${CMAKE_CURRENT_LIST_DIR}/RivPolylineGenerator.h
@ -58,6 +57,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RivTextLabelSourceInfo.h
${CMAKE_CURRENT_LIST_DIR}/RivDiskGeometryGenerator.h ${CMAKE_CURRENT_LIST_DIR}/RivDiskGeometryGenerator.h
${CMAKE_CURRENT_LIST_DIR}/RivWellDiskPartMgr.h ${CMAKE_CURRENT_LIST_DIR}/RivWellDiskPartMgr.h
${CMAKE_CURRENT_LIST_DIR}/RivElementVectorResultPartMgr.h ${CMAKE_CURRENT_LIST_DIR}/RivElementVectorResultPartMgr.h
${CMAKE_CURRENT_LIST_DIR}/RivPolylinePartMgr.h
${CMAKE_CURRENT_LIST_DIR}/RivCellFilterPartMgr.h
) )
set (SOURCE_GROUP_SOURCE_FILES set (SOURCE_GROUP_SOURCE_FILES
@ -105,7 +106,6 @@ ${CMAKE_CURRENT_LIST_DIR}/RivContourMapProjectionPartMgr.cpp
${CMAKE_CURRENT_LIST_DIR}/RivAnnotationsPartMgr.cpp ${CMAKE_CURRENT_LIST_DIR}/RivAnnotationsPartMgr.cpp
${CMAKE_CURRENT_LIST_DIR}/RivTextAnnotationPartMgr.cpp ${CMAKE_CURRENT_LIST_DIR}/RivTextAnnotationPartMgr.cpp
${CMAKE_CURRENT_LIST_DIR}/RivReachCircleAnnotationPartMgr.cpp ${CMAKE_CURRENT_LIST_DIR}/RivReachCircleAnnotationPartMgr.cpp
${CMAKE_CURRENT_LIST_DIR}/RivPolylineAnnotationPartMgr.cpp
${CMAKE_CURRENT_LIST_DIR}/RivReachCircleAnnotationSourceInfo.cpp ${CMAKE_CURRENT_LIST_DIR}/RivReachCircleAnnotationSourceInfo.cpp
${CMAKE_CURRENT_LIST_DIR}/RivPolylinesAnnotationSourceInfo.cpp ${CMAKE_CURRENT_LIST_DIR}/RivPolylinesAnnotationSourceInfo.cpp
${CMAKE_CURRENT_LIST_DIR}/RivPolylineGenerator.cpp ${CMAKE_CURRENT_LIST_DIR}/RivPolylineGenerator.cpp
@ -114,6 +114,8 @@ ${CMAKE_CURRENT_LIST_DIR}/RivTextLabelSourceInfo.cpp
${CMAKE_CURRENT_LIST_DIR}/RivDiskGeometryGenerator.cpp ${CMAKE_CURRENT_LIST_DIR}/RivDiskGeometryGenerator.cpp
${CMAKE_CURRENT_LIST_DIR}/RivWellDiskPartMgr.cpp ${CMAKE_CURRENT_LIST_DIR}/RivWellDiskPartMgr.cpp
${CMAKE_CURRENT_LIST_DIR}/RivElementVectorResultPartMgr.cpp ${CMAKE_CURRENT_LIST_DIR}/RivElementVectorResultPartMgr.cpp
${CMAKE_CURRENT_LIST_DIR}/RivPolylinePartMgr.cpp
${CMAKE_CURRENT_LIST_DIR}/RivCellFilterPartMgr.cpp
) )
list(APPEND CODE_HEADER_FILES list(APPEND CODE_HEADER_FILES

8
ApplicationLibCode/ModelVisualization/RivAnnotationsPartMgr.cpp
View File

@ -27,10 +27,12 @@
#include "RimPolylinesFromFileAnnotationInView.h" #include "RimPolylinesFromFileAnnotationInView.h"
#include "RimUserDefinedPolylinesAnnotationInView.h" #include "RimUserDefinedPolylinesAnnotationInView.h"
#include "RivPolylineAnnotationPartMgr.h" #include "RivPolylinePartMgr.h"
#include "RivReachCircleAnnotationPartMgr.h" #include "RivReachCircleAnnotationPartMgr.h"
#include "RivTextAnnotationPartMgr.h" #include "RivTextAnnotationPartMgr.h"
#include "cafPdmObject.h"
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -113,12 +115,12 @@ void RivAnnotationsPartMgr::createAnnotationPartManagers()
{ {
for ( auto annotation : userDefinedPolylineAnnotations ) for ( auto annotation : userDefinedPolylineAnnotations )
{ {
auto* apm = new RivPolylineAnnotationPartMgr( m_rimView, annotation ); auto* apm = new RivPolylinePartMgr( m_rimView, annotation, coll );
m_polylineAnnotationPartMgrs.push_back( apm ); m_polylineAnnotationPartMgrs.push_back( apm );
} }
for ( auto annotation : polylineFromFileAnnotations ) for ( auto annotation : polylineFromFileAnnotations )
{ {
auto* apm = new RivPolylineAnnotationPartMgr( m_rimView, annotation ); auto* apm = new RivPolylinePartMgr( m_rimView, annotation, coll );
m_polylineAnnotationPartMgrs.push_back( apm ); m_polylineAnnotationPartMgrs.push_back( apm );
} }
} }

7
ApplicationLibCode/ModelVisualization/RivAnnotationsPartMgr.h
View File

@ -37,12 +37,9 @@ class DisplayCoordTransform;
} }
class Rim3dView; class Rim3dView;
class RimAnnotationInViewCollection;
class RivTextAnnotationPartMgr; class RivTextAnnotationPartMgr;
class RivReachCircleAnnotationPartMgr; class RivReachCircleAnnotationPartMgr;
class RivPolylineAnnotationPartMgr; class RivPolylinePartMgr;
class RimSimWellInView;
class RimSimWellInViewCollection;
class RivAnnotationsPartMgr : public cvf::Object class RivAnnotationsPartMgr : public cvf::Object
{ {
@ -63,5 +60,5 @@ private:
caf::PdmPointer<Rim3dView> m_rimView; caf::PdmPointer<Rim3dView> m_rimView;
cvf::Collection<RivTextAnnotationPartMgr> m_textAnnotationPartMgrs; cvf::Collection<RivTextAnnotationPartMgr> m_textAnnotationPartMgrs;
cvf::Collection<RivReachCircleAnnotationPartMgr> m_reachCircleAnnotationPartMgrs; cvf::Collection<RivReachCircleAnnotationPartMgr> m_reachCircleAnnotationPartMgrs;
cvf::Collection<RivPolylineAnnotationPartMgr> m_polylineAnnotationPartMgrs; cvf::Collection<RivPolylinePartMgr> m_polylineAnnotationPartMgrs;
}; };

89
ApplicationLibCode/ModelVisualization/RivCellFilterPartMgr.cpp Normal file
View File

@ -0,0 +1,89 @@
/////////////////////////////////////////////////////////////////////////////////
//
// 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 "RivCellFilterPartMgr.h"
#include "Rim3dView.h"
#include "RimCellFilterCollection.h"
#include "RimPolygonFilter.h"
#include "RivPolylinePartMgr.h"
#include "cafPdmObject.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivCellFilterPartMgr::RivCellFilterPartMgr( Rim3dView* view )
: m_rimView( view )
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivCellFilterPartMgr::~RivCellFilterPartMgr()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivCellFilterPartMgr::appendGeometryPartsToModel( cvf::ModelBasicList* model,
const caf::DisplayCoordTransform* displayCoordTransform,
const cvf::BoundingBox& boundingBox )
{
createCellFilterPartManagers();
for ( auto& partMgr : m_cellFilterPartMgrs )
{
partMgr->appendDynamicGeometryPartsToModel( model, displayCoordTransform, boundingBox );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivCellFilterPartMgr::createCellFilterPartManagers()
{
std::vector<RimCellFilterCollection*> colls;
m_rimView->descendantsIncludingThisOfType( colls );
if ( colls.empty() ) return;
auto coll = colls.front();
clearGeometryCache();
for ( auto filter : coll->filters() )
{
RimPolygonFilter* polyFilter = dynamic_cast<RimPolygonFilter*>( filter );
if ( polyFilter )
{
RivPolylinePartMgr* ppm = new RivPolylinePartMgr( m_rimView, polyFilter, coll );
m_cellFilterPartMgrs.push_back( ppm );
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivCellFilterPartMgr::clearGeometryCache()
{
m_cellFilterPartMgrs.clear();
}

60
ApplicationLibCode/ModelVisualization/RivCellFilterPartMgr.h Normal file
View File

@ -0,0 +1,60 @@
/////////////////////////////////////////////////////////////////////////////////
//
// 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 "cafPdmPointer.h"
#include "cvfAssert.h"
#include "cvfCollection.h"
#include "cvfObject.h"
namespace cvf
{
class BoundingBox;
class Part;
class ModelBasicList;
class Transform;
class Font;
} // namespace cvf
namespace caf
{
class DisplayCoordTransform;
}
class Rim3dView;
class RivPolylinePartMgr;
class RivCellFilterPartMgr : public cvf::Object
{
public:
RivCellFilterPartMgr( Rim3dView* view );
~RivCellFilterPartMgr() override;
void appendGeometryPartsToModel( cvf::ModelBasicList* model,
const caf::DisplayCoordTransform* displayCoordTransform,
const cvf::BoundingBox& boundingBox );
void clearGeometryCache();
private:
void createCellFilterPartManagers();
private:
caf::PdmPointer<Rim3dView> m_rimView;
cvf::Collection<RivPolylinePartMgr> m_cellFilterPartMgrs;
};

6
ApplicationLibCode/ModelVisualization/RivMeasurementPartMgr.cpp
View File

@ -26,19 +26,13 @@
#include "RiaPreferences.h" #include "RiaPreferences.h"
#include "Rim3dView.h" #include "Rim3dView.h"
#include "RimAnnotationInViewCollection.h"
#include "RimMeasurement.h" #include "RimMeasurement.h"
#include "RimPolylinesFromFileAnnotationInView.h"
#include "RimProject.h" #include "RimProject.h"
#include "RimUserDefinedPolylinesAnnotationInView.h"
#include "RiuGuiTheme.h" #include "RiuGuiTheme.h"
#include "RivPartPriority.h" #include "RivPartPriority.h"
#include "RivPolylineAnnotationPartMgr.h"
#include "RivPolylineGenerator.h" #include "RivPolylineGenerator.h"
#include "RivReachCircleAnnotationPartMgr.h"
#include "RivTextAnnotationPartMgr.h"
#include "cafDisplayCoordTransform.h" #include "cafDisplayCoordTransform.h"
#include "cafEffectGenerator.h" #include "cafEffectGenerator.h"

285
ApplicationLibCode/ModelVisualization/RivPolylineAnnotationPartMgr.cpp
View File

@ -1,285 +0,0 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- 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 "RivPolylineAnnotationPartMgr.h"
#include "RiaBoundingBoxTools.h"
#include "RiaGuiApplication.h"
#include "Rim3dView.h"
#include "RimAnnotationCollection.h"
#include "RimAnnotationInViewCollection.h"
#include "RimAnnotationLineAppearance.h"
#include "RimEclipseView.h"
#include "RimPolylinesAnnotation.h"
#include "RimPolylinesAnnotationInView.h"
#include "RigMainGrid.h"
#include "RigPolyLinesData.h"
#include "RivPartPriority.h"
#include "RivPolylineGenerator.h"
#include "RivPolylinesAnnotationSourceInfo.h"
#include "cafEffectGenerator.h"
#include "cafDisplayCoordTransform.h"
#include "cvfDrawableGeo.h"
#include "cvfDrawableText.h"
#include "cvfDrawableVectors.h"
#include "cvfGeometryBuilderTriangles.h"
#include "cvfGeometryUtils.h"
#include "cvfModelBasicList.h"
#include "cvfPart.h"
#include "cvfTransform.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivPolylineAnnotationPartMgr::RivPolylineAnnotationPartMgr( Rim3dView* view, RimPolylinesAnnotationInView* annotationInView )
: m_rimView( view )
, m_rimAnnotationInView( annotationInView )
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivPolylineAnnotationPartMgr::~RivPolylineAnnotationPartMgr()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivPolylineAnnotationPartMgr::buildPolylineAnnotationParts( const caf::DisplayCoordTransform* displayXf )
{
clearAllGeometry();
auto rimAnnotation = m_rimAnnotationInView->sourceAnnotation();
if ( !rimAnnotation->isEmpty() && rimAnnotation->isActive() )
{
auto lineColor = rimAnnotation->appearance()->color();
auto isDashedLine = rimAnnotation->appearance()->isDashed();
auto lineThickness = rimAnnotation->appearance()->thickness();
auto* collection = annotationCollection();
if ( !collection ) return;
auto linesInDomain = getPolylinesPointsInDomain( collection->snapAnnotations(), collection->annotationPlaneZ() );
auto linesInDisplay = transformPolylinesPointsToDisplay( linesInDomain, displayXf );
// Line part
if ( rimAnnotation->showLines() )
{
cvf::ref<cvf::DrawableGeo> drawableGeo =
RivPolylineGenerator::createLineAlongPolylineDrawable( linesInDisplay, rimAnnotation->closePolyline() );
cvf::ref<cvf::Part> part = new cvf::Part;
part->setName( "RivPolylineAnnotationPartMgr" );
part->setDrawable( drawableGeo.p() );
caf::MeshEffectGenerator effgen( lineColor );
effgen.setLineWidth( lineThickness );
if ( isDashedLine ) effgen.setLineStipple( true );
cvf::ref<cvf::Effect> eff = effgen.generateCachedEffect();
part->setEffect( eff.p() );
part->setPriority( RivPartPriority::PartType::MeshLines );
cvf::ref<RivPolylinesAnnotationSourceInfo> sourceInfo = new RivPolylinesAnnotationSourceInfo( rimAnnotation );
part->setSourceInfo( sourceInfo.p() );
m_linePart = part;
}
// Sphere part
if ( rimAnnotation->showSpheres() )
{
auto sphereColor = rimAnnotation->appearance()->sphereColor();
double sphereRadiusFactor = rimAnnotation->appearance()->sphereRadiusFactor();
cvf::ref<cvf::Vec3fArray> vertices = new cvf::Vec3fArray;
cvf::ref<cvf::Vec3fArray> vecRes = new cvf::Vec3fArray;
cvf::ref<cvf::Color3fArray> colors = new cvf::Color3fArray;
size_t pointCount = 0;
for ( const auto& line : linesInDisplay )
pointCount += line.size();
vertices->reserve( pointCount );
vecRes->reserve( pointCount );
colors->reserve( pointCount );
for ( const auto& line : linesInDisplay )
{
for ( const auto& v : line )
{
vertices->add( cvf::Vec3f( v ) );
vecRes->add( cvf::Vec3f::X_AXIS );
colors->add( sphereColor );
}
}
cvf::ref<cvf::DrawableVectors> vectorDrawable;
if ( RiaGuiApplication::instance()->useShaders() )
{
// NOTE: Drawable vectors must be rendered using shaders when the rest of the application is rendered
// using shaders Drawing vectors using fixed function when rest of the application uses shaders causes
// visual artifacts
vectorDrawable = new cvf::DrawableVectors( "u_transformationMatrix", "u_color" );
}
else
{
vectorDrawable = new cvf::DrawableVectors();
}
vectorDrawable->setVectors( vertices.p(), vecRes.p() );
vectorDrawable->setColors( colors.p() );
cvf::GeometryBuilderTriangles builder;
double cellRadius = 15.0;
auto eclipseView = dynamic_cast<RimEclipseView*>( m_rimView.p() );
if ( eclipseView )
{
double characteristicCellSize = eclipseView->mainGrid()->characteristicIJCellSize();
cellRadius = sphereRadiusFactor * characteristicCellSize;
}
cvf::GeometryUtils::createSphere( cellRadius, 15, 15, &builder );
vectorDrawable->setGlyph( builder.trianglesUShort().p(), builder.vertices().p() );
cvf::ref<cvf::Part> part = new cvf::Part;
part->setName( "RivPolylineAnnotationPartMgr" );
part->setDrawable( vectorDrawable.p() );
part->setEffect( new cvf::Effect() );
part->setPriority( RivPartPriority::PartType::MeshLines );
cvf::ref<RivPolylinesAnnotationSourceInfo> sourceInfo = new RivPolylinesAnnotationSourceInfo( rimAnnotation );
part->setSourceInfo( sourceInfo.p() );
m_spherePart = part;
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::vector<RivPolylineAnnotationPartMgr::Vec3d>>
RivPolylineAnnotationPartMgr::getPolylinesPointsInDomain( bool snapToPlaneZ, double planeZ )
{
auto polylines = m_rimAnnotationInView->sourceAnnotation()->polyLinesData()->polyLines();
if ( !snapToPlaneZ ) return polylines;
std::vector<std::vector<Vec3d>> polylinesInDisplay;
for ( const auto& pts : polylines )
{
std::vector<Vec3d> polyline;
for ( const auto& pt : pts )
{
auto ptInDisp = pt;
ptInDisp.z() = planeZ;
polyline.push_back( ptInDisp );
}
polylinesInDisplay.push_back( polyline );
}
return polylinesInDisplay;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::vector<cvf::Vec3d>>
RivPolylineAnnotationPartMgr::transformPolylinesPointsToDisplay( const std::vector<std::vector<Vec3d>>& pointsInDomain,
const caf::DisplayCoordTransform* displayXf )
{
std::vector<std::vector<Vec3d>> pointsInDisplay;
for ( const auto& pts : pointsInDomain )
{
std::vector<cvf::Vec3d> displayCoords = displayXf->transformToDisplayCoords( pts );
pointsInDisplay.push_back( displayCoords );
}
return pointsInDisplay;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RivPolylineAnnotationPartMgr::isPolylinesInBoundingBox( const cvf::BoundingBox& boundingBox )
{
auto coll = annotationCollection();
if ( !coll ) return false;
auto effectiveBoundingBox = RiaBoundingBoxTools::inflate( boundingBox, 3 );
for ( const auto& pts : getPolylinesPointsInDomain( coll->snapAnnotations(), coll->annotationPlaneZ() ) )
{
for ( const auto& pt : pts )
{
if ( effectiveBoundingBox.contains( pt ) ) return true;
}
}
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivPolylineAnnotationPartMgr::clearAllGeometry()
{
m_linePart = nullptr;
m_spherePart = nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimAnnotationInViewCollection* RivPolylineAnnotationPartMgr::annotationCollection() const
{
std::vector<RimAnnotationInViewCollection*> colls;
m_rimView->descendantsIncludingThisOfType( colls );
return !colls.empty() ? colls.front() : nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivPolylineAnnotationPartMgr::appendDynamicGeometryPartsToModel( cvf::ModelBasicList* model,
const caf::DisplayCoordTransform* displayXf,
const cvf::BoundingBox& boundingBox )
{
auto rimAnnotation = m_rimAnnotationInView->sourceAnnotation();
if ( !rimAnnotation ) return;
if ( rimAnnotation->isEmpty() ) return;
if ( !m_rimAnnotationInView->isVisible() ) return;
// Check bounding box
if ( !isPolylinesInBoundingBox( boundingBox ) ) return;
buildPolylineAnnotationParts( displayXf );
if ( m_linePart.notNull() )
{
model->addPart( m_linePart.p() );
}
if ( m_spherePart.notNull() )
{
model->addPart( m_spherePart.p() );
}
}

274
ApplicationLibCode/ModelVisualization/RivPolylinePartMgr.cpp Normal file
View File

@ -0,0 +1,274 @@
/////////////////////////////////////////////////////////////////////////////////
//
// Copyright (C) 2018- 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 "RivPolylinePartMgr.h"
#include "RiaBoundingBoxTools.h"
#include "RiaGuiApplication.h"
#include "Rim3dView.h"
#include "RimEclipseView.h"
#include "RimPolylinesDataInterface.h"
#include "RigMainGrid.h"
#include "RigPolyLinesData.h"
#include "RivPartPriority.h"
#include "RivPolylineGenerator.h"
#include "cafEffectGenerator.h"
#include "cafDisplayCoordTransform.h"
#include "cvfDrawableGeo.h"
#include "cvfDrawableText.h"
#include "cvfDrawableVectors.h"
#include "cvfGeometryBuilderTriangles.h"
#include "cvfGeometryUtils.h"
#include "cvfModelBasicList.h"
#include "cvfPart.h"
#include "cvfTransform.h"
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivPolylinePartMgr::RivPolylinePartMgr( Rim3dView* view,
RimPolylinesDataInterface* polylineInterface,
caf::PdmObject* collection )
: m_rimView( view )
, m_polylineInterface( polylineInterface )
, m_viewCollection( collection )
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RivPolylinePartMgr::~RivPolylinePartMgr()
{
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RivPolylinePartMgr::isPolylinesInBoundingBox( std::vector<std::vector<cvf::Vec3d>> polyline,
const cvf::BoundingBox& boundingBox )
{
auto effectiveBoundingBox = RiaBoundingBoxTools::inflate( boundingBox, 3 );
for ( const auto& pts : polyline )
{
for ( const auto& pt : pts )
{
if ( effectiveBoundingBox.contains( pt ) ) return true;
}
}
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivPolylinePartMgr::buildPolylineParts( const caf::DisplayCoordTransform* displayXf,
const cvf::BoundingBox& boundingBox )
{
auto polylineDef = m_polylineInterface->polyLinesData();
if ( polylineDef.isNull() || polylineDef->polyLines().size() == 0 )
{
clearAllGeometry();
return;
}
auto linesInDomain = getPolylinesPointsInDomain( polylineDef->lockToZPlane(), polylineDef->lockedZValue() );
if ( !isPolylinesInBoundingBox( linesInDomain, boundingBox ) ) return;
auto linesInDisplay = transformPolylinesPointsToDisplay( linesInDomain, displayXf );
clearAllGeometry();
// Line part
if ( polylineDef->showLines() )
{
cvf::ref<cvf::DrawableGeo> drawableGeo =
RivPolylineGenerator::createLineAlongPolylineDrawable( linesInDisplay, polylineDef->closePolyline() );
cvf::ref<cvf::Part> part = new cvf::Part;
part->setName( "RivPolylinePartMgr" );
part->setDrawable( drawableGeo.p() );
caf::MeshEffectGenerator effgen( polylineDef->lineColor() );
effgen.setLineWidth( polylineDef->lineThickness() );
// if ( isDashedLine ) effgen.setLineStipple( true );
cvf::ref<cvf::Effect> eff = effgen.generateCachedEffect();
part->setEffect( eff.p() );
part->setPriority( RivPartPriority::PartType::MeshLines );
m_linePart = part;
}
// Sphere part
if ( polylineDef->showSpheres() )
{
auto sphereColor = polylineDef->sphereColor();
double sphereRadiusFactor = polylineDef->sphereRadiusFactor();
cvf::ref<cvf::Vec3fArray> vertices = new cvf::Vec3fArray;
cvf::ref<cvf::Vec3fArray> vecRes = new cvf::Vec3fArray;
cvf::ref<cvf::Color3fArray> colors = new cvf::Color3fArray;
size_t pointCount = 0;
for ( const auto& line : linesInDisplay )
pointCount += line.size();
vertices->reserve( pointCount );
vecRes->reserve( pointCount );
colors->reserve( pointCount );
for ( const auto& line : linesInDisplay )
{
for ( const auto& v : line )
{
vertices->add( cvf::Vec3f( v ) );
vecRes->add( cvf::Vec3f::X_AXIS );
colors->add( sphereColor );
}
}
cvf::ref<cvf::DrawableVectors> vectorDrawable;
if ( RiaGuiApplication::instance()->useShaders() )
{
// NOTE: Drawable vectors must be rendered using shaders when the rest of the application is rendered
// using shaders Drawing vectors using fixed function when rest of the application uses shaders causes
// visual artifacts
vectorDrawable = new cvf::DrawableVectors( "u_transformationMatrix", "u_color" );
}
else
{
vectorDrawable = new cvf::DrawableVectors();
}
vectorDrawable->setVectors( vertices.p(), vecRes.p() );
vectorDrawable->setColors( colors.p() );
double cellRadius = 15.0;
auto eclipseView = dynamic_cast<RimEclipseView*>( m_rimView.p() );
if ( eclipseView )
{
double characteristicCellSize = eclipseView->mainGrid()->characteristicIJCellSize();
cellRadius = sphereRadiusFactor * characteristicCellSize;
}
cvf::GeometryBuilderTriangles builder;
cvf::GeometryUtils::createSphere( cellRadius, 15, 15, &builder );
vectorDrawable->setGlyph( builder.trianglesUShort().p(), builder.vertices().p() );
cvf::ref<cvf::Part> part = new cvf::Part;
part->setName( "RivPolylinePartMgr" );
part->setDrawable( vectorDrawable.p() );
part->setEffect( new cvf::Effect() );
part->setPriority( RivPartPriority::PartType::MeshLines );
m_spherePart = part;
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::vector<cvf::Vec3d>> RivPolylinePartMgr::getPolylinesPointsInDomain( bool snapToPlaneZ, double planeZ )
{
auto polylines = m_polylineInterface->polyLinesData()->polyLines();
if ( !snapToPlaneZ ) return polylines;
std::vector<std::vector<cvf::Vec3d>> polylinesInDisplay;
for ( const auto& pts : polylines )
{
std::vector<cvf::Vec3d> polyline;
for ( const auto& pt : pts )
{
auto ptInDisp = pt;
ptInDisp.z() = planeZ;
polyline.push_back( ptInDisp );
}
polylinesInDisplay.push_back( polyline );
}
return polylinesInDisplay;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
std::vector<std::vector<cvf::Vec3d>>
RivPolylinePartMgr::transformPolylinesPointsToDisplay( const std::vector<std::vector<cvf::Vec3d>>& pointsInDomain,
const caf::DisplayCoordTransform* displayXf )
{
std::vector<std::vector<cvf::Vec3d>> pointsInDisplay;
for ( const auto& pts : pointsInDomain )
{
std::vector<cvf::Vec3d> displayCoords = displayXf->transformToDisplayCoords( pts );
pointsInDisplay.push_back( displayCoords );
}
return pointsInDisplay;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivPolylinePartMgr::clearAllGeometry()
{
m_linePart = nullptr;
m_spherePart = nullptr;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RivPolylinePartMgr::collectionVisible()
{
if ( m_viewCollection && m_viewCollection->objectToggleField() )
{
caf::PdmField<bool>* field = dynamic_cast<caf::PdmField<bool>*>( m_viewCollection->objectToggleField() );
return field->value();
}
return true;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivPolylinePartMgr::appendDynamicGeometryPartsToModel( cvf::ModelBasicList* model,
const caf::DisplayCoordTransform* displayXf,
const cvf::BoundingBox& boundingBox )
{
if ( !collectionVisible() ) return;
// build the lines
buildPolylineParts( displayXf, boundingBox );
// add the things we should
if ( m_linePart.notNull() )
{
model->addPart( m_linePart.p() );
}
if ( m_spherePart.notNull() )
{
model->addPart( m_spherePart.p() );
}
}

37
ApplicationLibCode/ModelVisualization/RivPolylineAnnotationPartMgr.h → ApplicationLibCode/ModelVisualization/RivPolylinePartMgr.h
View File

@ -22,6 +22,7 @@
#include "cvfObject.h" #include "cvfObject.h"
#include "cvfVector3.h" #include "cvfVector3.h"
#include "cafPdmObject.h"
#include "cafPdmPointer.h" #include "cafPdmPointer.h"
#include <vector> #include <vector>
@ -34,41 +35,41 @@ class ModelBasicList;
class Transform; class Transform;
class Font; class Font;
} // namespace cvf } // namespace cvf
namespace caf namespace caf
{ {
class DisplayCoordTransform; class DisplayCoordTransform;
} }
class Rim3dView; class Rim3dView;
class RimPolylinesAnnotationInView; class RimPolylinesDataInterface;
class RimAnnotationInViewCollection;
class RivPolylineAnnotationPartMgr : public cvf::Object class RivPolylinePartMgr : public cvf::Object
{ {
using Vec3d = cvf::Vec3d;
public: public:
RivPolylineAnnotationPartMgr( Rim3dView* view, RimPolylinesAnnotationInView* annotation ); RivPolylinePartMgr( Rim3dView* view, RimPolylinesDataInterface* polylines, caf::PdmObject* collection );
~RivPolylineAnnotationPartMgr() override; ~RivPolylinePartMgr() override;
void appendDynamicGeometryPartsToModel( cvf::ModelBasicList* model, void appendDynamicGeometryPartsToModel( cvf::ModelBasicList* model,
const caf::DisplayCoordTransform* displayXf, const caf::DisplayCoordTransform* displayXf,
const cvf::BoundingBox& boundingBox ); const cvf::BoundingBox& boundingBox );
private: private:
void buildPolylineAnnotationParts( const caf::DisplayCoordTransform* displayXf ); bool isPolylinesInBoundingBox( std::vector<std::vector<cvf::Vec3d>> polyline, const cvf::BoundingBox& boundingBox );
void buildPolylineParts( const caf::DisplayCoordTransform* displayXf, const cvf::BoundingBox& boundingBox );
std::vector<std::vector<Vec3d>> getPolylinesPointsInDomain( bool snapToPlaneZ, double planeZ ); std::vector<std::vector<cvf::Vec3d>> getPolylinesPointsInDomain( bool snapToPlaneZ, double planeZ );
std::vector<std::vector<Vec3d>> transformPolylinesPointsToDisplay( const std::vector<std::vector<Vec3d>>& pointsInDomain, std::vector<std::vector<cvf::Vec3d>>
const caf::DisplayCoordTransform* displayXf ); transformPolylinesPointsToDisplay( const std::vector<std::vector<cvf::Vec3d>>& pointsInDomain,
const caf::DisplayCoordTransform* displayXf );
bool isPolylinesInBoundingBox( const cvf::BoundingBox& boundingBox ); bool collectionVisible();
void clearAllGeometry(); void clearAllGeometry();
RimAnnotationInViewCollection* annotationCollection() const;
caf::PdmPointer<Rim3dView> m_rimView; RimPolylinesDataInterface* m_polylineInterface;
caf::PdmPointer<RimPolylinesAnnotationInView> m_rimAnnotationInView; caf::PdmObject* m_viewCollection;
cvf::ref<cvf::Part> m_linePart; caf::PdmPointer<Rim3dView> m_rimView;
cvf::ref<cvf::Part> m_spherePart; cvf::ref<cvf::Part> m_linePart;
cvf::ref<cvf::Part> m_spherePart;
}; };

21
ApplicationLibCode/ProjectDataModel/Annotations/RimPolylinesAnnotationInView.cpp
View File

@ -19,8 +19,11 @@
#include "RimPolylinesAnnotationInView.h" #include "RimPolylinesAnnotationInView.h"
#include "RimAnnotationCollectionBase.h" #include "RimAnnotationCollectionBase.h"
#include "RimAnnotationGroupCollection.h" #include "RimAnnotationGroupCollection.h"
#include "RimAnnotationInViewCollection.h"
#include "RimPolylinesAnnotation.h" #include "RimPolylinesAnnotation.h"
#include "RigPolyLinesData.h"
CAF_PDM_SOURCE_INIT( RimPolylinesAnnotationInView, "RimPolylinesAnnotationInView" ); CAF_PDM_SOURCE_INIT( RimPolylinesAnnotationInView, "RimPolylinesAnnotationInView" );
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -122,3 +125,21 @@ caf::PdmFieldHandle* RimPolylinesAnnotationInView::userDescriptionField()
{ {
return m_sourceAnnotation ? m_sourceAnnotation->userDescriptionField() : nullptr; 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;
}

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

@ -20,6 +20,8 @@
#include "RimAnnotationLineAppearance.h" #include "RimAnnotationLineAppearance.h"
#include "RimPolylinesDataInterface.h"
#include "cafAppEnum.h" #include "cafAppEnum.h"
#include "cafPdmChildArrayField.h" #include "cafPdmChildArrayField.h"
#include "cafPdmField.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; CAF_PDM_HEADER_INIT;
@ -60,6 +62,8 @@ public:
bool isVisible() const; bool isVisible() const;
cvf::ref<RigPolyLinesData> polyLinesData() const override;
protected: protected:
void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override; void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
caf::PdmFieldHandle* objectToggleField() override; caf::PdmFieldHandle* objectToggleField() override;

5
ApplicationLibCode/ProjectDataModel/Annotations/RimPolylinesFromFileAnnotation.cpp
View File

@ -143,6 +143,11 @@ void RimPolylinesFromFileAnnotation::readPolyLinesFile( QString* errorMessage )
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
cvf::ref<RigPolyLinesData> RimPolylinesFromFileAnnotation::polyLinesData() 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; return m_polyLinesData;
} }

7
ApplicationLibCode/ProjectDataModel/Annotations/RimUserDefinedPolylinesAnnotation.cpp
View File

@ -80,7 +80,12 @@ cvf::ref<RigPolyLinesData> RimUserDefinedPolylinesAnnotation::polyLinesData()
{ {
line.push_back( target->targetPointXYZ() ); 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; return pld;
} }

1
ApplicationLibCode/ProjectDataModel/CMakeLists_files.cmake
View File

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

2
ApplicationLibCode/ProjectDataModel/CellFilters/CMakeLists_files.cmake
View File

@ -11,6 +11,7 @@ ${CMAKE_CURRENT_LIST_DIR}/RimGeoMechPropertyFilter.h
${CMAKE_CURRENT_LIST_DIR}/RimGeoMechPropertyFilterCollection.h ${CMAKE_CURRENT_LIST_DIR}/RimGeoMechPropertyFilterCollection.h
${CMAKE_CURRENT_LIST_DIR}/RimPolygonFilter.h ${CMAKE_CURRENT_LIST_DIR}/RimPolygonFilter.h
${CMAKE_CURRENT_LIST_DIR}/RimUserDefinedFilter.h ${CMAKE_CURRENT_LIST_DIR}/RimUserDefinedFilter.h
${CMAKE_CURRENT_LIST_DIR}/RimCellFilterIntervalTool.h
) )
set (SOURCE_GROUP_SOURCE_FILES 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}/RimGeoMechPropertyFilterCollection.cpp
${CMAKE_CURRENT_LIST_DIR}/RimPolygonFilter.cpp ${CMAKE_CURRENT_LIST_DIR}/RimPolygonFilter.cpp
${CMAKE_CURRENT_LIST_DIR}/RimUserDefinedFilter.cpp ${CMAKE_CURRENT_LIST_DIR}/RimUserDefinedFilter.cpp
${CMAKE_CURRENT_LIST_DIR}/RimCellFilterIntervalTool.cpp
) )
list(APPEND CODE_HEADER_FILES list(APPEND CODE_HEADER_FILES

13
ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilter.cpp
View File

@ -112,13 +112,24 @@ void RimCellFilter::setActive( bool active )
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// /// Is the filter turned on in the explorer tree?
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
bool RimCellFilter::isActive() const bool RimCellFilter::isActive() const
{ {
return m_isActive(); 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();
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

2
ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilter.h
View File

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

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

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

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

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

125
ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilterIntervalTool.cpp Normal file
View File

@ -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;
}
}
}

55
ApplicationLibCode/ProjectDataModel/CellFilters/RimCellFilterIntervalTool.h Normal file
View File

@ -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;
};

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

@ -25,6 +25,7 @@
#include "RigFemPartGrid.h" #include "RigFemPartGrid.h"
#include "RigGeoMechCaseData.h" #include "RigGeoMechCaseData.h"
#include "RigMainGrid.h" #include "RigMainGrid.h"
#include "RigPolyLinesData.h"
#include "Rim3dView.h" #include "Rim3dView.h"
#include "RimCase.h" #include "RimCase.h"
@ -38,14 +39,20 @@
#include "RiuViewerCommands.h" #include "RiuViewerCommands.h"
#include "RiaStdStringTools.h"
#include "cafCmdFeatureMenuBuilder.h" #include "cafCmdFeatureMenuBuilder.h"
#include "cafPdmUiLineEditor.h"
#include "cafPdmUiPushButtonEditor.h" #include "cafPdmUiPushButtonEditor.h"
#include "cafPdmUiTableViewEditor.h" #include "cafPdmUiTableViewEditor.h"
#include "cafPdmUiTreeOrdering.h" #include "cafPdmUiTreeOrdering.h"
#include <cafPdmUiDoubleSliderEditor.h>
#include "cvfBoundingBox.h" #include "cvfBoundingBox.h"
#include "cvfStructGrid.h" #include "cvfStructGrid.h"
#include <QValidator>
namespace caf namespace caf
{ {
template <> template <>
@ -67,6 +74,42 @@ void caf::AppEnum<RimPolygonFilter::PolygonIncludeType>::setUp()
} // namespace caf } // 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" ); CAF_PDM_SOURCE_INIT( RimPolygonFilter, "PolygonFilter", "PolyLineFilter" );
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -74,6 +117,7 @@ CAF_PDM_SOURCE_INIT( RimPolygonFilter, "PolygonFilter", "PolyLineFilter" );
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RimPolygonFilter::RimPolygonFilter() RimPolygonFilter::RimPolygonFilter()
: m_pickTargetsEventHandler( new RicPolylineTargetsPickEventHandler( this ) ) : m_pickTargetsEventHandler( new RicPolylineTargetsPickEventHandler( this ) )
, m_intervalTool( true )
{ {
CAF_PDM_InitObject( "Polyline Filter", ":/CellFilter_Polygon.png", "", "" ); CAF_PDM_InitObject( "Polyline Filter", ":/CellFilter_Polygon.png", "", "" );
@ -94,6 +138,26 @@ RimPolygonFilter::RimPolygonFilter()
CAF_PDM_InitFieldNoDefault( &m_srcCase, "Case", "Case", "", "", "" ); CAF_PDM_InitFieldNoDefault( &m_srcCase, "Case", "Case", "", "", "" );
m_srcCase.uiCapability()->setUiHidden( true ); 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->setUi3dEditorTypeName( RicPolyline3dEditor::uiEditorTypeName() );
this->uiCapability()->setUiTreeChildrenHidden( true ); this->uiCapability()->setUiTreeChildrenHidden( true );
@ -142,12 +206,40 @@ void RimPolygonFilter::setCase( RimCase* srcCase )
m_srcCase = 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 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,
} }
} }
} }
else if ( field == &m_targets )
if ( field == &m_targets )
{ {
auto tvAttribute = dynamic_cast<caf::PdmUiTableViewEditorAttribute*>( attribute ); auto tvAttribute = dynamic_cast<caf::PdmUiTableViewEditorAttribute*>( attribute );
if ( tvAttribute ) 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 ) void RimPolygonFilter::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{ {
RimCellFilter::defineUiOrdering( uiConfigName, uiOrdering ); uiOrdering.add( &m_name );
uiOrdering.add( &m_polyFilterMode ); auto group = uiOrdering.addNewGroup( "General" );
uiOrdering.add( &m_polyIncludeType ); group->add( &m_filterMode );
uiOrdering.add( &m_targets ); group->add( &m_enableFiltering );
uiOrdering.add( &m_enablePicking ); 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() ); 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 ); 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() ) if ( m_enablePicking() )
{ {
setActive( false ); enableFilter( false );
filterChanged.send(); filterChanged.send();
} }
} }
@ -308,6 +472,8 @@ void RimPolygonFilter::updateCompundFilter( cvf::CellRangeFilter* cellRangeFilte
{ {
CVF_ASSERT( cellRangeFilter ); CVF_ASSERT( cellRangeFilter );
if ( !m_enableFiltering ) return;
if ( m_cells.size() == 0 ) updateCells(); if ( m_cells.size() == 0 ) updateCells();
const auto grid = selectedGrid(); 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 // we should look in depth using Z coordinate
// loop over all cells // loop over all cells
for ( size_t i = 0; i < grid->cellCount(); i++ ) for ( size_t n = 0; n < grid->cellCount(); n++ )
{ {
// valid cell? // valid cell?
RigCell cell = grid->cellByGridAndGridLocalCellIdx( gridIndex(), i ); RigCell cell = grid->cellByGridAndGridLocalCellIdx( gridIndex(), n );
if ( cell.isInvalid() ) continue; if ( cell.isInvalid() ) continue;
// get corner coordinates // get corner coordinates
std::array<cvf::Vec3d, 8> hexCorners; 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 // check if the polygon includes the cell
if ( cellInsidePolygon2D( cell.center(), hexCorners, points ) ) 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++ ) for ( size_t k = 0; k < grid->cellCountK(); k++ )
{ {
if ( !m_intervalTool.isNumberIncluded( k ) ) continue;
// get the cell index // get the cell index
size_t newIdx = grid->cellIndexFromIJK( ci, cj, k ); size_t newIdx = grid->cellIndexFromIJK( ci, cj, k );
// valid cell? // valid cell?
@ -505,6 +678,8 @@ void RimPolygonFilter::updateCellsDepthGeoMech( const std::vector<cvf::Vec3d>& p
{ {
for ( size_t k = 0; k < grid->cellCountK(); k++ ) for ( size_t k = 0; k < grid->cellCountK(); k++ )
{ {
if ( !m_intervalTool.isNumberIncluded( k ) ) continue;
size_t cellIdx = grid->cellIndexFromIJK( i, j, k ); size_t cellIdx = grid->cellIndexFromIJK( i, j, k );
cvf::Vec3d vertices[8]; 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++ ) for ( size_t k = 0; k < grid->cellCountK(); k++ )
{ {
if ( !m_intervalTool.isNumberIncluded( k ) ) continue;
// get the cell index // get the cell index
size_t newIdx = grid->cellIndexFromIJK( ci, cj, k ); size_t newIdx = grid->cellIndexFromIJK( ci, cj, k );
m_cells.push_back( newIdx ); m_cells.push_back( newIdx );
@ -643,6 +820,9 @@ void RimPolygonFilter::updateCells()
// reset // reset
m_cells.clear(); m_cells.clear();
// get optional k-cell filter
m_intervalTool.setInterval( m_enableKFilter, m_kFilterStr );
// get polyline as vector // get polyline as vector
std::vector<cvf::Vec3d> points; std::vector<cvf::Vec3d> points;
for ( auto& target : m_targets ) for ( auto& target : m_targets )
@ -668,3 +848,32 @@ void RimPolygonFilter::updateCells()
updateCellsForGeoMech( points, gCase ); 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;
}

27
ApplicationLibCode/ProjectDataModel/CellFilters/RimPolygonFilter.h
View File

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

41
ApplicationLibCode/ProjectDataModel/Rim3dView.cpp
View File

@ -43,6 +43,7 @@
#include "RimWellPathCollection.h" #include "RimWellPathCollection.h"
#include "RivAnnotationsPartMgr.h" #include "RivAnnotationsPartMgr.h"
#include "RivCellFilterPartMgr.h"
#include "RivMeasurementPartMgr.h" #include "RivMeasurementPartMgr.h"
#include "RivWellPathsPartMgr.h" #include "RivWellPathsPartMgr.h"
@ -170,8 +171,9 @@ Rim3dView::Rim3dView( void )
m_wellPathsPartManager = new RivWellPathsPartMgr( this ); m_wellPathsPartManager = new RivWellPathsPartMgr( this );
m_annotationsPartManager = new RivAnnotationsPartMgr( this ); m_annotationsPartManager = new RivAnnotationsPartMgr( this );
m_cellfilterPartManager = new RivCellFilterPartMgr( this );
m_measurementPartManager = new RivMeasurementPartMgr( this ); m_measurementPartManager = new RivMeasurementPartMgr( this );
this->setAs3DViewMdiWindow(); this->setAs3DViewMdiWindow();
} }
@ -570,12 +572,14 @@ void Rim3dView::updateDisplayModelForCurrentTimeStepAndRedraw()
this->onUpdateDisplayModelForCurrentTimeStep(); this->onUpdateDisplayModelForCurrentTimeStep();
appendAnnotationsToModel(); appendAnnotationsToModel();
appendMeasurementToModel(); appendMeasurementToModel();
appendCellFiltersToModel();
if ( Rim3dView* depView = prepareComparisonView() ) if ( Rim3dView* depView = prepareComparisonView() )
{ {
depView->onUpdateDisplayModelForCurrentTimeStep(); depView->onUpdateDisplayModelForCurrentTimeStep();
depView->appendAnnotationsToModel(); depView->appendAnnotationsToModel();
depView->appendMeasurementToModel(); depView->appendMeasurementToModel();
depView->appendCellFiltersToModel();
restoreComparisonView(); restoreComparisonView();
} }
@ -991,6 +995,19 @@ void Rim3dView::addAnnotationsToModel( cvf::ModelBasicList* annotationsModel )
annotationsModel->updateBoundingBoxesRecursive(); 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() );
}
}
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------

4
ApplicationLibCode/ProjectDataModel/Rim3dView.h
View File

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

1
ApplicationLibCode/ProjectDataModel/RimEclipseView.cpp
View File

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

1
ApplicationLibCode/ProjectDataModel/RimGeoMechView.cpp
View File

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

29
ApplicationLibCode/ProjectDataModel/RimPolylinesDataInterface.h Normal file
View File

@ -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;
};

2
ApplicationLibCode/ProjectDataModel/RimViewController.cpp
View File

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

153
ApplicationLibCode/ReservoirDataModel/RigPolyLinesData.cpp
View File

@ -1,7 +1,6 @@
#include "RigPolyLinesData.h"
///////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////
// //
// Copyright (C) 2018- Equinor ASA // Copyright (C) 2021 Equinor ASA
// //
// ResInsight is free software: you can redistribute it and/or modify // ResInsight is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by // it under the terms of the GNU General Public License as published by
@ -22,7 +21,16 @@
/// ///
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
RigPolyLinesData::RigPolyLinesData() RigPolyLinesData::RigPolyLinesData()
: m_showLines( true )
, m_showSpheres( true )
, m_lineThickness( 4 )
, m_sphereRadiusFactor( 0.1 )
, m_lockToZPlane( false )
, m_lockedZValue( 0.0 )
, m_closePolyline( true )
{ {
m_sphereColor.set( 200, 200, 200 );
m_lineColor.set( 200, 200, 200 );
} }
//-------------------------------------------------------------------------------------------------- //--------------------------------------------------------------------------------------------------
@ -31,3 +39,144 @@ RigPolyLinesData::RigPolyLinesData()
RigPolyLinesData::~RigPolyLinesData() RigPolyLinesData::~RigPolyLinesData()
{ {
} }
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
const std::vector<std::vector<cvf::Vec3d>>& RigPolyLinesData::polyLines() const
{
return m_polylines;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigPolyLinesData::setPolyLines( const std::vector<std::vector<cvf::Vec3d>>& polyLines )
{
m_polylines = polyLines;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigPolyLinesData::setPolyLine( const std::vector<cvf::Vec3d>& polyline )
{
m_polylines = { polyline };
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigPolyLinesData::addPolyLine( const std::vector<cvf::Vec3d>& polyline )
{
m_polylines.push_back( polyline );
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigPolyLinesData::setVisibility( bool showLines, bool showSpheres )
{
m_showLines = showLines;
m_showSpheres = showSpheres;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigPolyLinesData::setLineAppearance( int lineThickness, cvf::Color3f color, bool closePolyline )
{
m_lineThickness = lineThickness;
m_lineColor = color;
m_closePolyline = closePolyline;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigPolyLinesData::setSphereAppearance( double radiusFactor, cvf::Color3f color )
{
m_sphereRadiusFactor = radiusFactor;
m_sphereColor = color;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigPolyLinesData::showLines() const
{
return m_showLines;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigPolyLinesData::showSpheres() const
{
return m_showSpheres;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
int RigPolyLinesData::lineThickness() const
{
return m_lineThickness;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Color3f RigPolyLinesData::lineColor() const
{
return m_lineColor;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigPolyLinesData::closePolyline() const
{
return m_closePolyline;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
cvf::Color3f RigPolyLinesData::sphereColor() const
{
return m_sphereColor;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigPolyLinesData::sphereRadiusFactor() const
{
return m_sphereRadiusFactor;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double RigPolyLinesData::lockedZValue() const
{
return m_lockedZValue;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RigPolyLinesData::lockToZPlane() const
{
return m_lockToZPlane;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RigPolyLinesData::setZPlaneLock( bool lockToZ, double lockZValue )
{
m_lockToZPlane = lockToZ;
m_lockedZValue = lockZValue;
}

37
ApplicationLibCode/ReservoirDataModel/RigPolyLinesData.h
View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "cvfColor3.h"
#include "cvfObject.h" #include "cvfObject.h"
#include "cvfVector3.h" #include "cvfVector3.h"
@ -33,10 +34,40 @@ public:
RigPolyLinesData(); RigPolyLinesData();
~RigPolyLinesData() override; ~RigPolyLinesData() override;
const std::vector<std::vector<cvf::Vec3d>>& polyLines() const { return m_polylines; } const std::vector<std::vector<cvf::Vec3d>>& polyLines() const;
void setPolyLines( const std::vector<std::vector<cvf::Vec3d>>& polyLines ) { m_polylines = polyLines; }
void setPolyLine( const std::vector<cvf::Vec3d>& polyline ) { m_polylines = { polyline }; } void setPolyLines( const std::vector<std::vector<cvf::Vec3d>>& polyLines );
void setPolyLine( const std::vector<cvf::Vec3d>& polyline );
void addPolyLine( const std::vector<cvf::Vec3d>& polyline );
void setVisibility( bool showLines, bool showSpheres );
void setLineAppearance( int lineThickness, cvf::Color3f color, bool closePolyline );
void setSphereAppearance( double radiusFactor, cvf::Color3f color );
void setZPlaneLock( bool lockToZ, double lockZValue );
bool showLines() const;
bool showSpheres() const;
int lineThickness() const;
bool closePolyline() const;
cvf::Color3f lineColor() const;
cvf::Color3f sphereColor() const;
double sphereRadiusFactor() const;
double lockedZValue() const;
bool lockToZPlane() const;
private: private:
std::vector<std::vector<cvf::Vec3d>> m_polylines; std::vector<std::vector<cvf::Vec3d>> m_polylines;
bool m_showLines;
int m_lineThickness;
bool m_closePolyline;
bool m_showSpheres;
double m_sphereRadiusFactor;
bool m_lockToZPlane;
double m_lockedZValue;
cvf::Color3f m_lineColor;
cvf::Color3f m_sphereColor;
}; };