otbConvexOrConcaveClassificationFilter.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 otbConvexOrConcaveClassificationFilter_h
#define otbConvexOrConcaveClassificationFilter_h
 
#include "itkBinaryFunctorImageFilter.h"
namespace otb
{
namespace Functor
{
template <class TInput, class TOutput>
class ConvexOrConcaveDecisionRule
{
 
public:
  ConvexOrConcaveDecisionRule()
    : m_ConvexLabel(1), m_ConcaveLabel(2), m_FlatLabel(0), m_Sigma(0.0)
    {}
 
  virtual ~ConvexOrConcaveDecisionRule()
  {
  }
 
  inline TOutput operator()(const TInput& x, const TInput& xlevel)
  {
    TOutput resp = m_FlatLabel;
 
    if (static_cast<double>(x - xlevel) > m_Sigma)
    {
      resp = m_ConvexLabel;
    }
    else if (static_cast<double>(xlevel - x) > m_Sigma)
    {
      resp = m_ConcaveLabel;
    }
    return resp;
  }
  void SetConvexLabel(const TOutput& label)
  {
    m_ConvexLabel = label;
  }
 
  TOutput GetConvexLabel(void)
  {
    return m_ConvexLabel;
  }
 
  void SetConcaveLabel(const TOutput& label)
  {
    m_ConcaveLabel = label;
  }
 
  TOutput GetConcaveLabel(void)
  {
    return m_ConcaveLabel;
  }
 
  void SetFlatLabel(const TOutput& label)
  {
    m_FlatLabel = label;
  }
 
  TOutput GetFlatLabel(void)
  {
    return m_FlatLabel;
  }
 
  void SetSigma(const double& sigma)
  {
    m_Sigma = sigma;
  }
 
  double GetSigma(void)
  {
    return m_Sigma;
  }
 
private:
  TOutput m_ConvexLabel;
 
  TOutput m_ConcaveLabel;
 
  TOutput m_FlatLabel;
 
  double m_Sigma;
};
} // end namespace Functor
 
template <class TInputImage, class TOutputImage>
class ITK_EXPORT ConvexOrConcaveClassificationFilter
    : public itk::BinaryFunctorImageFilter<TInputImage, TInputImage, TOutputImage,
                                           Functor::ConvexOrConcaveDecisionRule<typename TInputImage::PixelType, typename TOutputImage::PixelType>>
{
public:
  typedef ConvexOrConcaveClassificationFilter Self;
  typedef itk::BinaryFunctorImageFilter<TInputImage, TInputImage, TOutputImage,
                                        Functor::ConvexOrConcaveDecisionRule<typename TInputImage::PixelType, typename TOutputImage::PixelType>>
                                        Superclass;
  typedef itk::SmartPointer<Self>       Pointer;
  typedef itk::SmartPointer<const Self> ConstPointer;
 
  itkNewMacro(Self);
 
  itkTypeMacro(ConvexOrConcaveClassificationFilter, BinaryFunctorImageFilter);
 
  typedef TInputImage                         InputImageType;
  typedef TOutputImage                        OutputImageType;
  typedef typename OutputImageType::PixelType LabelType;
  typedef Functor::ConvexOrConcaveDecisionRule<typename TInputImage::PixelType, typename TOutputImage::PixelType> DecisionFunctorType;
 
  using Superclass::SetInput;
  void SetInput(const TInputImage* image) override
  {
    this->SetInput1(image);
  }
 
  void SetInputLeveling(const TInputImage* leveling)
  {
    this->SetInput2(leveling);
  }
 
  itkSetMacro(ConvexLabel, LabelType);
  itkGetMacro(ConvexLabel, LabelType);
 
  itkSetMacro(ConcaveLabel, LabelType);
  itkGetMacro(ConcaveLabel, LabelType);
 
  itkSetMacro(FlatLabel, LabelType);
  itkGetMacro(FlatLabel, LabelType);
 
  itkSetMacro(Sigma, double);
  itkGetMacro(Sigma, double);
 
  void BeforeThreadedGenerateData(void) override
  {
    this->GetFunctor().SetConvexLabel(m_ConvexLabel);
    this->GetFunctor().SetConcaveLabel(m_ConcaveLabel);
    this->GetFunctor().SetFlatLabel(m_FlatLabel);
    this->GetFunctor().SetSigma(m_Sigma);
  }
 
protected:
  ConvexOrConcaveClassificationFilter()
    : m_ConvexLabel(1), m_ConcaveLabel(2), m_FlatLabel(0), m_Sigma(0.0)
    {};
 
  ~ConvexOrConcaveClassificationFilter() override
  {
  }
 
  void PrintSelf(std::ostream& os, itk::Indent indent) const override
  {
    Superclass::PrintSelf(os, indent);
    os << indent << "ConvexLabel: " << m_ConvexLabel << std::endl;
    os << indent << "ConcaveLabel: " << m_ConcaveLabel << std::endl;
    os << indent << "FlatLabel: " << m_FlatLabel << std::endl;
    os << indent << "Sigma: " << m_Sigma << std::endl;
  }
 
private:
  ConvexOrConcaveClassificationFilter(const Self&) = delete;
  void operator=(const Self&) = delete;
 
  LabelType m_ConvexLabel;
 
  LabelType m_ConcaveLabel;
 
  LabelType m_FlatLabel;