otbSynthetizeFilter.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 otbSynthetizeFilter_h
#define otbSynthetizeFilter_h
 
#include "otbZipIterator.h"
#include "itkImageToImageFilter.h"
#include "itkImageScanlineConstIterator.h"
#include "itkImageScanlineIterator.h"
#include "itkProgressReporter.h"
 
namespace otb
{
template <typename TInputImage, typename TOutputImage, typename TFunctor>
class SynthetizeFilter : public itk::ImageToImageFilter<TInputImage, TOutputImage>
{
public:
 
  using InputImageType  = TInputImage;
  using OutputImageType = TOutputImage;
  using FunctorType     = TFunctor;
 
  itkStaticConstMacro(InputImageDimension,  unsigned int, InputImageType::ImageDimension);
  itkStaticConstMacro(OutputImageDimension, unsigned int, OutputImageType::ImageDimension);
 
  using Self            = SynthetizeFilter;
  using Superclass      = itk::ImageToImageFilter<InputImageType, OutputImageType>;
  using Pointer         = itk::SmartPointer<Self>;
  using ConstPointer    = itk::SmartPointer<const Self>;
 
  static Pointer New(FunctorType functor)
  {
    Pointer smartPtr = new Self(std::move(functor));
    smartPtr->UnRegister();
    return smartPtr;
  }
 
  itkTypeMacro(SynthetizeFilter, ImageToImageFilter);
 
  using InputPixelType        = typename InputImageType::PixelType;
  using OutputPixelType       = typename OutputImageType::PixelType;
  using InputRealType         = typename itk::NumericTraits<InputPixelType>::RealType;
  using InputImageRegionType  = typename InputImageType::RegionType;
  using OutputImageRegionType = typename OutputImageType::RegionType;
  using InputSizeType         = typename InputImageType::SizeType;
  using OutputIndexType       = typename OutputImageType::IndexType;
  using OutputSizeType        = typename OutputImageType::SizeType;
 
  static_assert(InputImageDimension == OutputImageDimension, "Images have the same number of components");
 
  using DataObjectPointerArraySizeType = itk::ProcessObject::DataObjectPointerArraySizeType;
 
  using Superclass::SetNthInput;
  using Superclass::GetInput;
 
  InputImageType* GetNthInput(DataObjectPointerArraySizeType idx)
  {
    return const_cast<InputImageType*>(this->GetInput(idx));
  }
 
  std::vector<InputImageType const*> GetInputs() const
  {
    std::vector<InputImageType const*> res;
    auto const  nbInputImages = this->GetNumberOfInputs();
    res.reserve(nbInputImages);
    for (std::size_t i = 0 ; i != nbInputImages ; ++i)
      res.push_back(this->GetInput(i));
    return res;
  }
 
 
protected:
  explicit SynthetizeFilter(FunctorType functor)
    : m_functor(functor){}
  ~SynthetizeFilter() = default;
 
  void GenerateOutputInformation() override
  {
    Superclass::GenerateOutputInformation();
    CheckInputImageDimensions();
  }
 
  // void GenerateInputRequestedRegion() override;
  // +-> TODO: detect neighborhood to apply pad radius
 
  void DynamicThreadedGenerateData(
      OutputImageRegionType const& outputRegionForThread) override
  {
    using ImageScanlineConstIteratorType = itk::ImageScanlineConstIterator<InputImageType const>;
    // using OutImageScanlineConstIteratorType = itk::ImageScanlineIterator<OutputImageType>;
    using OutputIterator  = itk::ImageScanlineIterator<OutputImageType>;
    using InputIterator   = ZipConstIterator<ImageScanlineConstIteratorType>;
 
    InputIterator  inputIterator(this->GetInputs(), outputRegionForThread);
    OutputIterator outputIterator(this->GetOutput(), outputRegionForThread);
 
    inputIterator.GoToBegin();
    outputIterator.GoToBegin();
    for (
        ; !inputIterator.IsAtEnd()
        ; inputIterator.NextLine(), outputIterator.NextLine())
    {
      assert(! outputIterator.IsAtEnd());
      // inputIterator.GoToBeginOfLine();
      // outputIterator.GoToBeginOfLine();
      for (
          ; !inputIterator.IsAtEndOfLine()
          ; ++inputIterator, ++outputIterator)
      {
        assert(!outputIterator.IsAtEndOfLine());
 
        outputIterator.Set(m_functor(inputIterator.Get()));
      }
    }
  }
 
private:
 
  void CheckInputImageDimensions()
  {
    // Check if input image dimensions match
    auto const  nbInputImages = this->GetNumberOfInputs();
    auto const& inputSize = this->GetInput(0)->GetLargestPossibleRegion().GetSize();
 
    for (auto p = 1U; p < nbInputImages; ++p)
    {
      auto const& regionSize = this->GetInput(p)->GetLargestPossibleRegion().GetSize();
      if (inputSize != regionSize)
      {
        itkExceptionMacro(<< "Input images must have the same dimensions.\n"
            << "band #1 is [" << inputSize[0] << ";" << inputSize[1] << "]\n"
            << "band #" << p + 1 << " is [" << this->GetInput(p)->GetLargestPossibleRegion().GetSize(0) << ";"
            << regionSize << "]");
      }
    }
  }
 
  FunctorType m_functor;
 
};
 
template <typename TInputImage, typename TOutputImage, typename TFunctor>
auto MakeSynthetizeFilter(TFunctor functor)
{
  auto filter = SynthetizeFilter<TInputImage, TOutputImage, TFunctor>::New(std::move(functor));
  return filter;
}
 
} // otb namespace
 
#ifndef OTB_MANUAL_INSTANTIATION
// #include "otbSynthetizeFilter.hxx"
#endif
 
#endif  // otbSynthetizeFilter_h