otbFineRegistrationImageFilter.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2024 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 otbFineRegistrationImageFilter_h
#define otbFineRegistrationImageFilter_h
 
#include "itkImageToImageFilter.h"
#include "itkInterpolateImageFunction.h"
#include "itkContinuousIndex.h"
 
#include "itkTranslationTransform.h"
#include "itkImageToImageMetric.h"
 
namespace otb
{
 
template <class TInputImage, class T0utputCorrelation, class TOutputDisplacementField>
class ITK_EXPORT FineRegistrationImageFilter : public itk::ImageToImageFilter<TInputImage, T0utputCorrelation>
{
public:
  typedef FineRegistrationImageFilter Self;
  typedef itk::ImageToImageFilter<TInputImage, T0utputCorrelation> Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
  itkNewMacro(Self);
 
  itkTypeMacro(FineRegistrationImageFilter, ImageToImageFilter);
 
  typedef typename T0utputCorrelation::RegionType      OutputImageRegionType;
  typedef typename TOutputDisplacementField::PixelType DisplacementValueType;
  typedef typename TInputImage::Pointer                InputImagePointerType;
  typedef typename TInputImage::RegionType             InputImageRegionType;
  typedef typename TInputImage::SizeType               SizeType;
  typedef typename TInputImage::IndexType              IndexType;
  typedef typename TInputImage::SpacingType            SpacingType;
  typedef typename TInputImage::PointType              PointType;
  typedef typename TInputImage::OffsetType             OffsetType;
  typedef itk::InterpolateImageFunction<TInputImage, double> InterpolatorType;
  typedef typename InterpolatorType::Pointer InterpolatorPointerType;
  typedef itk::ContinuousIndex<double, 2>                   ContinuousIndexType;
  typedef itk::ImageToImageMetric<TInputImage, TInputImage> MetricType;
  typedef typename MetricType::Pointer MetricPointerType;
  typedef itk::TranslationTransform<double, 2> TranslationType;
  typedef typename TranslationType::Pointer TranslationPointerType;
  typedef typename itk::Transform<double, 2, 2> TransformType;
  typedef typename TransformType::Pointer TransformPointerType;
 
  itkSetObjectMacro(Metric, MetricType);
  itkGetObjectMacro(Metric, MetricType);
 
  itkSetObjectMacro(Interpolator, InterpolatorType);
  itkGetObjectMacro(Interpolator, InterpolatorType);
 
  void SetFixedInput(const TInputImage* image);
 
  void SetMovingInput(const TInputImage* image);
 
  const TInputImage* GetFixedInput();
  const TInputImage* GetMovingInput();
 
  TOutputDisplacementField* GetOutputDisplacementField();
 
  itkSetMacro(Radius, SizeType);
  itkGetMacro(Radius, SizeType);
 
  itkSetMacro(SearchRadius, SizeType);
  itkGetMacro(SearchRadius, SizeType);
 
  itkSetMacro(ConvergenceAccuracy, double);
  itkGetMacro(ConvergenceAccuracy, double);
 
  itkSetMacro(SubPixelAccuracy, double);
  itkGetMacro(SubPixelAccuracy, double);
 
  itkSetMacro(MaxIter, int);
  itkGetMacro(MaxIter, int);
 
  itkSetMacro(Minimize, bool);
  itkBooleanMacro(Minimize);
 
  itkSetMacro(UseSpacing, bool);
  itkBooleanMacro(UseSpacing);
 
  itkSetMacro(InitialOffset, SpacingType);
  itkGetConstReferenceMacro(InitialOffset, SpacingType);
 
  itkSetMacro(GridStep, OffsetType);
  itkGetConstReferenceMacro(GridStep, OffsetType);
 
  void SetRadius(unsigned int radius)
  {
    m_Radius.Fill(radius);
  }
 
  void SetSearchRadius(unsigned int radius)
  {
    m_SearchRadius.Fill(radius);
  }
 
  void SetGridStep(unsigned int step)
  {
    m_GridStep.Fill(step);
  }
 
  itkSetObjectMacro(Transform, TransformType);
  itkGetConstObjectMacro(Transform, TransformType);
 
protected:
  FineRegistrationImageFilter();
 
  ~FineRegistrationImageFilter() override{};
 
  void GenerateData() override;
 
  void GenerateInputRequestedRegion(void) override;
 
  void GenerateOutputInformation(void) override;
 
private:
  FineRegistrationImageFilter(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  inline double callMetric(double val1, double val2, double& oldRes, bool& flag);
  inline void updateOptParams(double potBestVal, double parx, double pary,                           // inputs
                              double& bestVal, typename TranslationType::ParametersType& optParams); // outputs
  inline void updatePoints(double& gn, double& in1, double& in2, double& in3,                        // inputs
                           double& out1, double& out2, double& out3, double& out4);                  // outputs
  inline void updateMinimize(double& a, double& b);
 
  SizeType m_Radius;
 
  SizeType m_SearchRadius;
 
  bool m_Minimize;
 
  bool m_UseSpacing;
 
  double m_ConvergenceAccuracy;
  double m_SubPixelAccuracy;
 
  int m_MaxIter;
 
  InterpolatorPointerType m_Interpolator;
 
  MetricPointerType m_Metric;
 
  TranslationPointerType m_Translation;
 
  SpacingType m_InitialOffset;
 
  OffsetType m_GridStep;
 
  TransformPointerType m_Transform;
};
 
} // end namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbFineRegistrationImageFilter.hxx"
#endif
 
#endif