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

#6033 Surface Properties : Add legend and adjust update functions

Browse Source
This commit is contained in:
Magne Sjaastad 2020-06-11 13:31:36 +02:00
parent c92b3e3024
commit 8cc167568c
10 changed files with 314 additions and 101 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

119
ApplicationCode/ModelVisualization/Surfaces/RivSurfacePartMgr.cpp
View File

@ -24,13 +24,16 @@
#include "ProjectDataModel/RimCase.h"
#include "RigSurface.h"
#include "Rim3dView.h"
#include "RimRegularLegendConfig.h"
#include "RimSurface.h"
#include "RimSurfaceInView.h"
#include "RimSurfaceResultDefinition.h"
#include "RivIntersectionResultsColoringTools.h"
#include "RivMeshLinesSourceInfo.h"
#include "RivPartPriority.h"
#include "RivReservoirSurfaceIntersectionSourceInfo.h"
#include "RivScalarMapperUtils.h"
#include "RivSurfaceIntersectionGeometryGenerator.h"
#include "cafEffectGenerator.h"
@ -40,6 +43,8 @@
#include "cvfPart.h"
#include "cvfPrimitiveSetIndexedUInt.h"
#include <limits>
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -48,10 +53,11 @@ RivSurfacePartMgr::RivSurfacePartMgr( RimSurfaceInView* surface )
{
CVF_ASSERT( surface );
m_intersectionFacesTextureCoords = new cvf::Vec2fArray;
cvf::ref<RivIntersectionHexGridInterface> hexGrid = m_surfaceInView->createHexGridInterface();
m_intersectionGenerator = new RivSurfaceIntersectionGeometryGenerator( m_surfaceInView, hexGrid.p() );
m_intersectionFacesTextureCoords = new cvf::Vec2fArray;
m_nativeTrianglesTextureCoords = new cvf::Vec2fArray;
}
//--------------------------------------------------------------------------------------------------
@ -67,7 +73,7 @@ void RivSurfacePartMgr::appendNativeGeometryPartsToModel( cvf::ModelBasicList* m
if ( m_nativeTrianglesPart.notNull() )
{
m_nativeTrianglesPart->setTransform( scaleTransform );
this->applySingleColor();
this->updateNativeSurfaceColors();
model->addPart( m_nativeTrianglesPart.p() );
@ -102,34 +108,37 @@ void RivSurfacePartMgr::updateCellResultColor( size_t timeStepIndex )
//--------------------------------------------------------------------------------------------------
void RivSurfacePartMgr::appendIntersectionGeometryPartsToModel( cvf::ModelBasicList* model, cvf::Transform* scaleTransform )
{
if ( m_intersectionFaces.isNull() )
if ( !m_surfaceInView->surfaceResultDefinition()->isChecked() )
{
generatePartGeometry();
}
if ( m_intersectionFaces.isNull() )
{
generatePartGeometry();
}
if ( m_intersectionFaces.notNull() )
{
m_intersectionFaces->setTransform( scaleTransform );
model->addPart( m_intersectionFaces.p() );
}
if ( m_intersectionFaces.notNull() )
{
m_intersectionFaces->setTransform( scaleTransform );
model->addPart( m_intersectionFaces.p() );
}
// Mesh Lines
// Mesh Lines
if ( m_intersectionGridLines.isNull() )
{
generatePartGeometry();
}
if ( m_intersectionGridLines.isNull() )
{
generatePartGeometry();
}
if ( m_intersectionGridLines.notNull() )
{
m_intersectionGridLines->setTransform( scaleTransform );
model->addPart( m_intersectionGridLines.p() );
}
if ( m_intersectionGridLines.notNull() )
{
m_intersectionGridLines->setTransform( scaleTransform );
model->addPart( m_intersectionGridLines.p() );
}
if ( m_intersectionFaultGridLines.notNull() )
{
m_intersectionFaultGridLines->setTransform( scaleTransform );
model->addPart( m_intersectionFaultGridLines.p() );
if ( m_intersectionFaultGridLines.notNull() )
{
m_intersectionFaultGridLines->setTransform( scaleTransform );
model->addPart( m_intersectionFaultGridLines.p() );
}
}
appendNativeGeometryPartsToModel( model, scaleTransform );
@ -138,25 +147,67 @@ void RivSurfacePartMgr::appendIntersectionGeometryPartsToModel( cvf::ModelBasicL
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RivSurfacePartMgr::applySingleColor()
void RivSurfacePartMgr::updateNativeSurfaceColors()
{
if ( m_surfaceInView->surfaceResultDefinition()->isChecked() )
{
caf::SurfaceEffectGenerator surfaceGen( cvf::Color4f( m_surfaceInView->surface()->color() ), caf::PO_1 );
cvf::ref<cvf::Effect> eff = surfaceGen.generateCachedEffect();
if ( m_usedSurfaceData.isNull() ) generateNativePartGeometry();
auto mapper = m_surfaceInView->surfaceResultDefinition()->legendConfig()->scalarMapper();
{
QString propertyName = m_surfaceInView->surfaceResultDefinition()->propertyName();
auto values = m_usedSurfaceData->propertyValues( propertyName );
const std::vector<cvf::Vec3d>& vertices = m_usedSurfaceData->vertices();
m_nativeTrianglesTextureCoords->resize( vertices.size() );
m_nativeTrianglesTextureCoords->setAll( cvf::Vec2f( 0.5f, 1.0f ) );
for ( size_t i = 0; i < values.size(); i++ )
{
const double val = values[i];
if ( val < std::numeric_limits<double>::infinity() && val == val )
{
m_nativeTrianglesTextureCoords->set( i, mapper->mapToTextureCoord( val ) );
}
}
float effectiveOpacityLevel = 1.0;
bool disableLighting = false;
Rim3dView* view = nullptr;
m_surfaceInView->firstAncestorOfType( view );
if ( view )
{
disableLighting = view->isLightingDisabled();
}
RivScalarMapperUtils::applyTextureResultsToPart( m_nativeTrianglesPart.p(),
m_nativeTrianglesTextureCoords.p(),
mapper,
effectiveOpacityLevel,
caf::FC_NONE,
disableLighting );
}
}
else
{
caf::SurfaceEffectGenerator surfaceGenBehind( cvf::Color4f( m_surfaceInView->surface()->color() ),
caf::PO_POS_LARGE );
cvf::ref<cvf::Effect> effBehind = surfaceGenBehind.generateCachedEffect();
cvf::ref<cvf::Effect> effBehind = surfaceGenBehind.generateCachedEffect();
if ( m_nativeTrianglesPart.notNull() )
{
m_nativeTrianglesPart->setEffect( effBehind.p() );
}
}
if ( m_intersectionFaces.notNull() )
{
m_intersectionFaces->setEffect( eff.p() );
}
if ( m_intersectionFaces.notNull() )
{
caf::SurfaceEffectGenerator surfaceGen( cvf::Color4f( m_surfaceInView->surface()->color() ), caf::PO_1 );
cvf::ref<cvf::Effect> eff = surfaceGen.generateCachedEffect();
m_intersectionFaces->setEffect( eff.p() );
}
// Update mesh colors as well, in case of change
@ -267,7 +318,7 @@ void RivSurfacePartMgr::generatePartGeometry()
}
}
applySingleColor();
updateNativeSurfaceColors();
}
//--------------------------------------------------------------------------------------------------

3
ApplicationCode/ModelVisualization/Surfaces/RivSurfacePartMgr.h
View File

@ -41,7 +41,7 @@ class RivSurfacePartMgr : public cvf::Object
public:
explicit RivSurfacePartMgr( RimSurfaceInView* surface );
void applySingleColor();
void updateNativeSurfaceColors();
void updateCellResultColor( size_t timeStepIndex );
void appendIntersectionGeometryPartsToModel( cvf::ModelBasicList* model, cvf::Transform* scaleTransform );
@ -65,4 +65,5 @@ private:
cvf::ref<cvf::Part> m_intersectionFaultGridLines;
cvf::ref<cvf::Vec2fArray> m_intersectionFacesTextureCoords;
cvf::ref<cvf::Vec2fArray> m_nativeTrianglesTextureCoords;
};

8
ApplicationCode/ProjectDataModel/RimEclipseView.cpp
View File

@ -586,6 +586,7 @@ void RimEclipseView::onCreateDisplayModel()
m_surfaceVizModel->removeAllParts();
if ( m_surfaceCollection )
{
m_surfaceCollection->clearGeometry();
m_surfaceCollection->appendPartsToModel( m_surfaceVizModel.p(), m_reservoirGridPartManager->scaleTransform() );
nativeOrOverrideViewer()->addStaticModelOnce( m_surfaceVizModel.p(), isUsingOverrideViewer() );
}
@ -670,6 +671,8 @@ void RimEclipseView::onUpdateDisplayModelForCurrentTimeStep()
{
clearReservoirCellVisibilities();
// m_surfaceCollection->clearGeometry();
m_propertyFilterCollection()->updateFromCurrentTimeStep();
onUpdateLegends(); // To make sure the scalar mappers are set up correctly
@ -1435,6 +1438,11 @@ void RimEclipseView::onUpdateLegends()
}
}
}
if ( m_surfaceCollection && m_surfaceCollection->isChecked() )
{
m_surfaceCollection->updateLegendRangesTextAndVisibility( nativeOrOverrideViewer(), isUsingOverrideViewer() );
}
}
//--------------------------------------------------------------------------------------------------

