Merge pull request #1323 from danieldresser-ie/imathPrep

Remove Use of Imath Functionality that is Going To Be Deprecated

Author: johnhaddon

contrib/IECoreUSD/src/IECoreUSD/SceneCacheData.cpp

@@ -294,7 +294,7 @@ void SceneCacheData::loadSceneIntoCache( ConstSceneInterfacePtr scene )
 		spec.fields.push_back( FieldValuePair( SdfFieldKeys->TimeCodesPerSecond, m_fps ) );
 
 		// figure out start and end frame based on timeSamples in header
-		float minTime = Imath::limits<float>::max();
+		float minTime = std::numeric_limits<float>::max();
 		float maxTime = 0;
 		bool validTimeSampleRange = false;
 		if ( auto sampleTimesDir = m_sceneio->subdirectory( g_sampleTimes, IndexedIO::MissingBehaviour::NullIfMissing ) )

include/IECore/BoundedKDTree.inl

@@ -135,8 +135,8 @@ template<class BoundIterator>
 unsigned char BoundedKDTree<BoundIterator>::majorAxis( PermutationConstIterator permFirst, PermutationConstIterator permLast )
 {
 	BaseType min, max;
-	vecSetAll( min, Imath::limits<typename BaseType::BaseType>::max() );
-	vecSetAll( max, Imath::limits<typename BaseType::BaseType>::min() );
+	vecSetAll( min, std::numeric_limits<typename BaseType::BaseType>::max() );
+	vecSetAll( max, std::numeric_limits<typename BaseType::BaseType>::lowest() );
 
 	for( PermutationConstIterator it=permFirst; it!=permLast; it++ )
 	{

include/IECore/ByteOrder.h

@@ -35,8 +35,6 @@
 #ifndef IE_CORE_BYTEORDER_H
 #define IE_CORE_BYTEORDER_H
 
-#include "OpenEXR/ImfInt64.h"
-
 #include "boost/static_assert.hpp"
 
 #include <stdint.h>
@@ -138,7 +136,7 @@ inline float reverseBytes<float>( const float &x )
 }
 
 template<>
-inline Imf::Int64 reverseBytes<Imf::Int64>( const Imf::Int64 &x )
+inline uint64_t reverseBytes<uint64_t>( const uint64_t &x )
 {
 	return ((x & 255) << 56) |
 			(((x >> 8) & 255) << 48) |
@@ -153,13 +151,13 @@ inline Imf::Int64 reverseBytes<Imf::Int64>( const Imf::Int64 &x )
 template<>
 inline double reverseBytes<double>( const double &x )
 {
-	BOOST_STATIC_ASSERT( sizeof(Imf::Int64) == sizeof(double) );
+	BOOST_STATIC_ASSERT( sizeof(uint64_t) == sizeof(double) );
 	union {
-		Imf::Int64 i;
+		uint64_t i;
 		double d;
 	} xx;
 	xx.d = x;
-	xx.i = 	reverseBytes<Imf::Int64>(xx.i);
+	xx.i = 	reverseBytes<uint64_t>(xx.i);
 	return xx.d;
 }
 

include/IECore/EuclideanToSphericalTransform.inl

@@ -38,8 +38,6 @@
 #include "IECore/Math.h"
 #include "IECore/VectorTraits.h"
 
-#include "OpenEXR/ImathMath.h"
-
 #include <cassert>
 
 namespace IECore
@@ -57,14 +55,14 @@ T EuclideanToSphericalTransform<F, T>::transform( const F &f )
 	U len = f.length();
 	F v( f );
 	v.normalize();
-	U phi = Imath::Math< U >::atan2( v.y, v.x );
+	U phi = std::atan2( v.y, v.x );
 	if ( phi < 0 )
 	{
 		phi += static_cast< U >( 2*M_PI );
 	}
 	T res;
 	res[0] = phi;
-	res[1] = Imath::Math< U >::acos( v.z );
+	res[1] = std::acos( v.z );
 	if ( TypeTraits::IsVec3<T>::value )
 	{
 		res[2] = len;

include/IECore/HenyeyGreenstein.inl

@@ -37,8 +37,6 @@
 
 #include "IECore/Math.h"
 
-#include "OpenEXR/ImathMath.h"
-
 namespace IECore
 {
 
@@ -51,7 +49,7 @@ inline typename Vec::BaseType henyeyGreenstein( typename Vec::BaseType g, const
 template<typename T>
 inline T henyeyGreenstein( T g, T theta )
 {
-	return henyeyGreensteinCT( g, Imath::Math<T>::cos( theta ) );
+	return henyeyGreensteinCT( g, std::cos( theta ) );
 }
 
 template<typename T>
@@ -60,7 +58,7 @@ inline T henyeyGreensteinCT( T g, T cosTheta )
 	T g2 = g * g;
 	T top = T( 1 ) - g2;
 	T bottom = T( 1 ) + g2 - ( T( 2 ) * g * cosTheta );
-	bottom = T( 4 * M_PI ) * Imath::Math<T>::pow( bottom, T( 1.5 ) );
+	bottom = T( 4 * M_PI ) * std::pow( bottom, T( 1.5 ) );
 	return top / bottom;
 }
 

include/IECore/IndexedIO.inl

@@ -32,7 +32,6 @@
 //
 //////////////////////////////////////////////////////////////////////////
 
-#include "OpenEXR/ImfInt64.h"
 #include "OpenEXR/ImfXdr.h"
 
 #include "boost/static_assert.hpp"

include/IECore/InverseDistanceWeightedInterpolation.inl

@@ -34,8 +34,6 @@
 
 #include "IECore/VectorOps.h"
 
-#include "OpenEXR/ImathLimits.h"
-
 #include <algorithm>
 
 namespace IECore
@@ -83,7 +81,7 @@ typename InverseDistanceWeightedInterpolation<PointIterator, ValueIterator>::Val
 	if( neighbourCount )
 	{
 
-		PointBaseType distanceToFurthest = std::max<PointBaseType>( Imath::Math<PointBaseType>::sqrt( neighbours.rbegin()->distSquared ), 1.e-6 );
+		PointBaseType distanceToFurthest = std::max<PointBaseType>( std::sqrt( neighbours.rbegin()->distSquared ), 1.e-6 );
 
 		PointBaseType totalNeighbourWeight = 0.0;
 
@@ -93,12 +91,12 @@ typename InverseDistanceWeightedInterpolation<PointIterator, ValueIterator>::Val
 
 			const Value &neighbourValue = *(m_firstValue + (neighbourPointIt - m_firstPoint));
 
-			PointBaseType distanceToNeighbour = std::max<PointBaseType>( Imath::Math<PointBaseType>::sqrt( it->distSquared ), 1.e-6 );
+			PointBaseType distanceToNeighbour = std::max<PointBaseType>( std::sqrt( it->distSquared ), 1.e-6 );
 			assert( distanceToNeighbour <= distanceToFurthest );
 
 			// Franke & Nielson's (1980) improvement on Shephard's original weight function
 			PointBaseType neighbourWeight = ( distanceToFurthest - distanceToNeighbour ) / ( distanceToFurthest * distanceToNeighbour );
-			assert( neighbourWeight >= -Imath::limits<PointBaseType>::epsilon() );
+			assert( neighbourWeight >= -std::numeric_limits<PointBaseType>::epsilon() );
 
 			neighbourWeight = std::max<PointBaseType>(neighbourWeight * neighbourWeight, 1.e-6 );
 

include/IECore/KDTree.inl

@@ -35,8 +35,6 @@
 #include "IECore/BoxOps.h"
 #include "IECore/VectorOps.h"
 
-#include "OpenEXR/ImathLimits.h"
-
 #include <algorithm>
 
 namespace IECore
@@ -144,8 +142,8 @@ unsigned char KDTree<PointIterator>::majorAxis( PermutationConstIterator permFir
 {
 	Point min, max;
 	for( unsigned char i=0; i<VectorTraits<Point>::dimensions(); i++ ) {
-		min[i] = Imath::limits<BaseType>::max();
-		max[i] = Imath::limits<BaseType>::min();
+		min[i] = std::numeric_limits<BaseType>::max();
+		max[i] = std::numeric_limits<BaseType>::lowest();
 	}
 	for( PermutationConstIterator it=permFirst; it!=permLast; it++ )
 	{
@@ -206,7 +204,7 @@ void KDTree<PointIterator>::build( NodeIndex nodeIndex, PermutationIterator perm
 template<class PointIterator>
 PointIterator KDTree<PointIterator>::nearestNeighbour( const Point &p ) const
 {
-	BaseType maxDistSquared = Imath::limits<BaseType>::max();
+	BaseType maxDistSquared = std::numeric_limits<BaseType>::max();
 	PointIterator closestPoint = m_lastPoint;
 	nearestNeighbourWalk( rootIndex(), p, closestPoint, maxDistSquared );
 	return closestPoint;
@@ -244,7 +242,7 @@ unsigned int KDTree<PointIterator>::nearestNNeighbours( const Point &p, unsigned
 
 	if( numNeighbours )
 	{
-		BaseType maxDistSquared = Imath::limits<BaseType>::max();
+		BaseType maxDistSquared = std::numeric_limits<BaseType>::max();
 		nearestNNeighboursWalk( rootIndex(), p, numNeighbours, nearNeighbours, maxDistSquared );
 		std::sort_heap( nearNeighbours.begin(), nearNeighbours.end() );
 	}

include/IECore/LevenbergMarquardt.inl

@@ -37,8 +37,6 @@
 
 #include "IECore/Exception.h"
 
-#include "OpenEXR/ImathMath.h"
-
 #include <cassert>
 
 namespace IECore
@@ -70,13 +68,13 @@ struct DefaultLevenbergMarquardtTraits
 };
 
 template<typename T>
-T DefaultLevenbergMarquardtTraits<T>::g_machinePrecision( Imath::limits<T>::epsilon() );
+T DefaultLevenbergMarquardtTraits<T>::g_machinePrecision( std::numeric_limits<T>::epsilon() );
 
 template<typename T>
-T DefaultLevenbergMarquardtTraits<T>::g_sqrtMin( Imath::Math<T>::sqrt( Imath::limits<T>::smallest() ) );
+T DefaultLevenbergMarquardtTraits<T>::g_sqrtMin( std::sqrt( std::numeric_limits<T>::min() ) );
 
 template<typename T>
-T DefaultLevenbergMarquardtTraits<T>::g_sqrtMax( Imath::Math<T>::sqrt( Imath::limits<T>::max() ) );
+T DefaultLevenbergMarquardtTraits<T>::g_sqrtMax( std::sqrt( std::numeric_limits<T>::max() ) );
 
 template<typename T, typename ErrorFn, template<typename> class Traits>
 LevenbergMarquardt<T, ErrorFn, Traits>::LevenbergMarquardt()
@@ -168,7 +166,7 @@ typename LevenbergMarquardt<T, ErrorFn, Traits>::Status LevenbergMarquardt<T, Er
 
 	T delta = 0;
 	T xnorm = 0;
-	T eps = Imath::Math<T>::sqrt( std::max<T>( m_epsilon, Traits<T>::machinePrecision() ) );
+	T eps = std::sqrt( std::max<T>( m_epsilon, Traits<T>::machinePrecision() ) );
 
 	if (( m_n <= 0 ) || ( m_m < m_n ) || ( m_ftol < 0. )
 	                || ( m_xtol < 0. ) || ( m_gtol < 0. ) || ( m_stepBound <= 0. ) )
@@ -186,7 +184,7 @@ typename LevenbergMarquardt<T, ErrorFn, Traits>::Status LevenbergMarquardt<T, Er
 		for ( unsigned j = 0; j < m_n; j++ )
 		{
 			T temp = x[j];
-			step = eps * Imath::Math<T>::fabs( temp );
+			step = eps * std::fabs( temp );
 			if ( step == 0. )
 			{
 				step = eps;
@@ -269,7 +267,7 @@ typename LevenbergMarquardt<T, ErrorFn, Traits>::Status LevenbergMarquardt<T, Er
 					{
 						sum += m_fjac[j * m_m + i] * m_qtf[i] / fnorm;
 					}
-					gnorm = std::max<T>( gnorm, Imath::Math<T>::fabs( sum / wa2[m_ipvt[j]] ) );
+					gnorm = std::max<T>( gnorm, std::fabs( sum / wa2[m_ipvt[j]] ) );
 				}
 			}
 		}
@@ -333,7 +331,7 @@ typename LevenbergMarquardt<T, ErrorFn, Traits>::Status LevenbergMarquardt<T, Er
 			}
 			assert( m_wa3.size() == m_n );
 			temp1 = euclideanNorm( m_wa3.begin(), m_wa3.end() ) / fnorm;
-			temp2 = Imath::Math<T>::sqrt( par ) * pnorm / fnorm;
+			temp2 = std::sqrt( par ) * pnorm / fnorm;
 			prered = sqr( temp1 ) + 2 * sqr( temp2 );
 			dirder = -( sqr( temp1 ) + sqr( temp2 ) );
 
@@ -384,7 +382,7 @@ typename LevenbergMarquardt<T, ErrorFn, Traits>::Status LevenbergMarquardt<T, Er
 			}
 
 			/// tests for convergence
-			if ( Imath::Math<T>::fabs( actred ) <= m_ftol && prered <= m_ftol && 0.5 * ratio <= 1 )
+			if ( std::fabs( actred ) <= m_ftol && prered <= m_ftol && 0.5 * ratio <= 1 )
 			{
 				return Success;
 			}
@@ -399,7 +397,7 @@ typename LevenbergMarquardt<T, ErrorFn, Traits>::Status LevenbergMarquardt<T, Er
 			{
 				return  CallLimit;
 			}
-			if ( Imath::Math<T>::fabs( actred ) <= Traits<T>::machinePrecision() &&
+			if ( std::fabs( actred ) <= Traits<T>::machinePrecision() &&
 			                prered <= Traits<T>::machinePrecision() && 0.5 * ratio <= 1 )
 			{
 				return FailedFTol;
@@ -503,7 +501,7 @@ void LevenbergMarquardt<T, ErrorFn, Traits>::qrFactorize()
 			{
 				temp = m_fjac[m_m * k + j] / rdiag[k];
 				temp = std::max<T>( 0., 1 - temp * temp );
-				rdiag[k] *= Imath::Math<T>::sqrt( temp );
+				rdiag[k] *= std::sqrt( temp );
 				temp = rdiag[k] / m_wa3[k];
 				if ( T( 0.05 ) * sqr( temp ) <= Traits<T>::machinePrecision() )
 				{
@@ -607,7 +605,7 @@ T LevenbergMarquardt<T, ErrorFn, Traits>::computeLMParameter( std::vector<T> &x,
 	paru = gnorm / delta;
 	if ( paru == 0. )
 	{
-		paru = Imath::limits<T>::smallest() / std::min<T>( delta, 0.1 );
+		paru = std::numeric_limits<T>::min() / std::min<T>( delta, 0.1 );
 	}
 
 	par = std::max<T>( par, parl );
@@ -623,9 +621,9 @@ T LevenbergMarquardt<T, ErrorFn, Traits>::computeLMParameter( std::vector<T> &x,
 		/// evaluate the function at the current value of par.
 		if ( par == 0. )
 		{
-			par = std::max<T>( Imath::limits<T>::smallest(), 0.001 * paru );
+			par = std::max<T>( std::numeric_limits<T>::min(), 0.001 * paru );
 		}
-		temp = Imath::Math<T>::sqrt( par );
+		temp = std::sqrt( par );
 		for ( j = 0; j < m_n; j++ )
 		{
 			m_wa3[j] = temp * m_diag[j];
@@ -641,7 +639,7 @@ T LevenbergMarquardt<T, ErrorFn, Traits>::computeLMParameter( std::vector<T> &x,
 
 		/// if the function is small enough, accept the current value of par. Also test for the exceptional cases where parl
 		/// is zero or the number of iterations has reached 10.
-		if ( Imath::Math<T>::fabs( fp ) <= 0.1 * delta || ( parl == 0. && fp <= fp_old && fp_old < 0. ) || iter == 10 )
+		if ( std::fabs( fp ) <= 0.1 * delta || ( parl == 0. && fp <= fp_old && fp_old < 0. ) || iter == 10 )
 		{
 			break;
 		}
@@ -721,16 +719,16 @@ void LevenbergMarquardt<T, ErrorFn, Traits>::qrSolve( std::vector<T> &r, std::ve
 					unsigned kk = k + m_m * k;
 					T sinTheta, cosTheta;
 
-					if ( Imath::Math<T>::fabs( r[kk] ) < Imath::Math<T>::fabs( sdiag[k] ) )
+					if ( std::fabs( r[kk] ) < std::fabs( sdiag[k] ) )
 					{
 						T cotTheta = r[kk] / sdiag[k];
-						sinTheta = 0.5 / Imath::Math<T>::sqrt( 0.25 + 0.25 * sqr( cotTheta ) );
+						sinTheta = 0.5 / std::sqrt( 0.25 + 0.25 * sqr( cotTheta ) );
 						cosTheta = sinTheta * cotTheta;
 					}
 					else
 					{
 						T tanTheta = sdiag[k] / r[kk];
-						cosTheta = 0.5 / Imath::Math<T>::sqrt( 0.25 + 0.25 * sqr( tanTheta ) );
+						cosTheta = 0.5 / std::sqrt( 0.25 + 0.25 * sqr( tanTheta ) );
 						sinTheta = cosTheta * tanTheta;
 					}
 
@@ -802,7 +800,7 @@ T LevenbergMarquardt<T, ErrorFn, Traits>::euclideanNorm( typename std::vector<T>
 	/// sum squares
 	for ( typename std::vector<T>::const_iterator it = begin; it != end; ++it )
 	{
-		T xabs = Imath::Math<T>::fabs( *it );
+		T xabs = std::fabs( *it );
 		if ( xabs > Traits<T>::sqrtMin() && xabs < agiant )
 		{
 			///  sum for intermediate components.
@@ -845,22 +843,22 @@ T LevenbergMarquardt<T, ErrorFn, Traits>::euclideanNorm( typename std::vector<T>
 	/// calculation of norm.
 	if ( s1 != 0 )
 	{
-		return x1max * Imath::Math<T>::sqrt( s1 + ( s2 / x1max ) / x1max );
+		return x1max * std::sqrt( s1 + ( s2 / x1max ) / x1max );
 	}
 
 	if ( s2 != 0 )
 	{
 		if ( s2 >= x3max )
 		{
-			return Imath::Math<T>::sqrt( s2 * ( 1 + ( x3max / s2 ) * ( x3max * s3 ) ) );
+			return std::sqrt( s2 * ( 1 + ( x3max / s2 ) * ( x3max * s3 ) ) );
 		}
 		else
 		{
-			return Imath::Math<T>::sqrt( x3max * (( s2 / x3max ) + ( x3max * s3 ) ) );
+			return std::sqrt( x3max * (( s2 / x3max ) + ( x3max * s3 ) ) );
 		}
 	}
 
-	return x3max * Imath::Math<T>::sqrt( s3 );
+	return x3max * std::sqrt( s3 );
 }
 
 } // namespace IECore

include/IECore/NumericParameter.h

@@ -38,7 +38,7 @@
 #include "IECore/Parameter.h"
 #include "IECore/TypedData.h"
 
-#include "OpenEXR/ImathLimits.h"
+#include "OpenEXR/half.h"
 
 namespace IECore
 {
@@ -58,7 +58,7 @@ class IECORE_EXPORT NumericParameter : public Parameter
 		typedef std::vector<Preset> PresetsContainer;
 
 		NumericParameter( const std::string &name, const std::string &description, T defaultValue = T(),
-			T minValue = Imath::limits<T>::min(), T maxValue = Imath::limits<T>::max(),
+			T minValue = std::numeric_limits<T>::lowest(), T maxValue = std::numeric_limits<T>::max(),
 			const PresetsContainer &presets = PresetsContainer(), bool presetsOnly = false, ConstCompoundObjectPtr userData = nullptr );
 
 		NumericParameter( const std::string &name, const std::string &description, T defaultValue,