otbImageWidgetTransferFunction.h

Go to the documentation of this file.

/*=========================================================================

  Program:   ORFEO Toolbox
  Language:  C++
  Date:      $Date$
  Version:   $Revision$


  Copyright (c) Centre National d'Etudes Spatiales. All rights reserved.
  See OTBCopyright.txt for details.


     This software is distributed WITHOUT ANY WARRANTY; without even
     the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
     PURPOSE.  See the above copyright notices for more information.

=========================================================================*/
#ifndef __otbImageWidgetTransferFunction_h
#define __otbImageWidgetTransferFunction_h

#include "vcl_deprecated_header.h"

#include "itkProcessObject.h"
#include "itkMacro.h"
#include "otbMath.h"

namespace otb
{
template <class TPixel>
class ITK_EXPORT ImageWidgetTransferFunction
  : public itk::Object
{
public:
  typedef ImageWidgetTransferFunction   Self;
  typedef itk::Object                   Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;

  itkTypeMacro(ImageWidgetTransferFunction, Object);

  typedef TPixel PixelType;

  itkSetMacro(LowerBound, PixelType);
  itkGetMacro(LowerBound, PixelType);
  itkSetMacro(UpperBound, PixelType);
  itkGetMacro(UpperBound, PixelType);

  virtual unsigned char Map(PixelType)
  {
    return 0;
  }

protected:
  ImageWidgetTransferFunction()
    {
    m_LowerBound = 0;
    m_UpperBound = 255;
    }
  virtual ~ImageWidgetTransferFunction() {}
  virtual void PrintSelf(std::ostream& os, itk::Indent indent) const
  {
    Superclass::PrintSelf(os, indent);
    os << indent << "Lower bound: " << m_LowerBound << std::endl;
    os << indent << "Upper bound: " << m_UpperBound << std::endl;
  }

private:
  ImageWidgetTransferFunction(const Self &); //purposely not implemented
  void operator =(const Self&); //purposely not implemented

  PixelType m_LowerBound;
  PixelType m_UpperBound;
};

template <class TPixel>
class ITK_EXPORT ImageWidgetAffineTransferFunction
  : public ImageWidgetTransferFunction<TPixel>
{
public:
  typedef ImageWidgetAffineTransferFunction   Self;
  typedef ImageWidgetTransferFunction<TPixel> Superclass;
  typedef itk::SmartPointer<Self>             Pointer;
  typedef itk::SmartPointer<const Self>       ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(ImageWidgetAffineTransferFunction, ImageWidgetTransferFunction);

  typedef TPixel PixelType;

  virtual unsigned char Map(PixelType value)
  {
    if (value < this->GetLowerBound())
      {
      return 0;
      }
    else if (value > this->GetUpperBound())
      {
      return 255;
      }
    else
      {
      return static_cast<unsigned char>(vcl_floor(255. *
                                                  (value -
                                                   this->GetLowerBound()) /
                                                  (this->GetUpperBound() - this->GetLowerBound()) + 0.5));
      }

  }
protected:
  ImageWidgetAffineTransferFunction() {}
  virtual ~ImageWidgetAffineTransferFunction() {}
private:
  ImageWidgetAffineTransferFunction(const Self &); //purposely not implemented
  void operator =(const Self&); //purposely not implemented
};

template <class TPixel>
class ITK_EXPORT ImageWidgetSquareRootTransferFunction
  : public ImageWidgetTransferFunction<TPixel>
{
public:
  typedef ImageWidgetSquareRootTransferFunction Self;
  typedef ImageWidgetTransferFunction<TPixel>   Superclass;
  typedef itk::SmartPointer<Self>               Pointer;
  typedef itk::SmartPointer<const Self>         ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(ImageWidgetSquareRootTransferFunction, ImageWidgetTransferFunction);

  typedef TPixel PixelType;

  virtual unsigned char Map(PixelType value)
  {
    if (value < this->GetLowerBound())
      {
      return 0;
      }
    else if (value > this->GetUpperBound())
      {
      return 255;
      }
    else
      {
      double b = vcl_sqrt(static_cast<double>(this->GetLowerBound()));
      double a = 255. / (vcl_sqrt(static_cast<double>(this->GetUpperBound())) - b);
      return static_cast<unsigned char>(vcl_floor(a * (vcl_sqrt(static_cast<double>(value)) - b) + 0.5));
      }

  }
protected:
  ImageWidgetSquareRootTransferFunction() {}
  virtual ~ImageWidgetSquareRootTransferFunction() {}
private:
  ImageWidgetSquareRootTransferFunction(const Self &); //purposely not implemented
  void operator =(const Self&); //purposely not implemented
};

template <class TPixel>
class ITK_EXPORT ImageWidgetLogTransferFunction
  : public ImageWidgetTransferFunction<TPixel>
{
public:
  typedef ImageWidgetLogTransferFunction      Self;
  typedef ImageWidgetTransferFunction<TPixel> Superclass;
  typedef itk::SmartPointer<Self>             Pointer;
  typedef itk::SmartPointer<const Self>       ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(ImageWidgetLogTransferFunction, ImageWidgetTransferFunction);

  typedef TPixel PixelType;

  virtual unsigned char Map(PixelType value)
  {
    if (value < this->GetLowerBound())
      {
      return 0;
      }
    else if (value > this->GetUpperBound())
      {
      return 255;
      }
    else
      {
      double b = vcl_log(1. + static_cast<double>(this->GetLowerBound()));
      double a = 255. / (vcl_log(1. + static_cast<double>(this->GetUpperBound())) - b);
      return static_cast<unsigned char>(vcl_floor(a * (vcl_log(1. + static_cast<double>(value)) - b) + 0.5));
      }

  }
protected:
  ImageWidgetLogTransferFunction() {}
  virtual ~ImageWidgetLogTransferFunction() {}
private:
  ImageWidgetLogTransferFunction(const Self &); //purposely not implemented
  void operator =(const Self&); //purposely not implemented
};

template <class TPixel>
class ITK_EXPORT ImageWidgetSquareTransferFunction
  : public ImageWidgetTransferFunction<TPixel>
{
public:
  typedef ImageWidgetSquareTransferFunction   Self;
  typedef ImageWidgetTransferFunction<TPixel> Superclass;
  typedef itk::SmartPointer<Self>             Pointer;
  typedef itk::SmartPointer<const Self>       ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(ImageWidgetSquareTransferFunction, ImageWidgetTransferFunction);

  typedef TPixel PixelType;

  virtual unsigned char Map(PixelType value)
  {
    if (value < this->GetLowerBound())
      {
      return 0;
      }
    else if (value > this->GetUpperBound())
      {
      return 255;
      }
    else
      {
      double b = vcl_pow(static_cast<double>(this->GetLowerBound()), 2);
      double a = 255. / (vcl_pow(static_cast<double>(this->GetUpperBound()), 2) - b);
      return static_cast<unsigned char>(vcl_floor(a * (vcl_pow(static_cast<double>(value), 2) - b) + 0.5));
      }

  }
protected:
  ImageWidgetSquareTransferFunction() {}
  virtual ~ImageWidgetSquareTransferFunction() {}
private:
  ImageWidgetSquareTransferFunction(const Self &); //purposely not implemented
  void operator =(const Self&); //purposely not implemented
};
} // End namespace otb

#endif