otbImageLayerGenerator.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 __otbImageLayerGenerator_h
#define __otbImageLayerGenerator_h

#include "itkObject.h"
#include "itkObjectFactory.h"
#include "otbStreamingShrinkImageFilter.h"

namespace otb
{
template <class TImageLayer>
class ImageLayerGenerator
  : public itk::Object
{
public:
  typedef ImageLayerGenerator           Self;
  typedef itk::Object                   Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(ImageLayerGenerator, Object);

  typedef TImageLayer                      ImageLayerType;
  typedef typename ImageLayerType::Pointer ImageLayerPointerType;

  typedef typename ImageLayerType::ImageType ImageType;
  typedef typename ImageType::Pointer        ImagePointerType;

  typedef otb::StreamingShrinkImageFilter
  <ImageType, ImageType>                        ResampleFilterType;
  typedef typename ResampleFilterType::Pointer ResampleFilterPointerType;

  typedef typename ImageLayerType::RenderingFunctionType RenderingFunctionType;
//   typedef typename ImageLayerType::DefaultRenderingFunctionType DefaultRenderingFunctionType;
  typedef typename RenderingFunctionType::Pointer RenderingFunctionPointerType;

  typedef typename ImageLayerType::OutputPixelType      OutputPixelType;
  typedef typename ImageLayerType::BlendingFunctionType BlendingFunctionType;
  typedef typename BlendingFunctionType::Pointer        BlendingFunctionPointerType;

  typedef typename ImageLayerType::ScalarType      ScalarType;
  typedef typename ImageLayerType::VectorPixelType VectorPixelType;
  typedef typename ImageLayerType::RGBPixelType    RGBPixelType;
  typedef typename ImageLayerType::RGBAPixelType   RGBAPixelType;

  itkGetObjectMacro(Layer, ImageLayerType);

  virtual void GenerateLayer();

  virtual unsigned int GetOptimalSubSamplingRate();

  itkSetObjectMacro(Image, ImageType);
  itkGetObjectMacro(Image, ImageType);

  itkSetObjectMacro(Quicklook, ImageType);
  itkGetObjectMacro(Quicklook, ImageType);

  itkSetMacro(SubsamplingRate, unsigned int);
  itkGetMacro(SubsamplingRate, unsigned int);

  itkSetMacro(GenerateQuicklook, bool);
  itkBooleanMacro(GenerateQuicklook);

  itkSetMacro(ScreenRatio, double);
  itkGetMacro(ScreenRatio, double);

//   itkSetObjectMacro(RenderingFunction, RenderingFunctionType);
//   itkGetObjectMacro(RenderingFunction, RenderingFunctionType);
  virtual void SetRenderingFunction(RenderingFunctionType* func)
  {
    if (this->m_Layer.IsNull())
      {
      itkExceptionMacro(<< "Layer is not set");
      }
    if (this->m_Layer->GetRenderingFunction() != func)
      {
      this->m_Layer->SetRenderingFunction(func);
      this->Modified();
      }
  }

  virtual RenderingFunctionType * GetRenderingFunction()
  {
    if (this->m_Layer.IsNull())
      {
      itkExceptionMacro(<< "Layer is not set");
      }
    return this->m_Layer->GetRenderingFunction();
  }

//   itkSetObjectMacro(BlendingFunction, BlendingFunctionType);
//   itkGetObjectMacro(BlendingFunction, BlendingFunctionType);
  virtual void SetBlendingFunction(BlendingFunctionType* func)
  {
    if (this->m_Layer.IsNull())
      {
      itkExceptionMacro(<< "Layer is not set");
      }
    if (this->m_Layer->GetBlendingFunction() != func)
      {
      this->m_Layer->SetBlendingFunction(func);
      this->Modified();
      }
  }

  virtual BlendingFunctionType * GetBlendingFunction()
  {
    if (this->m_Layer.IsNull())
      {
      itkExceptionMacro(<< "Layer is not set");
      }
    return this->m_Layer->GetBlendingFunction();
  }

  itk::ProcessObject* GetProgressSource() const
  {
    return m_Resampler->GetStreamer();
  }

protected:
  ImageLayerGenerator();
  virtual ~ImageLayerGenerator();
  void PrintSelf(std::ostream& os, itk::Indent indent) const;

  virtual void GenerateLayerInformation();

  virtual void GenerateQuicklook();

  unsigned int PixelSize(ImagePointerType image, ScalarType* v) const;
  unsigned int PixelSize(ImagePointerType image, VectorPixelType* v) const;
  unsigned int PixelSize(ImagePointerType image, RGBPixelType* v) const;
  unsigned int PixelSize(ImagePointerType image, RGBAPixelType* v) const;

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

  ImageLayerPointerType m_Layer;

//   RenderingFunctionPointerType m_RenderingFunction;

//   BlendingFunctionPointerType m_BlendingFunction;

  ImagePointerType m_Image;

  ImagePointerType m_Quicklook;

  unsigned int m_SubsamplingRate;

  bool m_GenerateQuicklook;

  ResampleFilterPointerType m_Resampler;

  double m_ScreenRatio;

}; // end class
} // end namespace otb

#ifndef OTB_MANUAL_INSTANTIATION
#include "otbImageLayerGenerator.txx"
#endif

#endif