otbWaveletOperatorBase.h

Go to the documentation of this file.

/*
 * Copyright (C) 2005-2022 Centre National d'Etudes Spatiales (CNES)
 * Copyright (C) 2007-2012 Institut Mines Telecom / Telecom Bretagne
 *
 * 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 otbWaveletOperatorBase_h
#define otbWaveletOperatorBase_h
 
#include "itkMacro.h"
#include "itkNeighborhoodOperator.h"
 
// This include is needed here to define MotherWaveletOperatorEnum...
#include "otbWaveletGenerator.h"
 
namespace otb
{
 
namespace Wavelet
{
enum WaveletDirection
{
  FORWARD = 0,
  INVERSE = 1
};
}
 
template <Wavelet::Wavelet TMotherWaveletOperator, class TPixel, unsigned int VDimension, class TAllocator = itk::NeighborhoodAllocator<TPixel>>
class ITK_EXPORT WaveletOperatorBase : public itk::NeighborhoodOperator<TPixel, VDimension, TAllocator>
{
public:
 
  typedef WaveletOperatorBase Self;
  typedef itk::NeighborhoodOperator<TPixel, VDimension, TAllocator> Superclass;
 
  itkTypeMacro(WaveletOperatorBase, NeighborhoodOperator);
 
  typedef typename Superclass::SizeType SizeType;
  typedef Wavelet::Wavelet              MotherWaveletOperatorEnumType;
  itkStaticConstMacro(MotherWaveletOperator, MotherWaveletOperatorEnumType, TMotherWaveletOperator);
 
  WaveletOperatorBase() :
    m_UpSampleFactor(0),
    m_WaveletGenerator(WaveletGeneratorType::New())
    {}
 
  WaveletOperatorBase(const Self& other) :
    itk::NeighborhoodOperator<TPixel, VDimension, TAllocator>(other),
    m_UpSampleFactor(other.GetUpSampleFactor()),
    m_WaveletGenerator(WaveletGeneratorType::New())
    {}
 
  ~WaveletOperatorBase() override
  {
  }
 
  Self& operator=(const Self& other)
  {
    Superclass::operator=(other);
    m_UpSampleFactor    = other.GetUpSampleFactor();
    return *this;
  }
 
  unsigned int GetUpSampleFactor() const
  {
    return this->m_UpSampleFactor;
  }
 
  void SetUpSampleFactor(unsigned int upSampleFactor)
  {
    this->m_UpSampleFactor = upSampleFactor;
  }
 
  virtual const char* GetWaveletName() const
  {
    return this->m_WaveletGenerator->GetWaveletName();
  }
 
protected:
  void PrintSelf(std::ostream& os, itk::Indent i) const override;
 
  typedef WaveletGenerator<TMotherWaveletOperator> WaveletGeneratorType;
  typedef typename WaveletGeneratorType::Pointer   WaveletGeneratorPointerType;
 
  typedef typename Superclass::CoefficientVector CoefficientVector;
  typedef typename Superclass::PixelType         PixelType;
 
  void UpSamplingCoefficients(CoefficientVector& coeff);
 
  void RevertFilter(CoefficientVector& coeff);
 
  void GenerateInverseHighPassFilterFromLowPassFilter(CoefficientVector& coeff);
 
  void GenerateInverseLowPassFilterFromHighPassFilter(CoefficientVector& coeff);
 
  void ReduceFilterLength(CoefficientVector& coeff);
 
  void Fill(const CoefficientVector& coeff) override
  {
    this->FillCenteredDirectional(coeff);
  }
 
#if 0
 
  void GetHighPassFilterFromQuadratureLowPassFilter(CoefficientVector& coeff)
  {
    unsigned int length = coeff.size();
 
    CoefficientVector highPassCoeff (length);
    int               medianPosition = static_cast<int>(length) / 2;
 
    highPassCoeff[medianPosition] = -coeff[medianPosition];
 
    double sign = 1.;
    for (int i = 1; i <= medianPosition; ++i)
      {
      highPassCoeff[medianPosition + i] = sign * coeff[medianPosition - i];
      highPassCoeff[medianPosition - i] = sign * coeff[medianPosition + i];
      sign *= -1.;
      }
 
    coeff = highPassCoeff;
  }
 
  void GetInverseHighPassFilterFromForwardLowPassFilter(CoefficientVector& coeff)
  {
    unsigned long length = static_cast<unsigned long>(coeff.size());
    unsigned long medianPosition = length / 2;
 
    // Wavelet coefficients are always of add size, so that 2*medianPosition < length
    coeff[medianPosition] *= -1.;
    for (unsigned int i = 2; i <= medianPosition; i += 2)
      {
      coeff[medianPosition + i] *= -1.;
      coeff[medianPosition - i] *= -1.;
      }
  }
 
  void GetInverseLowPassFilterFromForwardHighPassFilter(CoefficientVector& coeff)
  {
    unsigned long length = static_cast<unsigned long>(coeff.size());
    unsigned long medianPosition = length / 2;
 
    // Wavelet coefficients are always of add size, so that 2*medianPosition < length
    for (unsigned int i = 1; i <= medianPosition; i += 2)
      {
      coeff[medianPosition + i] *= -1.;
      coeff[medianPosition - i] *= -1.;
      }
  }
 
  void GetForwardHighPassFilterFromInverseLowPassFilter(CoefficientVector& coeff)
  {
    GetInverseLowPassFilterFromForwardHighPassFilter(coeff);
  }
#endif
 
 
  unsigned int                m_UpSampleFactor;
  WaveletGeneratorPointerType m_WaveletGenerator;
};
 
} // end of namespace otb
 
#ifndef OTB_MANUAL_INSTANTIATION
#include "otbWaveletOperatorBase.hxx"
#endif
 
#endif