77
ApplicationCode/ProjectDataModel/Surfaces/RimSurfaceInView.cpp
View File

@ -18,13 +18,18 @@
#include "RimSurfaceInView.h"
#include "RigFemPartCollection.h"
#include "RigSurface.h"
#include "RimEclipseView.h"
#include "RimGeoMechView.h"
#include "RimGridView.h"
#include "RimRegularLegendConfig.h"
#include "RimSurface.h"
#include "RimSurfaceResultDefinition.h"
#include "RigFemPartCollection.h"
#include "RimEclipseView.h"
#include "RimGeoMechView.h"
#include "RiuViewer.h"
#include "RivHexGridIntersectionTools.h"
#include "RivSurfacePartMgr.h"
@ -51,8 +56,9 @@ RimSurfaceInView::RimSurfaceInView()
CAF_PDM_InitFieldNoDefault( &m_resultDefinition, "ResultDefinition", "Result Definition", "", "", "" );
m_resultDefinition.uiCapability()->setUiHidden( true );
m_resultDefinition.uiCapability()->setUiTreeChildrenHidden( false );
m_resultDefinition.uiCapability()->setUiTreeChildrenHidden( true );
m_resultDefinition = new RimSurfaceResultDefinition;
m_resultDefinition->setCheckState( false );
m_resultDefinition->setSurfaceInView( this );
}
@ -87,6 +93,36 @@ RimSurface* RimSurfaceInView::surface() const
void RimSurfaceInView::setSurface( RimSurface* surf )
{
m_surface = surf;
if ( surface()->surfaceData() && surface()->surfaceData()->propertyNames().empty() )
{
m_resultDefinition.uiCapability()->setUiTreeChildrenHidden( true );
m_resultDefinition->setCheckState( false );
}
else
{
m_resultDefinition.uiCapability()->setUiTreeChildrenHidden( false );
m_resultDefinition->setCheckState( true );
m_resultDefinition->assignDefaultProperty();
m_resultDefinition->updateMinMaxValues();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
bool RimSurfaceInView::isNativeSurfaceResultsActive() const
{
return m_resultDefinition->isChecked();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
RimSurfaceResultDefinition* RimSurfaceInView::surfaceResultDefinition()
{
return m_resultDefinition();
}
//--------------------------------------------------------------------------------------------------
@ -115,6 +151,39 @@ RivSurfacePartMgr* RimSurfaceInView::surfacePartMgr()
return m_surfacePartMgr.p();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSurfaceInView::loadDataAndUpdate()
{
if ( surface() )
{
surface()->loadDataIfRequired();
m_resultDefinition->updateMinMaxValues();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSurfaceInView::updateLegendRangesTextAndVisibility( RiuViewer* nativeOrOverrideViewer, bool isUsingOverrideViewer )
{
if ( m_resultDefinition->legendConfig() )
{
RimRegularLegendConfig* legendConfig = m_resultDefinition->legendConfig();
legendConfig->setTitle(
QString( "Surface : \n%1\n%2" ).arg( this->name() ).arg( m_resultDefinition->propertyName() ) );
if ( this->isActive() && m_resultDefinition->isChecked() && legendConfig->showLegend() )
{
nativeOrOverrideViewer->addColorLegendToBottomLeftCorner( legendConfig->titledOverlayFrame(),
isUsingOverrideViewer );
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------

8
ApplicationCode/ProjectDataModel/Surfaces/RimSurfaceInView.h
View File

@ -31,6 +31,7 @@ class RimSurface;
class RimSurfaceResultDefinition;
class RivSurfacePartMgr;
class RivIntersectionHexGridInterface;
class RiuViewer;
//--------------------------------------------------------------------------------------------------
///
@ -47,11 +48,18 @@ public:
RimSurface* surface() const;
void setSurface( RimSurface* surf );
bool isNativeSurfaceResultsActive() const;
RimSurfaceResultDefinition* surfaceResultDefinition();
double depthOffset() const;
void clearGeometry();
RivSurfacePartMgr* surfacePartMgr();
void loadDataAndUpdate();
void updateLegendRangesTextAndVisibility( RiuViewer* nativeOrOverrideViewer, bool isUsingOverrideViewer );
protected:
void defineEditorAttribute( const caf::PdmFieldHandle* field,
QString uiConfigName,

79
ApplicationCode/ProjectDataModel/Surfaces/RimSurfaceInViewCollection.cpp
View File

@ -39,11 +39,10 @@ RimSurfaceInViewCollection::RimSurfaceInViewCollection()
{
CAF_PDM_InitObject( "Surfaces", ":/ReservoirSurfaces16x16.png", "", "" );
CAF_PDM_InitField( &m_isActive, "isActive", true, "Active", "", "", "" );
m_isActive.uiCapability()->setUiHidden( true );
CAF_PDM_InitFieldNoDefault( &m_surfacesInView, "SurfacesInViewField", "SurfacesInViewField", "", "", "" );
m_surfacesInView.uiCapability()->setUiTreeHidden( true );
setName( "Surfaces" );
}
//--------------------------------------------------------------------------------------------------
@ -101,25 +100,35 @@ void RimSurfaceInViewCollection::loadData()
{
for ( RimSurfaceInView* surf : m_surfacesInView )
{
if ( surf->isActive() && surf->surface() )
if ( surf->isActive() )
{
surf->surface()->loadDataIfRequired();
surf->loadDataAndUpdate();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSurfaceInViewCollection::clearGeometry()
{
for ( RimSurfaceInView* surf : m_surfacesInView )
{
surf->clearGeometry();
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSurfaceInViewCollection::appendPartsToModel( cvf::ModelBasicList* model, cvf::Transform* scaleTransform )
{
if ( !m_isActive() ) return;
if ( !isChecked() ) return;
for ( RimSurfaceInView* surf : m_surfacesInView )
{
if ( surf->isActive() )
{
// surf->surfacePartMgr()->appendNativeGeometryPartsToModel( model, scaleTransform );
surf->surfacePartMgr()->appendIntersectionGeometryPartsToModel( model, scaleTransform );
}
}
@ -134,7 +143,7 @@ void RimSurfaceInViewCollection::fieldChangedByUi( const caf::PdmFieldHandle* ch
const QVariant& oldValue,
const QVariant& newValue )
{
if ( changedField == &m_isActive )
if ( changedField == &m_isChecked )
{
RimGridView* ownerView;
this->firstAncestorOrThisOfTypeAsserted( ownerView );
@ -158,36 +167,40 @@ bool RimSurfaceInViewCollection::hasSurfaceInViewForSurface( const RimSurface* s
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
caf::PdmFieldHandle* RimSurfaceInViewCollection::objectToggleField()
{
return &m_isActive;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSurfaceInViewCollection::updateCellResultColor( bool hasGeneralCellResult, size_t timeStepIndex )
{
if ( !this->m_isActive() ) return;
if ( !this->isChecked() ) return;
for ( RimSurfaceInView* surf : m_surfacesInView )
{
if ( surf->isActive() )
{
bool showResults = surf->activeSeparateResultDefinition()
? surf->activeSeparateResultDefinition()->hasResult()
: hasGeneralCellResult;
bool useNativeSurfaceColors = false;
if ( showResults )
if ( surf->isNativeSurfaceResultsActive() ) useNativeSurfaceColors = true;
if ( !useNativeSurfaceColors )
{
surf->surfacePartMgr()->updateCellResultColor( timeStepIndex );
bool showResults = surf->activeSeparateResultDefinition()
? surf->activeSeparateResultDefinition()->hasResult()
: hasGeneralCellResult;
if ( showResults )
{
surf->surfacePartMgr()->updateCellResultColor( timeStepIndex );
}
else
{
useNativeSurfaceColors = true;
}
}
else
if ( useNativeSurfaceColors )
{
surf->surfacePartMgr()->applySingleColor();
surf->surfacePartMgr()->updateNativeSurfaceColors();
}
}
}
@ -198,13 +211,13 @@ void RimSurfaceInViewCollection::updateCellResultColor( bool hasGeneralCellResul
//--------------------------------------------------------------------------------------------------
void RimSurfaceInViewCollection::applySingleColorEffect()
{
if ( !this->m_isActive() ) return;
if ( !this->isChecked() ) return;
for ( RimSurfaceInView* surf : m_surfacesInView )
{
if ( surf->isActive() )
{
surf->surfacePartMgr()->applySingleColor();
surf->surfacePartMgr()->updateNativeSurfaceColors();
}
}
}
@ -214,7 +227,7 @@ void RimSurfaceInViewCollection::applySingleColorEffect()
//--------------------------------------------------------------------------------------------------
bool RimSurfaceInViewCollection::hasAnyActiveSeparateResults()
{
if ( !this->m_isActive() ) return false;
if ( !this->isChecked() ) return false;
for ( RimSurfaceInView* surf : m_surfacesInView )
{
@ -227,3 +240,15 @@ bool RimSurfaceInViewCollection::hasAnyActiveSeparateResults()
return false;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSurfaceInViewCollection::updateLegendRangesTextAndVisibility( RiuViewer* nativeOrOverrideViewer,
bool isUsingOverrideViewer )
{
for ( RimSurfaceInView* surf : m_surfacesInView )
{
surf->updateLegendRangesTextAndVisibility( nativeOrOverrideViewer, isUsingOverrideViewer );
}
}

11
ApplicationCode/ProjectDataModel/Surfaces/RimSurfaceInViewCollection.h
View File

@ -17,6 +17,8 @@
/////////////////////////////////////////////////////////////////////////////////
#pragma once
#include "RimCheckableNamedObject.h"
#include "cafPdmChildArrayField.h"
#include "cafPdmField.h"
#include "cafPdmObject.h"
@ -30,8 +32,9 @@ class ScalarMapper;
class RimSurfaceInView;
class RimSurface;
class RiuViewer;
class RimSurfaceInViewCollection : public caf::PdmObject
class RimSurfaceInViewCollection : public RimCheckableNamedObject
{
CAF_PDM_HEADER_INIT;
@ -41,19 +44,19 @@ public:
void updateFromSurfaceCollection();
void loadData();
void clearGeometry();
void appendPartsToModel( cvf::ModelBasicList* surfaceVizModel, cvf::Transform* scaleTransform );
void updateCellResultColor( bool hasGeneralCellResult, size_t timeStepIndex );
void applySingleColorEffect();
bool hasAnyActiveSeparateResults();
void updateLegendRangesTextAndVisibility( RiuViewer* nativeOrOverrideViewer, bool isUsingOverrideViewer );
private:
caf::PdmFieldHandle* objectToggleField() override;
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;
bool hasSurfaceInViewForSurface( const RimSurface* surf ) const;
caf::PdmField<bool> m_isActive;
caf::PdmChildArrayField<RimSurfaceInView*> m_surfacesInView;
};

102
ApplicationCode/ProjectDataModel/Surfaces/RimSurfaceResultDefinition.cpp
View File

@ -23,6 +23,7 @@
#include "RigStatisticsMath.h"
#include "RigSurface.h"
#include "Rim3dView.h"
#include "RimRegularLegendConfig.h"
#include "RimSurface.h"
#include "RimSurfaceInView.h"
@ -43,7 +44,7 @@ RimSurfaceResultDefinition::RimSurfaceResultDefinition()
m_legendConfig.uiCapability()->setUiTreeChildrenHidden( false );
m_legendConfig = new RimRegularLegendConfig;
setName( "Result Definition" );
setName( "Result Property" );
CAF_PDM_InitFieldNoDefault( &m_surfaceInView, "SurfaceInView", "Surface In View", "", "", "" );
m_surfaceInView.uiCapability()->setUiHidden( true );
@ -63,6 +64,16 @@ RimSurfaceResultDefinition::~RimSurfaceResultDefinition()
void RimSurfaceResultDefinition::setSurfaceInView( RimSurfaceInView* surfaceInView )
{
m_surfaceInView = surfaceInView;
assignDefaultProperty();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
QString RimSurfaceResultDefinition::propertyName() const
{
return m_propertyName;
}
//--------------------------------------------------------------------------------------------------
@ -73,6 +84,57 @@ RimRegularLegendConfig* RimSurfaceResultDefinition::legendConfig()
return m_legendConfig();
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSurfaceResultDefinition::updateMinMaxValues()
{
RigSurface* surfData = surfaceData();
if ( surfData )
{
double globalMin = 0.0;
double globalMax = 0.0;
double globalPosClosestToZero = 0.0;
double globalNegClosestToZero = 0.0;
{
MinMaxAccumulator minMaxAccumulator;
PosNegAccumulator posNegAccumulator;
auto values = surfData->propertyValues( m_propertyName );
minMaxAccumulator.addData( values );
posNegAccumulator.addData( values );
globalPosClosestToZero = posNegAccumulator.pos;
globalNegClosestToZero = posNegAccumulator.neg;
globalMin = minMaxAccumulator.min;
globalMax = minMaxAccumulator.max;
}
m_legendConfig->setClosestToZeroValues( globalPosClosestToZero,
globalNegClosestToZero,
globalPosClosestToZero,
globalNegClosestToZero );
m_legendConfig->setAutomaticRanges( globalMin, globalMax, globalMin, globalMax );
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void RimSurfaceResultDefinition::assignDefaultProperty()
{
if ( m_surfaceInView->surface() && m_surfaceInView->surface()->surfaceData() )
{
auto propNames = m_surfaceInView->surface()->surfaceData()->propertyNames();
if ( !propNames.empty() )
{
m_propertyName = m_surfaceInView->surface()->surfaceData()->propertyNames().front();
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
@ -80,37 +142,17 @@ void RimSurfaceResultDefinition::fieldChangedByUi( const caf::PdmFieldHandle* ch
const QVariant& oldValue,
const QVariant& newValue )
{
if ( changedField == &m_propertyName && m_propertyName != RiaDefines::undefinedResultName() )
if ( changedField == &m_propertyName )
{
RigSurface* surfData = surfaceData();
if ( surfData )
{
double globalMin = 0.0;
double globalMax = 0.0;
double globalPosClosestToZero = 0.0;
double globalNegClosestToZero = 0.0;
updateMinMaxValues();
}
{
MinMaxAccumulator minMaxAccumulator;
PosNegAccumulator posNegAccumulator;
Rim3dView* view = nullptr;
this->firstAncestorOrThisOfType( view );
auto values = surfData->propertyValues( m_propertyName );
minMaxAccumulator.addData( values );
posNegAccumulator.addData( values );
globalPosClosestToZero = posNegAccumulator.pos;
globalNegClosestToZero = posNegAccumulator.neg;
globalMin = minMaxAccumulator.min;
globalMax = minMaxAccumulator.max;
}
m_legendConfig->setClosestToZeroValues( globalPosClosestToZero,
globalNegClosestToZero,
globalPosClosestToZero,
globalNegClosestToZero );
m_legendConfig->setAutomaticRanges( globalMin, globalMax, globalMin, globalMax );
}
if ( view )
{
view->scheduleCreateDisplayModelAndRedraw();
}
}
@ -120,6 +162,8 @@ void RimSurfaceResultDefinition::fieldChangedByUi( const caf::PdmFieldHandle* ch
void RimSurfaceResultDefinition::defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering )
{
uiOrdering.add( &m_propertyName );
uiOrdering.skipRemainingFields();
}
//--------------------------------------------------------------------------------------------------

6
ApplicationCode/ProjectDataModel/Surfaces/RimSurfaceResultDefinition.h
View File

@ -41,10 +41,14 @@ public:
RimSurfaceResultDefinition();
~RimSurfaceResultDefinition() override;
void setSurfaceInView( RimSurfaceInView* surfaceInView );
void setSurfaceInView( RimSurfaceInView* surfaceInView );
QString propertyName() const;
RimRegularLegendConfig* legendConfig();
void updateMinMaxValues();
void assignDefaultProperty();
private:
void fieldChangedByUi( const caf::PdmFieldHandle* changedField, const QVariant& oldValue, const QVariant& newValue ) override;
virtual void defineUiOrdering( QString uiConfigName, caf::PdmUiOrdering& uiOrdering ) override;

2
Fwk/AppFwk/cafVizExtensions/cafHexGridIntersectionTools/cafHexGridIntersectionTools.cpp
View File

@ -217,7 +217,7 @@ bool HexGridIntersectionTools::planeTriangleIntersection(const cvf::Plane& plane
CVF_ASSERT(false);
}
CVF_TIGHT_ASSERT(ok1 && ok2);
//CVF_TIGHT_ASSERT(ok1 && ok2);
return true;
}