otbResetMarginFilter.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 otbResetMarginFilter_h
#define otbResetMarginFilter_h
 
#include "itkImageToImageFilter.h"
 
namespace otb
{
template <typename TImage>
class ResetMarginFilter : public itk::ImageToImageFilter<TImage, TImage>
{
public:
 
  using InputImageType  = TImage;
  using OutputImageType = TImage;
 
  itkStaticConstMacro(InputImageDimension, unsigned int, InputImageType::ImageDimension);
  itkStaticConstMacro(OutputImageDimension, unsigned int, OutputImageType::ImageDimension);
 
  using Self            = ResetMarginFilter;
  using Superclass      = itk::ImageToImageFilter<InputImageType, OutputImageType>;
  using Pointer         = itk::SmartPointer<Self>;
  using ConstPointer    = itk::SmartPointer<const Self>;
 
  itkNewMacro(Self);
 
  itkTypeMacro(ResetMarginFilter, unused);
 
  using InputPixelType        = typename InputImageType::PixelType;
  using OutputPixelType       = typename OutputImageType::PixelType;
  using InternalPixelType     = typename OutputImageType::InternalPixelType;
  using InputRealType         = typename itk::NumericTraits<InputPixelType>::RealType;
  using InputImageRegionType  = typename InputImageType::RegionType;
  using OutputImageRegionType = typename OutputImageType::RegionType;
  using InputIndexType        = typename InputImageType::IndexType;
  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");
 
  void SetROI(const InputImageRegionType& roi)
  {
    m_ROI = roi;
  }
 
  const InputImageRegionType& GetROI() const
  {
    return m_ROI;
  }
 
  void SetPaddingValue(InternalPixelType val)
  {
    m_Pad = val;
  }
 
  InternalPixelType GetPaddingValue() const
  {
    return m_Pad;
  }
 
protected:
  ResetMarginFilter()
  {
    this->DynamicMultiThreadingOff();
  }
 
  InputImageType      * GetInputImage()       { return const_cast<InputImageType*>(this->GetInput()); }
  InputImageType const* GetInputImage() const { return this->GetInput(); }
 
  void CallCopyOutputRegionToInputRegion(
      InputImageRegionType       & destRegion,
      OutputImageRegionType const& srcRegion) override
  {
    destRegion = OutputRegionToInputRegion(srcRegion);
  }
 
  InputImageRegionType OutputRegionToInputRegion(
      OutputImageRegionType const& srcRegion);
 
  void GenerateOutputInformation() override;
 
  void ThreadedGenerateData(
      OutputImageRegionType const& outputRegionForThread,
      itk::ThreadIdType            threadId) override;
 
private:
 
  InputImageRegionType m_ROI;
 
  InternalPixelType m_Pad = 0.0;
};
 
} // otb namespace
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbResetMarginFilter.hxx"
#endif
 
#endif  // otbResetMarginFilter_h