otbImageToSIFTKeyPointSetFilter.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 otbImageToSIFTKeyPointSetFilter_h
#define otbImageToSIFTKeyPointSetFilter_h
 
#include <vector>
 
#include "itkExpandImageFilter.h"
#include "itkDiscreteGaussianImageFilter.h"
#include "itkRecursiveGaussianImageFilter.h"
#include "itkSubtractImageFilter.h"
#include "itkShrinkImageFilter.h"
#include "itkConstNeighborhoodIterator.h"
#include "itkImageRegionConstIterator.h"
#include "itkVector.h"
#include "itkMinimumMaximumImageCalculator.h"
#include "itkUnaryFunctorImageFilter.h"
#include "itkGradientImageFilter.h"
 
#include "otbImageToPointSetFilter.h"
#include "otbImageList.h"
#include "otbMath.h"
 
namespace otb
{
 
namespace Functor
{
template <class TInputPixel, class TOutputPixel>
class MagnitudeFunctor
{
public:
  inline TOutputPixel operator()(const TInputPixel& input)
  {
    return std::sqrt(input[0] * input[0] + input[1] * input[1]);
  }
};
 
template <class TInputPixel, class TOutputPixel>
class OrientationFunctor
{
public:
  inline TOutputPixel operator()(const TInputPixel& input)
  {
    TOutputPixel resp = std::atan2(input[1], input[0]);
    if (resp < 0)
    {
      resp += CONST_2PI;
    }
 
    return resp;
  }
};
} // end namespace Functor
 
template <class TInputImage, class TOutputPointSet>
class ITK_EXPORT ImageToSIFTKeyPointSetFilter : public ImageToPointSetFilter<TInputImage, TOutputPointSet>
{
public:
  typedef ImageToSIFTKeyPointSetFilter Self;
  typedef ImageToPointSetFilter<TInputImage, TOutputPointSet> Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
  itkNewMacro(Self);
 
  itkTypeMacro(ImageToSIFTKeyPointSetFilter, ImageToPointSetFilter);
 
  typedef TInputImage                     InputImageType;
  typedef typename TInputImage::Pointer   InputImagePointerType;
  typedef typename TInputImage::PixelType PixelType;
 
  typedef TOutputPointSet                           OutputPointSetType;
  typedef typename TOutputPointSet::Pointer         OutputPointSetPointerType;
  typedef typename TOutputPointSet::PixelType       OutputPixelType;
  typedef typename TOutputPointSet::PointType       OutputPointType;
  typedef typename TOutputPointSet::PointIdentifier OutputPointIdentifierType;
 
  typedef itk::Vector<PixelType, 3> VectorPointType;
 
  itkSetMacro(OctavesNumber, unsigned int);
  itkGetMacro(OctavesNumber, unsigned int);
 
  itkSetMacro(ScalesNumber, unsigned int);
  itkGetMacro(ScalesNumber, unsigned int);
 
  itkSetMacro(ExpandFactors, unsigned int);
  itkGetMacro(ExpandFactors, unsigned int);
 
  itkSetMacro(ShrinkFactors, unsigned int);
  itkGetMacro(ShrinkFactors, unsigned int);
 
  itkSetMacro(Sigma0, double);
  itkGetMacro(Sigma0, double);
 
  itkSetMacro(DoGThreshold, double);
  itkGetMacro(DoGThreshold, double);
 
  itkSetMacro(EdgeThreshold, double);
  itkGetMacro(EdgeThreshold, double);
 
  itkSetMacro(SigmaFactorOrientation, double);
  itkGetMacro(SigmaFactorOrientation, double);
 
  itkSetMacro(SigmaFactorDescriptor, double);
  itkGetMacro(SigmaFactorDescriptor, double);
 
  typedef itk::ExpandImageFilter<TInputImage, TInputImage> ExpandFilterType;
  typedef typename ExpandFilterType::Pointer ExpandFilterPointerType;
 
  typedef itk::ShrinkImageFilter<InputImageType, InputImageType> ShrinkFilterType;
  typedef typename ShrinkFilterType::Pointer ShrinkFilterPointerType;
 
  typedef itk::RecursiveGaussianImageFilter<InputImageType, InputImageType> GaussianFilterType;
  typedef typename GaussianFilterType::Pointer GaussianFilterPointerType;
 
  typedef otb::ImageList<InputImageType>  ImageListType;
  typedef typename ImageListType::Pointer ImageListPointerType;
 
  typedef itk::SubtractImageFilter<InputImageType, InputImageType, InputImageType> SubtractFilterType;
  typedef typename SubtractFilterType::Pointer SubtractFilterPointerType;
 
