MeVis/Foundation/Sources/ML/include/mlScaleShiftData.h

Go to the documentation of this file.

// **InsertLicense** code
//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
#ifndef __mlScaleShiftData_H
#define __mlScaleShiftData_H

// ML-includes
#ifndef __mlInitSystemML_H
#include "mlInitSystemML.h"
#endif

#include "mlDataTypes.h"

ML_START_NAMESPACE

//-------------------------------------------------------------------------
//-------------------------------------------------------------------------
template <typename DT>
class TScaleShiftData
{
  
public:
  enum ReorderMode {
    NoReordering = 0,                   
    ReorderColorPlanesToInterleaved = 1 
  };
  
  //------------------------------------------------------

  //------------------------------------------------------
  
  inline TScaleShiftData() 
  : _scale(static_cast<DT>(1)),
    _shift(static_cast<DT>(0)),
    _reorderMode(NoReordering)
  {
    ML_TRACE_IN_TIME_CRITICAL( "ScaleShiftData( )" );
  }
  
  inline TScaleShiftData(const TScaleShiftData<DT> &ssd) 
  : _scale(ssd._scale), 
  _shift(ssd._shift),
  _reorderMode(ssd._reorderMode)
  {
    ML_TRACE_IN_TIME_CRITICAL( "ScaleShiftData( )" );
  }
  
  inline TScaleShiftData(DT scale, DT shift) : _scale(scale), _shift(shift) , _reorderMode(NoReordering)
  {
    ML_TRACE_IN_TIME_CRITICAL( "ScaleShiftData( )" );
  }
  
  inline TScaleShiftData(DT fromMin, DT fromMax, DT toMin, DT toMax)
    :_reorderMode(NoReordering)
  {
    ML_TRACE_IN_TIME_CRITICAL( "ScaleShiftData( )" );
    
    setFromMinMaxToMinMax(fromMin, fromMax, toMin, toMax); 
  }
  
  
  //------------------------------------------------------

  //------------------------------------------------------
  
  inline TScaleShiftData &operator=(const TScaleShiftData<DT> &ssd)
  {
    ML_TRACE_IN_TIME_CRITICAL( "ScaleShiftData::operator=" );
    
    _scale = ssd._scale;  
    _shift = ssd._shift; 
    _reorderMode = ssd._reorderMode; 
    
    return *this; 
  }
  
  
  //------------------------------------------------------

  //------------------------------------------------------
  
  inline bool operator==(const TScaleShiftData<DT> &ssd) const
  {
    ML_TRACE_IN_TIME_CRITICAL( "ScaleShiftData::operator==" );
    
    return MLValuesAreEqualWOM(_scale, ssd._scale) && 
    MLValuesAreEqualWOM(_shift, ssd._shift) && (_reorderMode == ssd._reorderMode); 
  }
  
  inline bool operator!=(const TScaleShiftData<DT> &ssd) const
  {
    ML_TRACE_IN_TIME_CRITICAL( "ScaleShiftData::operator!=" );
    
    return !(*this == ssd);
  }
  
  
  //------------------------------------------------------

  //------------------------------------------------------
  
  inline void setScaleOffset(DT scale, DT shift)
  {
    ML_TRACE_IN_TIME_CRITICAL( "ScaleShiftData::setScaleOffset( )" );
    
    _scale=scale; 
    _shift=shift; 
  }
  
  inline void setFromMinMaxToMinMax(DT fromMin, DT fromMax, DT toMin, DT toMax)
  {
    ML_TRACE_IN( "ScaleShiftData::setFromMinMaxToMinMax( )" );
    ML_TRY
    {
      if (toMin   > toMax)  { DT help; help = toMin;   toMin   = toMax;   toMax   = help; }
      if (fromMin > fromMax){ DT help; help = fromMin; fromMin = fromMax; fromMax = help; }
      DT srcWidth = fromMax-fromMin;
      if (srcWidth > 0){
        _scale = (toMax - toMin) / srcWidth;
        _shift = -fromMin * _scale + toMin;
      }
      else{
        // Our source interval has (nearly) identical left and right interval border.
        // Since this case often occurs if images have identical minimum and maximum
        // values we handle it so that the source interval is assumed as [fromMin, fromMin+1].
        // So the only value from that interval is projected to the minimum value of the
        // target interval.
        _scale = static_cast<DT>(1);
        _shift = toMin - fromMin;
      }
    }
    ML_CATCH_RETHROW;
  }
  
  inline void setFromMinMaxToMinMax(MLDataType fromType, DT fromMin, DT fromMax,
                                    MLDataType toType,   DT toMin, DT toMax)
  {
    ML_TRACE_IN( "ScaleShiftData::setFromMinMaxToMinMax( )" );
    ML_TRY
    {
      bool fromTypeIsInt = MLIsIntType(fromType)!=0;
      bool toTypeIsInt   = MLIsIntType(toType)!=0;
      if (toMin   > toMax)  { DT help; help = toMin;   toMin   = toMax;   toMax   = help; }
      if (fromMin > fromMax){ DT help; help = fromMin; fromMin = fromMax; fromMax = help; }
      DT srcWidth = fromMax-fromMin;
      if (srcWidth > 0){
        if (!fromTypeIsInt && toTypeIsInt) {
          // Float -> Int:
          // adding 0.99 to the integer range, since that is almost the case
          // like adding 1. and avoids having to clamp the result to the int max value.
          toMax += 0.99;
        } else if (fromTypeIsInt && toTypeIsInt) {
          // Int -> Int:
          // max+1 is be used for both ranges (which is the same as shifting for
          // power-of-two differences in range)
          fromMax += 1;
          toMax += 1;
          srcWidth += 1;
        } else {
          // Int -> Float:
          // use max int value, and not max+1, so that the max integer value will get the
          // max float value (like in OpenGL, where the max integer is mapped to 1.)

          // Float -> Float:
          // keep max as given
        }
        _scale = (toMax - toMin) / srcWidth;
        _shift = -fromMin * _scale + toMin;
      }
      else{
        // Our source interval has (nearly) identical left and right interval border.
        // Since this case often occurs if images have identical minimum and maximum
        // values we handle it so that the source interval is assumed as [fromMin, fromMin+1].
        // So the only value from that interval is projected to the minimum value of the
        // target interval.
        _scale = static_cast<DT>(1);
        _shift = toMin - fromMin;
      }

    }
    ML_CATCH_RETHROW;
  }

  inline void unset()
  {
    ML_TRACE_IN_TIME_CRITICAL( "ScaleShiftData::unset( )" );
    
    _scale = static_cast<DT>(1); 
    _shift = static_cast<DT>(0);
    _reorderMode = NoReordering;
  }
  
  
  //------------------------------------------------------

  //------------------------------------------------------
  
  inline DT getScale() const { return _scale; }
  
  inline DT getShift() const { return _shift; }

  inline ReorderMode getReorderMode() const { return _reorderMode; }

  inline void setReorderMode(ReorderMode mode) { _reorderMode = mode; }

private:
  


  DT _scale;
  
  DT _shift;

  ReorderMode _reorderMode;

};

typedef TScaleShiftData<MLdouble> ScaleShiftData;


ML_END_NAMESPACE

//-----------------------------------------------------------------------------------
//   Stream output for std::ostream
//-----------------------------------------------------------------------------------
namespace std {
  
  inline ostream& operator<<(ostream& s, const ML_NAMESPACE::ScaleShiftData &ssd)
  {
    return s << "Scale=" << ssd.getScale() << ",  Shift=" << ssd.getShift();
  }
  
}


#endif //of __mlScaleShiftData_H