otbGenericRSTransform.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 otbGenericRSTransform_h
#define otbGenericRSTransform_h
 
#include "otbCompositeTransform.h"
#include "otbImageMetadata.h"
#include "otbSensorTransformFactory.h"
#include <string>
 
namespace otb
{
namespace Projection
{
enum TransformAccuracy
{
  UNKNOWN,
  ESTIMATE,
  PRECISE
};
}
template <class TScalarType = double, unsigned int NInputDimensions = 2,
          unsigned int NOutputDimensions = 2>
class ITK_EXPORT       GenericRSTransform : public otb::Transform<TScalarType, // Data type for scalars
                                                            NInputDimensions,  // Number of dimensions in the input space
                                                            NOutputDimensions> // Number of dimensions in the output space
{
public:
  typedef otb::Transform<TScalarType, NInputDimensions, NOutputDimensions> Superclass;
  typedef GenericRSTransform            Self;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
  typedef typename Superclass::ScalarType   ScalarType;
  typedef typename Superclass::JacobianType JacobianType;
  typedef itk::Point<ScalarType, NInputDimensions>  InputPointType;
  typedef itk::Point<ScalarType, NOutputDimensions> OutputPointType;
 
  typedef itk::Vector<double, 2> SpacingType;
  typedef itk::Point<double, 2>  OriginType;
 
  typedef itk::Transform<double, NInputDimensions, NOutputDimensions> GenericTransformType;
  typedef typename GenericTransformType::Pointer GenericTransformPointerType;
  typedef otb::CompositeTransform<GenericTransformType, GenericTransformType> TransformType;
  typedef typename TransformType::Pointer TransformPointerType;
 
  typedef typename Superclass::InverseTransformBasePointer InverseTransformBasePointer;
 
  itkNewMacro(Self);
 
  itkTypeMacro(GenericRSTransform, Transform);
 
  typedef TransformDirection DirectionOfMappingEnumType;
 
  itkStaticConstMacro(InputSpaceDimension, unsigned int, NInputDimensions);
  itkStaticConstMacro(OutputSpaceDimension, unsigned int, NOutputDimensions);
  itkStaticConstMacro(SpaceDimension, unsigned int, NInputDimensions);
  itkStaticConstMacro(ParametersDimension, unsigned int, NInputDimensions*(NInputDimensions + 1));
 
  itkSetStringMacro(InputProjectionRef);
  itkGetStringMacro(InputProjectionRef);
 
  itkSetStringMacro(OutputProjectionRef);
  itkGetStringMacro(OutputProjectionRef);
 
  const ImageMetadata* GetInputImageMetadata() const
  {
    return m_InputImd;
  }
 
  void SetInputImageMetadata(const ImageMetadata* imd)
  {
    m_InputImd = imd;
    this->Modified();
  }
 
  const ImageMetadata* GetOutputImageMetadata() const
  {
    return m_OutputImd;
  }
 
  void SetOutputImageMetadata(const ImageMetadata* imd)
  {
    m_OutputImd = imd;
    this->Modified();
  }
 
  itkSetMacro(InputOrigin, OriginType);
  itkGetConstReferenceMacro(InputOrigin, OriginType);
 
  itkSetMacro(InputSpacing, SpacingType);
  itkGetConstReferenceMacro(InputSpacing, SpacingType);
 
  itkSetMacro(OutputOrigin, OriginType);
  itkGetConstReferenceMacro(OutputOrigin, OriginType);
 
  itkSetMacro(OutputSpacing, SpacingType);
  itkGetConstReferenceMacro(OutputSpacing, SpacingType);
 
  virtual bool IsUpToDate()
  {
    return m_TransformUpToDate;
  }
 
  itkGetMacro(TransformAccuracy, Projection::TransformAccuracy);
 
  virtual const TransformType* GetTransform() const;
 
  OutputPointType TransformPoint(const InputPointType& point) const override;
 
  virtual void InstantiateTransform();
 
  // Get inverse methods
  bool GetInverse(Self* inverseTransform) const;
  InverseTransformBasePointer GetInverseTransform() const override;
 
  // Dummy set parameter method
  void SetParameters(const typename Superclass::ParametersType&) override
  {
  }
 
  // Dummy ComputeJacobianWithRespectToParameters method
  void ComputeJacobianWithRespectToParameters(const InputPointType&, JacobianType&) const override
  {
  }
 
protected:
  GenericRSTransform();
  ~GenericRSTransform() override
  {
   // SensorTransformFactory<TScalarType, NInputDimensions, NOutputDimensions>::CleanFactories();
  }
 
  void Modified() const override
  {
    this->Superclass::Modified();
    m_TransformUpToDate = false;
  }
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
private:
  GenericRSTransform(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  const ImageMetadata* m_InputImd;
  const ImageMetadata* m_OutputImd;
 
  std::string m_InputProjectionRef;
  std::string m_OutputProjectionRef;
 
  SpacingType m_InputSpacing;
  OriginType  m_InputOrigin;
  SpacingType m_OutputSpacing;
  OriginType  m_OutputOrigin;
 
  TransformPointerType m_Transform;
 
  GenericTransformPointerType   m_InputTransform;
  GenericTransformPointerType   m_OutputTransform;
  mutable bool                  m_TransformUpToDate;
  Projection::TransformAccuracy m_TransformAccuracy;
};
 
} // namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbGenericRSTransform.hxx"
#endif
 
#endif