LutKey< float > Class Reference

#include <lut.h>

Classes
union	IFNumber

Public Member Functions
int	inputToKey (float i) const
bool	inrange (float i) const
float	keyToInput (int k) const
	LutKey (float min, float max, float precision)
float	maximum () const
float	minimum () const
int	size () const

Private Attributes
int	m_diff_p
float	m_max
float	m_min
float	m_precision
int	m_shift
int	m_tMax_n
int	m_tMax_p
int	m_tMin_n
int	m_tMin_p

Detailed Description

This provide an implementation for a LutKey for floating point input values.

Based on "High-speed Conversion of Floating Point Images to 8-bit" by Bill Spitzaks (https://spitzak.github.io/conversion/sketches_0265.pdf)

Definition at line 208 of file lut.h.

Constructor & Destructor Documentation

LutKey()

LutKey< float >::LutKey ( float min, float max, float precision )

inline

Definition at line 215 of file lut.h.

                                                  : m_min(min), m_max(max), m_precision(precision)
    {
      // Those values where computed using the test_linear and setting the shift and then using
      // the standard deviation.
      if (precision <= 0.000011809f) {
        m_min =  1;
        m_max = -1;
      }
      else if (precision <= 0.0000237291f) m_shift =  8;
      else if (precision <= 0.0000475024f) m_shift =  9;
      else if (precision <= 0.0000948575f) m_shift = 10;
      else if (precision <= 0.00019013f) m_shift = 11;
      else if (precision <= 0.000379523f) m_shift = 12;
      else if (precision <= 0.000758431f) m_shift = 13;
      else if (precision <= 0.00151891f) m_shift = 14;
      else if (precision <= 0.00303725f) m_shift = 15;
      else m_shift = 16;
 
      if ( 0.0 <= m_min && m_min <= precision)
        m_min = precision;
      if ( -precision <= m_max && m_max <= 0.0)
        m_max = -precision;
      
      IFNumber uf;
      
      if(m_min > 0 && m_max > 0)
      {
        uf.f = m_min;
        m_tMin_p = uf.i >> m_shift;
        uf.f = m_max;
        m_tMax_p = uf.i >> m_shift;
        m_tMin_n = m_tMax_p;
        m_tMax_n = m_tMax_p;
     } else if( m_max < 0)
      {
        uf.f = m_min;
        m_tMax_n = uf.i >> m_shift;
        uf.f = m_max;
        m_tMin_n = uf.i >> m_shift;
        m_tMin_p = m_tMax_n;
        m_tMax_p = m_tMax_n;
      } else { // m_min <0 && m_max > 0
        uf.f = precision;
        m_tMin_p = uf.i >> m_shift;
        uf.f = m_max;
        m_tMax_p = uf.i >> m_shift;
        uf.f = -precision;
        m_tMin_n = uf.i >> m_shift;
        uf.f = m_min;
        m_tMax_n = uf.i >> m_shift;
      }
      m_diff_p = m_tMax_p - m_tMin_p;
    }

Member Function Documentation

inputToKey()

int LutKey< float >::inputToKey ( float i ) const

inline

Definition at line 269 of file lut.h.

    {
      IFNumber uf;
      uf.f = i;
      int k = (uf.i >> m_shift);
      if(k <= m_tMax_p)
      {
        return k - m_tMin_p;
      } else {
        return k - m_tMin_n + m_diff_p;
      }
    }

inrange()

bool LutKey< float >::inrange ( float i ) const

inline

Definition at line 291 of file lut.h.

    {
       return i >= m_min && i <= m_max && (i < -m_precision || i > m_precision);
    }

keyToInput()

float LutKey< float >::keyToInput ( int k ) const

inline

Definition at line 281 of file lut.h.

    {
      IFNumber uf;
      if( k <= m_diff_p ) {
        uf.i = ((k + m_tMin_p) << m_shift);
      } else {
        uf.i = ((k + m_tMin_n - m_diff_p ) << m_shift);
      }
      return uf.f;
    }

maximum()

float LutKey< float >::maximum ( ) const

inline

Definition at line 299 of file lut.h.

    {
      return m_max;
    }

minimum()

float LutKey< float >::minimum ( ) const

inline

Definition at line 295 of file lut.h.

    {
      return m_min;
    }

size()

int LutKey< float >::size ( ) const

inline

Definition at line 303 of file lut.h.

    {
      return m_diff_p + m_tMax_n - m_tMin_p + 1;
    }

Member Data Documentation

m_diff_p

int LutKey< float >::m_diff_p

private

Definition at line 309 of file lut.h.

m_max

float LutKey< float >::m_max

private

Definition at line 308 of file lut.h.

m_min

float LutKey< float >::m_min

private

Definition at line 308 of file lut.h.

m_precision

float LutKey< float >::m_precision

private

Definition at line 308 of file lut.h.

m_shift

int LutKey< float >::m_shift

private

Definition at line 310 of file lut.h.

m_tMax_n

int LutKey< float >::m_tMax_n

private

Definition at line 309 of file lut.h.

m_tMax_p

int LutKey< float >::m_tMax_p

private

Definition at line 309 of file lut.h.

m_tMin_n

int LutKey< float >::m_tMin_n

private

Definition at line 309 of file lut.h.

m_tMin_p

int LutKey< float >::m_tMin_p

private

Definition at line 309 of file lut.h.

---

The documentation for this class was generated from the following file:

• libs/pigment/lut.h