OilfieldToolsNet/ResInsight
4
0
Fork 0
mirror of https://github.com/OPM/ResInsight.git synced 2025-02-03 12:10:57 -06:00
Code Issues Packages Projects Releases Wiki Activity

Legend config: Removed obsolete min value threshold

Browse Source 
p4#: 20626
This commit is contained in:
Jacob Støren 2013-02-26 12:45:41 +01:00
parent 39ac12f2f3
commit ab02afabcf
10 changed files with 148 additions and 49 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ApplicationCode/ProjectDataModel/RimLegendConfig.cpp
View File

@ -405,13 +405,13 @@ void RimLegendConfig::recreateLegend()
//--------------------------------------------------------------------------------------------------
double RimLegendConfig::adjust(double domainValue, double precision)
{
double decadeValue = cvf::Math::abs(domainValue);
double threshold = 1e-6;
if (decadeValue < threshold)
double absDomainValue = cvf::Math::abs(domainValue);
if (absDomainValue == 0.0)
{
return 0.0;
}
double logDecValue = log10(decadeValue);
double logDecValue = log10(absDomainValue);
logDecValue = cvf::Math::ceil(logDecValue);
double factor = pow(10.0, precision - logDecValue);

2
ApplicationCode/ProjectDataModel/RimLegendConfig.h
View File

@ -92,7 +92,7 @@ private:
caf::PdmPointer<RimReservoirView> m_reservoirView;
cvf::ref<cvf::ScalarMapperDiscreteLinear> m_linDiscreteScalarMapper;
cvf::ref<cvf::ScalarMapperDiscreteLinear> m_logDiscreteScalarMapper;
cvf::ref<cvf::ScalarMapperDiscreteLog> m_logDiscreteScalarMapper;
cvf::ref<cvf::ScalarMapperContinuousLog> m_logSmoothScalarMapper;
cvf::ref<cvf::ScalarMapperContinuousLinear> m_linSmoothScalarMapper;
cvf::ref<cvf::ScalarMapper> m_currentScalarMapper;

53
VisualizationModules/LibRender/cvfScalarMapperContinuousLog.cpp
View File

@ -22,6 +22,7 @@
#include "cvfMath.h"
#include "cvfTextureImage.h"
#include <cmath>
#include <limits>
namespace cvf {
@ -34,6 +35,9 @@ namespace cvf {
/// Configured by specifying a number of level colors and a min/max range.
//==================================================================================================
ScalarMapperContinuousLog::ScalarMapperContinuousLog()
: m_hasNegativeRange(false),
m_logRange(0.0),
m_logRangeMin(0.0)
{
}
@ -43,17 +47,16 @@ ScalarMapperContinuousLog::ScalarMapperContinuousLog()
//--------------------------------------------------------------------------------------------------
double ScalarMapperContinuousLog::normalizedValue(double scalarValue) const
{
double logRangeMax = log10(m_rangeMax);
double logRangeMin = log10(m_rangeMin);
double logRange = logRangeMax - logRangeMin;
if (m_hasNegativeRange) scalarValue = -1.0*scalarValue;
double logValue;
if (scalarValue <= 0) logValue = logRangeMin;
if (scalarValue <= 0) logValue = std::numeric_limits<double>::min_exponent10;
else logValue = log10(scalarValue);
if (logRange != 0)
if (m_logRange != 0)
{
return cvf::Math::clamp((logValue - logRangeMin)/logRange, 0.0, 1.0);
return cvf::Math::clamp((logValue - m_logRangeMin)/m_logRange, 0.0, 1.0);
}
else
{
@ -66,13 +69,37 @@ double ScalarMapperContinuousLog::normalizedValue(double scalarValue) const
//--------------------------------------------------------------------------------------------------
double ScalarMapperContinuousLog::domainValue(double normalizedPosition) const
{
double logRangeMax = log10(m_rangeMax);
double logRangeMin = log10(m_rangeMin);
double logRange = logRangeMax - logRangeMin;
double logValue = normalizedPosition*m_logRange + m_logRangeMin;
double domainVal = pow(10, logValue);
double logValue = normalizedPosition*logRange + logRangeMin;
return pow(10, logValue);
if (m_hasNegativeRange)
domainVal *= -1.0;
return domainVal;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void ScalarMapperContinuousLog::rangeUpdated()
{
m_hasNegativeRange = false;
double transformedRangeMax = m_rangeMax;
double transformedRangeMin = m_rangeMin;
if ( m_rangeMax <= 0 && m_rangeMin <= 0)
{
m_hasNegativeRange = true;
transformedRangeMax = -1.0*transformedRangeMax;
transformedRangeMin = -1.0*transformedRangeMin;
}
double logRangeMax = (transformedRangeMax > 0) ? log10(transformedRangeMax): std::numeric_limits<double>::min_exponent10;
m_logRangeMin = (transformedRangeMin > 0) ? log10(transformedRangeMin): std::numeric_limits<double>::min_exponent10;
m_logRange = logRangeMax - m_logRangeMin;
}
} // namespace cvf

9
VisualizationModules/LibRender/cvfScalarMapperContinuousLog.h
View File

@ -38,6 +38,15 @@ public:
virtual double normalizedValue( double domainValue ) const;
virtual double domainValue( double normalizedPosition ) const;
//
protected:
virtual void rangeUpdated();
private:
double m_logRange;
double m_logRangeMin;
bool m_hasNegativeRange;
};
}

12
VisualizationModules/LibRender/cvfScalarMapperDiscreteLinear.cpp
View File

@ -41,7 +41,7 @@ ScalarMapperDiscreteLinear::ScalarMapperDiscreteLinear()
//--------------------------------------------------------------------------------------------------
Vec2f ScalarMapperDiscreteLinear::mapToTextureCoord(double scalarValue) const
{
double discVal = discretize(scalarValue);
double discVal = discretize(scalarValue, m_sortedLevels);
return ScalarMapperRangeBased::mapToTextureCoord(discVal);
}
@ -50,20 +50,20 @@ Vec2f ScalarMapperDiscreteLinear::mapToTextureCoord(double scalarValue) const
//--------------------------------------------------------------------------------------------------
Color3ub ScalarMapperDiscreteLinear::mapToColor(double scalarValue) const
{
double discVal = discretize(scalarValue);
double discVal = discretize(scalarValue, m_sortedLevels);
return ScalarMapperRangeBased::mapToColor(discVal);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double ScalarMapperDiscreteLinear::discretize(double scalarValue) const
double ScalarMapperDiscreteLinear::discretize(double scalarValue, const std::set<double>& sortedLevels)
{
std::set<double>::iterator it;
it = m_sortedLevels.upper_bound(scalarValue);
if (it == m_sortedLevels.begin()) return (*it);
if (it == m_sortedLevels.end()) return (*m_sortedLevels.rbegin());
it = sortedLevels.upper_bound(scalarValue);
if (it == sortedLevels.begin()) return (*it);
if (it == sortedLevels.end()) return (*sortedLevels.rbegin());
double upperValue = *it;
it--;
double lowerValue = *it;

5
VisualizationModules/LibRender/cvfScalarMapperDiscreteLinear.h
View File

@ -23,6 +23,7 @@
namespace cvf {
class ScalarMapperDiscreteLog;
//==================================================================================================
//
// Maps scalar values to texture coordinates/colors
@ -42,8 +43,8 @@ public:
virtual double domainValue( double normalizedPosition ) const;
private:
double discretize(double scalarValue) const;
static double discretize(double scalarValue, const std::set<double>& sortedLevels);
friend ScalarMapperDiscreteLog;
};
}

74
VisualizationModules/LibRender/cvfScalarMapperDiscreteLog.cpp
View File

@ -18,6 +18,7 @@
//##################################################################################################
#include "cvfScalarMapperDiscreteLog.h"
#include "cvfScalarMapperDiscreteLinear.h"
#include <cmath>
#include "cvfMath.h"
@ -31,42 +32,87 @@ namespace cvf {
/// Maps scalar values to texture coordinates/colors using discrete logarithmic mapping
//==================================================================================================
ScalarMapperDiscreteLog::ScalarMapperDiscreteLog()
{
m_decadeLevelCount = 2;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double ScalarMapperDiscreteLog::normalizedValue(double domainScalarValue) const
Vec2f ScalarMapperDiscreteLog::mapToTextureCoord(double scalarValue) const
{
double logRangeMax = log10(m_rangeMax);
double logRangeMin = log10(m_rangeMin);
double logRange = logRangeMax - logRangeMin;
double discVal = ScalarMapperDiscreteLinear::discretize(scalarValue, m_sortedLevels);
return ScalarMapperRangeBased::mapToTextureCoord(discVal);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
Color3ub ScalarMapperDiscreteLog::mapToColor(double scalarValue) const
{
double discVal = ScalarMapperDiscreteLinear::discretize(scalarValue, m_sortedLevels);
return ScalarMapperRangeBased::mapToColor(discVal);
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double ScalarMapperDiscreteLog::normalizedValue(double scalarValue) const
{
if (m_hasNegativeRange) scalarValue = -1.0*scalarValue;
double logValue;
if (domainScalarValue <= 0) logValue = logRangeMin;
else logValue = log10(domainScalarValue);
if (scalarValue <= 0) logValue = std::numeric_limits<double>::min_exponent10;
else logValue = log10(scalarValue);
if (logRange != 0)
if (m_logRange != 0)
{
return cvf::Math::clamp((logValue - logRangeMin)/logRange, 0.0, 1.0);
return cvf::Math::clamp((logValue - m_logRangeMin)/m_logRange, 0.0, 1.0);
}
else
{
return 0;
}
}
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
double ScalarMapperDiscreteLog::domainValue(double normalizedPosition) const
{
double logRangeMax = log10(m_rangeMax);
double logRangeMin = log10(m_rangeMin);
double logRange = logRangeMax - logRangeMin;
double logValue = normalizedPosition*m_logRange + m_logRangeMin;
double domainVal = pow(10, logValue);
double logValue = normalizedPosition*logRange + logRangeMin;
if (m_hasNegativeRange)
domainVal *= -1.0;
return pow(10, logValue);
return domainVal;
}
//--------------------------------------------------------------------------------------------------
///
//--------------------------------------------------------------------------------------------------
void ScalarMapperDiscreteLog::rangeUpdated()
{
m_hasNegativeRange = false;
double transformedRangeMax = m_rangeMax;
double transformedRangeMin = m_rangeMin;
if ( m_rangeMax <= 0 && m_rangeMin <= 0)
{
m_hasNegativeRange = true;
transformedRangeMax = -1.0*transformedRangeMax;
transformedRangeMin = -1.0*transformedRangeMin;
}
double logRangeMax = (transformedRangeMax > 0) ? log10(transformedRangeMax): std::numeric_limits<double>::min_exponent10;
m_logRangeMin = (transformedRangeMin > 0) ? log10(transformedRangeMin): std::numeric_limits<double>::min_exponent10;
m_logRange = logRangeMax - m_logRangeMin;
}
} // namespace cvf

18
VisualizationModules/LibRender/cvfScalarMapperDiscreteLog.h
View File

@ -19,7 +19,7 @@
#pragma once
#include "cvfScalarMapperDiscreteLinear.h"
#include "cvfScalarMapperRangeBased.h"
namespace cvf {
@ -29,14 +29,24 @@ namespace cvf {
//
//==================================================================================================
class ScalarMapperDiscreteLog : public ScalarMapperDiscreteLinear
class ScalarMapperDiscreteLog : public ScalarMapperRangeBased
{
public:
ScalarMapperDiscreteLog() {m_decadeLevelCount = 2; }
ScalarMapperDiscreteLog();
// Implementing the Scalarmapper interface
virtual Vec2f mapToTextureCoord(double scalarValue) const;
virtual Color3ub mapToColor(double scalarValue) const;
virtual double normalizedValue( double domainValue ) const;
virtual double domainValue( double normalizedPosition ) const;
//
protected:
virtual void rangeUpdated();
private:
double m_logRange;
double m_logRangeMin;
bool m_hasNegativeRange;
};
}

14
VisualizationModules/LibRender/cvfScalarMapperRangeBased.cpp
View File

@ -56,6 +56,7 @@ void ScalarMapperRangeBased::setRange(double min, double max)
m_rangeMin = min;
m_rangeMax = max;
updateSortedLevels();
rangeUpdated();
}
@ -160,7 +161,8 @@ bool ScalarMapperRangeBased::updateTexture(TextureImage* image) const
// Then calculate a stepsize that is humanly understandable
// basically rounded to whole or half of the decade in question
// decadeParts - The number of steps wanted within a decade
// decadeValue - The value used to describe the current decade to round off within
static double adjust(double domainValue, double decadeValue, unsigned int decadeParts = 2)
{
if (decadeValue == 0) return domainValue; // Conceptually correct
@ -200,7 +202,7 @@ void ScalarMapperRangeBased::majorTickValues( std::vector<double>* domainValues)
if (m_userDefinedLevelValues.empty())
{
domainValues->push_back(m_rangeMin);
domainValues->push_back(domainValue(0));
if (m_levelCount > 1)
{
double stepSizeNorm = 1.0/m_levelCount;
@ -213,17 +215,19 @@ void ScalarMapperRangeBased::majorTickValues( std::vector<double>* domainValues)
{
double prevNormPos = normalizedValue(prevDomValue);
double newNormPos = prevNormPos + stepSizeNorm;
double domValue = domainValue(newNormPos);
double domStep = domValue - prevDomValue;
double newLevel;
newLevel = prevDomValue + adjust(domStep, domStep, m_decadeLevelCount);
//newLevel = prevDomValue + adjust(domStep, domStep, m_decadeLevelCount);
newLevel = domValue;
// Must handle first level specially to get a good absolute staring point
// For log domain this must be done all the time, and it does not hamper linear, so.. do it always
newLevel = adjust(newLevel, domStep, m_decadeLevelCount);
if (newLevel > m_rangeMax - domStep*0.4) break;
if (normalizedValue(newLevel) > 1.0 - stepSizeNorm*0.4) break;
domainValues->push_back(newLevel);
prevDomValue = newLevel;
@ -237,7 +241,7 @@ void ScalarMapperRangeBased::majorTickValues( std::vector<double>* domainValues)
}
}
}
domainValues->push_back(m_rangeMax);
domainValues->push_back(domainValue(1));
}
else
{

2
VisualizationModules/LibRender/cvfScalarMapperRangeBased.h
View File

@ -48,6 +48,8 @@ public:
virtual void majorTickValues(std::vector<double>* domainValues ) const;
protected:
virtual void rangeUpdated() {}; //< Called when the range is changed. Subclasses can reimplment to recalculate cached values
double m_rangeMin;
double m_rangeMax;
unsigned int m_decadeLevelCount;