otbRenderingImageFilter.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 __otbRenderingImageFilter_h
#define __otbRenderingImageFilter_h

#include "itkUnaryFunctorImageFilter.h"
#include "otbStandardRenderingFunction.h"
#include "otbImage.h"
#include "itkRGBAPixel.h"
#include "otbRenderingFunction.h"
#include "itkImageRegionConstIterator.h"

#include "itkMetaDataDictionary.h"

namespace otb
{
namespace Functor
{
template <class TPixel, class TRGBPixel>
class RenderingFunctor
{
public:
  typedef otb::Function::RenderingFunction<TPixel, TRGBPixel> RenderingFunctionType;
  typedef typename RenderingFunctionType::Pointer RenderingFunctionPointerType;
  typedef TPixel                                            PixelType;
  typedef typename itk::NumericTraits<PixelType>::ValueType ScalarPixelType;
  typedef itk::VariableLengthVector<ScalarPixelType>        VectorPixelType;
  typedef itk::RGBPixel<ScalarPixelType>                    RGBPixelType;
  typedef itk::RGBAPixel<ScalarPixelType>                   RGBAPixelType;

  typedef itk::MetaDataDictionary MetaDataDictionaryType;

  inline TRGBPixel operator ()(const PixelType& pixel) const
  {
    return m_Function->Evaluate(pixel);
  }

  RenderingFunctor() : m_Function()
  {
    // Default rendering function
//     m_Function = DefaultRenderingFunctionType::New();
  }

  virtual ~RenderingFunctor(){}

  void SetFunction(RenderingFunctionType * function)
  {
    m_Function = function;
  }

  RenderingFunctionType * GetFunction(void)
  {
    return m_Function;
  }

  void InitializeFunction(const MetaDataDictionaryType& metadatadictionary)
  {
    m_Function->Initialize(metadatadictionary);
  }

private:
  RenderingFunctionPointerType m_Function;
};
} // end namespace Functor

template <class TInputImage, class TOutputImage = Image<itk::RGBAPixel<unsigned char>, 2> >
class RenderingImageFilter
  : public itk::UnaryFunctorImageFilter<TInputImage, TOutputImage,
      Functor::RenderingFunctor
      <typename TInputImage::PixelType,
          typename TOutputImage::PixelType> >
{
public:
  typedef RenderingImageFilter Self;
  typedef itk::UnaryFunctorImageFilter
  <TInputImage, TOutputImage, Functor::RenderingFunctor
      <typename TInputImage::PixelType,
          typename TOutputImage::PixelType> >          Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(RenderingImageFilter, itk::UnaryFunctorImageFilter);

  typedef Functor::RenderingFunctor
  <typename TInputImage::PixelType,
      typename TOutputImage::PixelType>                         RenderingFunctorType;
  typedef typename RenderingFunctorType::RenderingFunctionType RenderingFunctionType;

  void SetRenderingFunction(RenderingFunctionType * function)
  {
    this->GetFunctor().SetFunction(function);
    this->Modified();
  }

  RenderingFunctionType * GetRenderingFunction(void)
  {
    if (this->GetFunctor().GetFunction() == NULL)
      {
      this->SetDefaultRenderingFunction();
      }
    return this->GetFunctor().GetFunction();
  }

  virtual void BeforeThreadedGenerateData(void)
  {
    // Call the superclass implementation
    Superclass::BeforeThreadedGenerateData();

    if (this->GetFunctor().GetFunction() == NULL)
      {
      otbMsgDevMacro(<< "RenderingFunction set to default");
      this->SetDefaultRenderingFunction();
      }

    // Initialize the rendering function
    this->GetFunctor().InitializeFunction(this->GetInput()->GetMetaDataDictionary());

    otbMsgDevMacro(<< "RenderingImageFilter::BeforeThreadedGenerateData():");
    otbMsgDevMacro(<< " - Output functor size "
                   << (this->GetFunctor().GetFunction())->GetPixelRepresentationSize());
    otbMsgDevMacro(<< "Rendering Funtion:" << this->GetFunctor().GetFunction());

    //Check if the rendering function channels are compatible with the image
    //might want to be more generic here one day.
//     unsigned int numberOfInputChannels = this->GetInput()->GetNumberOfComponentsPerPixel();
    itk::ImageRegionConstIterator<TInputImage> it(this->GetInput(), this->GetInput()->GetBufferedRegion());
    unsigned int                               numberOfInputChannels = VisualizationPixelTraits::PixelSize(it.Get());
    std::vector<unsigned int>                  channels = (this->GetFunctor().GetFunction())->GetChannelList();
    for (unsigned int i = 0; i < channels.size(); ++i)
      {
      if (channels[i] >= numberOfInputChannels)
        {
        itkExceptionMacro(<< "Channels specified as input (" << channels[i] << ") is not compatible "
                          << "with the size of the image: " << numberOfInputChannels);
        }
      }

  }

protected:
  RenderingImageFilter() {}
  virtual ~RenderingImageFilter() {}

  typedef Function::StandardRenderingFunction<
      typename TInputImage::PixelType,
      typename TOutputImage::PixelType> DefaultRenderingFunctionType;

  void SetDefaultRenderingFunction()
  {
    otbMsgDevMacro(<< "WARNING: using the default rendering function");

    this->GetFunctor().SetFunction(DefaultRenderingFunctionType::New());
  }

private:
  RenderingImageFilter(const Self&); //purposely not implemented
  void operator =(const Self&); //purposely not implemented
};
} // end namespace otb

#endif