otbStreamingResampleImageFilter.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 __otbStreamingResampleImageFilter_h
#define __otbStreamingResampleImageFilter_h

#include "itkImageToImageFilter.h"
#include "otbStreamingWarpImageFilter.h"
#include "itkTransformToDeformationFieldSource.h"
#include "itkLinearInterpolateImageFunction.h"
#include "itkInterpolateImageFunction.h"
#include "otbImage.h"
#include "itkVector.h"

#include "otbMacro.h"

namespace otb
{

template <class TInputImage, class TOutputImage,
          class TInterpolatorPrecisionType = double>
class ITK_EXPORT StreamingResampleImageFilter :
    public itk::ImageToImageFilter<TInputImage, TOutputImage>
{
public:
  typedef StreamingResampleImageFilter                                Self;
  typedef itk::ImageToImageFilter<TInputImage, TOutputImage>    Superclass;
  typedef itk::SmartPointer<Self>                               Pointer;
  typedef itk::SmartPointer<const Self>                         ConstPointer;

  itkNewMacro(Self);

  itkTypeMacro(StreamingResampleImageFilter, itk::ImageToImageFilter);

  typedef TInputImage                InputImageType;
  typedef TOutputImage               OutputImageType;
  
  typedef itk::Vector<double,
                      TOutputImage::ImageDimension>             DeformationType;
  typedef otb::Image<DeformationType>                           DeformationFieldType;

  typedef StreamingWarpImageFilter<InputImageType,
                                   OutputImageType,
                                   DeformationFieldType>        WarpImageFilterType;
  
  typedef itk::TransformToDeformationFieldSource<DeformationFieldType,
                                                 double>        DeformationFieldGeneratorType;
  typedef typename DeformationFieldGeneratorType::TransformType TransformType;
  typedef typename DeformationFieldGeneratorType::SizeType      SizeType;
  typedef typename DeformationFieldGeneratorType::SpacingType   SpacingType;
  typedef typename DeformationFieldGeneratorType::OriginType    OriginType;
  typedef typename DeformationFieldGeneratorType::IndexType     IndexType;
  typedef typename DeformationFieldGeneratorType::RegionType    RegionType;

  typedef itk::InterpolateImageFunction<InputImageType,
                                        TInterpolatorPrecisionType>       InterpolatorType;
  typedef typename InterpolatorType::Pointer                              InterpolatorPointerType;
  typedef itk::LinearInterpolateImageFunction<InputImageType,
                                              TInterpolatorPrecisionType> DefaultInterpolatorType;

  typedef itk::ImageBase<OutputImageType::ImageDimension>     ImageBaseType;
  
  
  void SetTransform(TransformType * transform)
  {
    m_DeformationFilter->SetTransform(transform);
    this->Modified();
  }
  otbGetObjectMemberConstMacro(DeformationFilter, Transform, const TransformType*);

  void SetDeformationFieldSpacing(const SpacingType & spacing)
  {
    m_DeformationFilter->SetOutputSpacing(spacing);
    this->Modified();
  }
  const SpacingType & GetDeformationFieldSpacing() const
  {
   return m_DeformationFilter->GetOutputSpacing();
  }

  // Output Origin
  void SetOutputOrigin(const OriginType & origin)
  {
    m_DeformationFilter->SetOutputOrigin(origin);
    m_WarpFilter->SetOutputOrigin(origin);
    this->Modified();
  }
  otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputOrigin, OriginType);

  // Output Start index
  otbSetObjectMemberMacro(WarpFilter, OutputStartIndex, IndexType);
  otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputStartIndex, IndexType);

  // Output Size
  otbSetObjectMemberMacro(WarpFilter, OutputSize, SizeType);
  otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputSize, SizeType);

  // Output Spacing
  otbSetObjectMemberMacro(WarpFilter, OutputSpacing, SpacingType);
  otbGetObjectMemberConstReferenceMacro(WarpFilter, OutputSpacing, SpacingType);
  
  void SetInterpolator(InterpolatorType * interpolator)
  {
    m_WarpFilter->SetInterpolator(interpolator);
    this->Modified();
  }
  otbGetObjectMemberConstMacro(WarpFilter, Interpolator, const InterpolatorType *);

  otbSetObjectMemberMacro(WarpFilter,
                          EdgePaddingValue,
                          typename OutputImageType::PixelType);
  otbGetObjectMemberMacro(WarpFilter,
                                        EdgePaddingValue,
                                        typename OutputImageType::PixelType);

  void SetOutputParametersFromImage(const ImageBaseType * image);

protected:
  StreamingResampleImageFilter();

  virtual ~StreamingResampleImageFilter() {};

  virtual void GenerateData();

  virtual void GenerateOutputInformation();

  virtual void GenerateInputRequestedRegion();

  void PrintSelf(std::ostream& os, itk::Indent indent) const;

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

  typename DeformationFieldGeneratorType::Pointer   m_DeformationFilter;
  typename WarpImageFilterType::Pointer             m_WarpFilter;
};

} // namespace otb

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

#endif