otbGenericRSResampleImageFilter.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2022 Centre National d'Etudes Spatiales (CNES)
 *
 * This file is part of Orfeo Toolbox
 *
 *     https://www.orfeo-toolbox.org/
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef otbGenericRSResampleImageFilter_h
#define otbGenericRSResampleImageFilter_h
 
#include "otbStreamingResampleImageFilter.h"
#include "otbPhysicalToRPCSensorModelImageFilter.h"
#include <string>
 
namespace otb
{
 
template <class TInputImage, class TOutputImage>
class ITK_EXPORT GenericRSResampleImageFilter : public itk::ImageToImageFilter<TInputImage, TOutputImage>
{
public:
  typedef GenericRSResampleImageFilter Self;
  typedef itk::ImageToImageFilter<TInputImage, TOutputImage> Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
  itkNewMacro(Self);
 
  itkTypeMacro(GenericRSResampleImageFilter, itk::ImageToImageFilter);
 
  typedef TInputImage                                 InputImageType;
  typedef TOutputImage                                OutputImageType;
  typedef typename OutputImageType::InternalPixelType OutputInternalPixelType;
  typedef typename OutputImageType::PointType         OutputPointType;
 
  typedef StreamingResampleImageFilter<InputImageType, OutputImageType> ResamplerType;
  typedef typename ResamplerType::Pointer          ResamplerPointerType;
  typedef typename ResamplerType::TransformType    TransformType;
  typedef typename ResamplerType::SizeType         SizeType;
  typedef typename ResamplerType::SpacingType      SpacingType;
  typedef typename ResamplerType::OriginType       OriginType;
  typedef typename ResamplerType::IndexType        IndexType;
  typedef typename ResamplerType::RegionType       RegionType;
  typedef typename ResamplerType::InterpolatorType InterpolatorType;
 
  typedef PhysicalToRPCSensorModelImageFilter<InputImageType> InputRpcModelEstimatorType;
  typedef typename InputRpcModelEstimatorType::Pointer        InputRpcModelEstimatorPointerType;
 
  typedef PhysicalToRPCSensorModelImageFilter<OutputImageType> OutputRpcModelEstimatorType;
  typedef typename OutputRpcModelEstimatorType::Pointer        OutputRpcModelEstimatorPointerType;
 
 
  typedef GenericRSTransform<>                     GenericRSTransformType;
  typedef typename GenericRSTransformType::Pointer GenericRSTransformPointerType;
 
  typedef itk::ImageBase<OutputImageType::ImageDimension> ImageBaseType;
 
  otbSetObjectMemberMacro(Resampler, DisplacementFieldSpacing, SpacingType);
 
  otbGetObjectMemberConstReferenceMacro(Resampler, DisplacementFieldSpacing, SpacingType);
 
  void SetOutputOrigin(const OriginType& origin)
  {
    m_Resampler->SetOutputOrigin(origin);
    this->Modified();
  }
  otbGetObjectMemberConstReferenceMacro(Resampler, OutputOrigin, OriginType);
 
  otbSetObjectMemberMacro(Resampler, OutputStartIndex, IndexType);
  otbGetObjectMemberConstReferenceMacro(Resampler, OutputStartIndex, IndexType);
 
  otbSetObjectMemberMacro(Resampler, OutputSize, SizeType);
  otbGetObjectMemberConstReferenceMacro(Resampler, OutputSize, SizeType);
 
  otbSetObjectMemberMacro(Resampler, OutputSpacing, SpacingType);
  otbGetObjectMemberConstReferenceMacro(Resampler, OutputSpacing, SpacingType);
 
  void SetInterpolator(InterpolatorType* interpolator)
  {
    m_Resampler->SetInterpolator(interpolator);
    this->Modified();
  }
  otbGetObjectMemberConstMacro(Resampler, Interpolator, const InterpolatorType*);
 
  otbSetObjectMemberMacro(Resampler, EdgePaddingValue, typename OutputImageType::PixelType);
  otbGetObjectMemberMacro(Resampler, EdgePaddingValue, typename OutputImageType::PixelType);
 