  typedef itk::ConstNeighborhoodIterator<InputImageType>      NeighborhoodIteratorType;
  typedef typename NeighborhoodIteratorType::NeighborhoodType NeighborhoodType;
  typedef typename NeighborhoodType::OffsetType               OffsetType;
 
  typedef itk::ImageRegionConstIterator<InputImageType> RegionIteratorType;
 
  typedef itk::MinimumMaximumImageCalculator<InputImageType> MinimumMaximumCalculatorType;
  typedef typename MinimumMaximumCalculatorType::Pointer     MinimumMaximumCalculatorPointerType;
 
  typedef itk::GradientImageFilter<InputImageType, PixelType, PixelType> GradientFilterType;
  typedef typename GradientFilterType::Pointer         GradientFilterPointerType;
  typedef typename GradientFilterType::OutputImageType GradientOutputImageType;
 
  typedef itk::UnaryFunctorImageFilter<GradientOutputImageType, InputImageType,
                                       Functor::MagnitudeFunctor<typename GradientOutputImageType::PixelType, typename InputImageType::PixelType>>
                                                MagnitudeFilterType;
  typedef typename MagnitudeFilterType::Pointer MagnitudeFilterPointerType;
 
  typedef itk::UnaryFunctorImageFilter<GradientOutputImageType, InputImageType,
                                       Functor::OrientationFunctor<typename GradientOutputImageType::PixelType, typename InputImageType::PixelType>>
                                                  OrientationFilterType;
  typedef typename OrientationFilterType::Pointer OrientationFilterPointerType;
 
protected:
  void GenerateData() override;
 
  ImageToSIFTKeyPointSetFilter();
 
  ~ImageToSIFTKeyPointSetFilter() override
  {
  }
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const override;
 
  void InitializeInputImage();
 
  void ComputeDifferenceOfGaussian(InputImagePointerType input);
 
  void DetectKeyPoint(const unsigned int octave);
 
  bool IsLocalExtremum(const NeighborhoodIteratorType& currentScale, const NeighborhoodIteratorType& previousScale,
                       const NeighborhoodIteratorType& nextScale) const;
 
  bool RefineLocationKeyPoint(const NeighborhoodIteratorType& currentScale, const NeighborhoodIteratorType& previousScale,
                              const NeighborhoodIteratorType& nextScale, VectorPointType& solution);
 
  std::vector<PixelType> ComputeKeyPointOrientations(const NeighborhoodIteratorType& currentScale, const unsigned int scale, const PixelType translation);
 
  std::vector<PixelType> ComputeKeyPointDescriptor(const NeighborhoodIteratorType& currentScale, const unsigned int scale, const PixelType& orientation);
 
private:
  ImageToSIFTKeyPointSetFilter(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  unsigned int m_OctavesNumber;
 
  unsigned int m_ScalesNumber;
 
  unsigned int m_ExpandFactors;
 
  unsigned int m_ShrinkFactors;
 
  double m_DoGThreshold;
 
  double m_EdgeThreshold;
 
  double m_RatioEdgeThreshold;
 
  PixelType m_GradientMagnitudeThreshold;
 
  typename GaussianFilterType::ScalarRealType m_Sigma0;
 
  double m_Sigmak;
 
  double m_SigmaFactorOrientation;
 
  double m_SigmaFactorDescriptor;
 
  ExpandFilterPointerType m_ExpandFilter;
 
  ShrinkFilterPointerType m_ShrinkFilter;
 
  GaussianFilterPointerType m_XGaussianFilter;
  GaussianFilterPointerType m_YGaussianFilter;
 
  InputImagePointerType m_LastGaussian;
 
  ImageListPointerType m_DoGList;
 
  ImageListPointerType m_MagnitudeList;
 
  ImageListPointerType m_OrientationList;
 
  SubtractFilterPointerType m_SubtractFilter;
 
  GradientFilterPointerType m_GradientFilter;
 
  MagnitudeFilterPointerType m_MagnitudeFilter;
 
  OrientationFilterPointerType m_OrientationFilter;
 
  OutputPointIdentifierType m_ValidatedKeyPoints;
 
  unsigned int m_DifferentSamplePoints;
 
  unsigned int m_DiscardedKeyPoints;
 
  unsigned int m_ChangeSamplePointsMax;
 
  std::vector<double> m_HistogramGaussianWeights;
 
  OffsetType m_Offsets[8];
};
} // End namespace otb
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbImageToSIFTKeyPointSetFilter.hxx"
#endif
 
#endif