rtkLagCorrectionImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright RTK Consortium
 *
 *  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
 *
 *         https://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  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 rtkLagCorrectionImageFilter_h
#define rtkLagCorrectionImageFilter_h

#include <itkInPlaceImageFilter.h>
#include <itkVector.h>
#include <vector>

#include "rtkConfiguration.h"
#include "rtkMacro.h"

namespace rtk
{

template <typename TImage, unsigned VModelOrder>
class ITK_TEMPLATE_EXPORT LagCorrectionImageFilter : public itk::InPlaceImageFilter<TImage, TImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(LagCorrectionImageFilter);

  using Self = LagCorrectionImageFilter;
  using Superclass = itk::InPlaceImageFilter<TImage, TImage>;
  using Pointer = itk::SmartPointer<Self>;
  using ConstPointer = itk::SmartPointer<const Self>;

  itkNewMacro(Self);

#ifdef itkOverrideGetNameOfClassMacro
  itkOverrideGetNameOfClassMacro(LagCorrectionImageFilter);
#else
  itkTypeMacro(LagCorrectionImageFilter, ImageToImageFilter);
#endif


  using ImageRegionType = typename TImage::RegionType;
  using ImageSizeType = typename TImage::SizeType;
  using PixelType = typename TImage::PixelType;
  using IndexType = typename TImage::IndexType;
  using VectorType = typename itk::Vector<float, VModelOrder>;
  using FloatVectorType = typename std::vector<float>;
  using OutputImageRegionType = typename TImage::RegionType;

  itkGetMacro(A, VectorType);
  itkGetMacro(B, VectorType);
  virtual void
  SetCoefficients(const VectorType A, const VectorType B)
  {
    if ((this->m_A != A) && (this->m_B != B))
    {
      if ((A.Size() == VModelOrder) && (B.Size() == VModelOrder))
      {
      }
      this->m_A = A;
      this->m_B = B;
      this->Modified();
      m_NewParamJustReceived = true;
    }
  }

protected:
  LagCorrectionImageFilter();
  ~LagCorrectionImageFilter() override = default;

  void
  GenerateOutputInformation() override;

  void
  GenerateInputRequestedRegion() override;

  void
  ThreadedGenerateData(const ImageRegionType & thRegion, itk::ThreadIdType threadId) override;

  unsigned int
  SplitRequestedRegion(unsigned int i, unsigned int num, OutputImageRegionType & splitRegion) override;
  virtual int
  SplitRequestedRegion(int i, int num, OutputImageRegionType & splitRegion);

  VectorType m_A;     // a_n coefficients (lag rates)
  VectorType m_B;     // b coefficients (lag coefficients)
  VectorType m_ExpmA; // exp(-a)
  float      m_SumB;  // normalization factor

protected:
  FloatVectorType m_S; // State variable

private:
  bool      m_NewParamJustReceived; // For state/correction initialization
  IndexType m_StartIdx;             // To account for cropping
};

} // namespace rtk

#ifndef ITK_MANUAL_INSTANTIATION
#  include "rtkLagCorrectionImageFilter.hxx"
#endif

#endif