  void SetInputProjectionRef(const std::string& ref)
  {
    m_Transform->SetOutputProjectionRef(ref);
    this->Modified();
  }
 
  std::string GetInputProjectionRef() const
  {
    return m_Transform->GetOutputProjectionRef();
  }
 
  void SetOutputProjectionRef(const std::string& ref)
  {
    m_Transform->SetInputProjectionRef(ref);
    this->Modified();
  }
 
  std::string GetOutputProjectionRef() const
  {
    return m_Transform->GetInputProjectionRef();
  }
 
  void SetInputImageMetadata(const ImageMetadata* imd)
  {
    m_Transform->SetOutputImageMetadata(imd);
    this->Modified();
  }
 
  const ImageMetadata* GetInputImageMetadata()
  {
    return m_Transform->GetOutputImageMetadata();
  }
 
  void SetOutputImageMetadata(const ImageMetadata* imd)
  {
    m_Transform->SetInputImageMetadata(imd);
    this->Modified();
  }
 
  const ImageMetadata* GetOutputImageMetadata()
  {
    return m_Transform->GetInputImageMetadata();
  }
 
  void SetOutputParametersFromImage(const ImageBaseType* image);
 
  template <class TImageType>
  void SetOutputParametersFromImage(const TImageType* image);
 
  void SetOutputParametersFromMap(const std::string& map, const SpacingType& spacing);
 
  void SetOutputParametersFromMap(const std::string& projectionRef);
 
  void SetInputRpcGridSize(const SizeType& gridSize)
  {
    m_InputRpcEstimator->SetGridSize(gridSize);
    this->Modified();
  }
 
  void SetInputRpcGridSize(unsigned int gridSize)
  {
    m_InputRpcEstimator->SetGridSize(gridSize);
    this->Modified();
  }
 
  const SizeType& GetInputRpcGridSize() const
  {
    return m_InputRpcEstimator->GetGridSize();
  }
 
  itkSetMacro(EstimateInputRpcModel, bool);
  itkGetMacro(EstimateInputRpcModel, bool);
  itkBooleanMacro(EstimateInputRpcModel);
 
  void SetOutputRpcGridSize(const SizeType& gridSize)
  {
    m_OutputRpcEstimator->SetGridSize(gridSize);
    this->Modified();
  }
 
  void SetOutputRpcGridSize(unsigned int gridSize)
  {
    m_OutputRpcEstimator->SetGridSize(gridSize);
    this->Modified();
  }
 
  const SizeType& GetOutputRpcGridSize() const
  {
    return m_OutputRpcEstimator->GetGridSize();
  }
 
  itkSetMacro(EstimateOutputRpcModel, bool);
  itkGetMacro(EstimateOutputRpcModel, bool);
  itkBooleanMacro(EstimateOutputRpcModel);
 
  void SetDisplacementFilterNumberOfThreads(unsigned int nbThread)
  {
    m_Resampler->SetDisplacementFilterNumberOfThreads(nbThread);
  }
 
  void PropagateRequestedRegion(itk::DataObject* output) override;
 
protected:
  GenericRSResampleImageFilter();
  ~GenericRSResampleImageFilter() override{};
 
  void GenerateData() override;
 
  void GenerateOutputInformation() override;
 
  virtual void UpdateTransform();
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
private:
  GenericRSResampleImageFilter(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  // Method to estimate the input & output rpc model
  void EstimateOutputRpcModel();
  void EstimateInputRpcModel();
 
  // boolean that allow the estimation of the input rpc model
  bool m_EstimateInputRpcModel;
  bool m_EstimateOutputRpcModel;
  bool m_RpcEstimationUpdated;
 
  // Filters pointers
  ResamplerPointerType               m_Resampler;
  InputRpcModelEstimatorPointerType  m_InputRpcEstimator;
  OutputRpcModelEstimatorPointerType m_OutputRpcEstimator;
  GenericRSTransformPointerType      m_Transform;
};
 
} // namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbGenericRSResampleImageFilter.hxx"
#endif
 
#endif