mlScaleShiftData.h

Go to the documentation of this file.

/*************************************************************************************
**
** Copyright 2007, MeVis Medical Solutions AG
**
** The user may use this file in accordance with the license agreement provided with
** the Software or, alternatively, in accordance with the terms contained in a
** written agreement between the user and MeVis Medical Solutions AG.
**
** For further information use the contact form at https://www.mevislab.de/contact
**
**************************************************************************************/
 
#ifndef ML_SCALE_SHIFT_DATA_H
#define ML_SCALE_SHIFT_DATA_H
 
 
// ML-includes
#include "mlInitSystemML.h"
#include <mlTypeDefTraits.h>
#include <mlDataTypes.h>
 
#include <iostream>
#include <utility>
#include <string>
 
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)
  {
  }
 
  inline TScaleShiftData(const TScaleShiftData<DT> &ssd)
  : _scale(ssd._scale),
  _shift(ssd._shift),
  _reorderMode(ssd._reorderMode)
  {
  }
 
  inline TScaleShiftData(DT scale, DT shift) : _scale(scale), _shift(shift) , _reorderMode(NoReordering)
  {
  }
 
  inline TScaleShiftData(DT fromMin, DT fromMax, DT toMin, DT toMax)
    :_reorderMode(NoReordering)
  {
    setFromMinMaxToMinMax(fromMin, fromMax, toMin, toMax);
  }
 
 
  //------------------------------------------------------
  //------------------------------------------------------
 
  inline TScaleShiftData &operator=(const TScaleShiftData<DT> &ssd)
  {
    _scale = ssd._scale;
    _shift = ssd._shift;
    _reorderMode = ssd._reorderMode;
 
    return *this;
  }
 
 
  //------------------------------------------------------
  //------------------------------------------------------
 
  inline bool operator==(const TScaleShiftData<DT> &ssd) const
  {
    return MLValuesAreEqualWOM(_scale, ssd._scale) &&
    MLValuesAreEqualWOM(_shift, ssd._shift) && (_reorderMode == ssd._reorderMode);
  }
 
  inline bool operator!=(const TScaleShiftData<DT> &ssd) const
  {
    return !(*this == ssd);
  }
 
 
  //------------------------------------------------------
  //------------------------------------------------------
 
  inline void setScaleOffset(DT scale, DT shift)
  {
    _scale=scale;
    _shift=shift;
  }
 
  inline void setFromMinMaxToMinMax(DT fromMin, DT fromMax, DT toMin, DT toMax)
  {
    if (toMin   > toMax)   { std::swap(toMin,   toMax);   }
    if (fromMin > fromMax) { std::swap(fromMin, fromMax); }
    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 borders.
      // 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].
      // This way, the only value from that interval is projected to the minimum value of the
      // target interval.
      _scale = static_cast<DT>(1);
      _shift = toMin - fromMin;
    }
  }
 
  inline void setFromMinMaxToMinMax(MLDataType fromType, DT fromMin, DT fromMax,
                                    MLDataType toType,   DT toMin, DT toMax)
  {
    bool fromTypeIsInt = MLIsIntType(fromType)!=0;
    bool toTypeIsInt   = MLIsIntType(toType)!=0;
    if (toMin   > toMax)   { std::swap(toMin,   toMax);   }
    if (fromMin > fromMax) { std::swap(fromMin, fromMax); }
    DT srcWidth  = fromMax-fromMin;
    DT destWidth = toMax-toMin;
    if (srcWidth > 0){
 
      if (toTypeIsInt) {
        if (!fromTypeIsInt) {
          // Float -> Int:
          // adding 0.99 to the integer range, since that is almost the same
          // as adding 1.0 and avoids having to clamp the result to the integer max value.
          destWidth += 0.99;
        } else if (srcWidth > destWidth) {
          // Int -> Int and srcWidth > destWidth
          // max+1 is be used for both ranges, which is the same as shifting for
          // power-of-two differences in range
          srcWidth += 1;
          destWidth += 1;
        }
        else {
          // Int -> Int and srcWidth <= destWidth
          // leave as is, so that fromMax is mapped to toMax
        }
      } else {
        // Int -> Float:
        // use max integer 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.0)
 
        // Float -> Float:
        // keep max as given
      }
      _scale = destWidth / 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].
      // This way, the only value from that interval is projected to the minimum value of the
      // target interval.
      _scale = static_cast<DT>(1);
      _shift = toMin - fromMin;
    }
  }
 
  inline void 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