itkDisplacementFieldToBSplineImageFilter.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright NumFOCUS
 *
 *  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 itkDisplacementFieldToBSplineImageFilter_h
#define itkDisplacementFieldToBSplineImageFilter_h
 
#include "itkImageToImageFilter.h"
 
#include "itkBSplineScatteredDataPointSetToImageFilter.h"
#include "itkPointSet.h"
#include "itkVector.h"
 
namespace itk
{

 
template <typename TInputImage,
          typename TInputPointSet = PointSet<typename TInputImage::PixelType, TInputImage::ImageDimension>,
          typename TOutputImage = TInputImage>
class ITK_TEMPLATE_EXPORT DisplacementFieldToBSplineImageFilter : public ImageToImageFilter<TInputImage, TOutputImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(DisplacementFieldToBSplineImageFilter);
 
  using Self = DisplacementFieldToBSplineImageFilter;
  using Superclass = ImageToImageFilter<TInputImage, TOutputImage>;
  using Pointer = SmartPointer<Self>;
  using ConstPointer = SmartPointer<const Self>;

  itkNewMacro(Self);

  itkOverrideGetNameOfClassMacro(DisplacementFieldToBSplineImageFilter);

  static constexpr unsigned int ImageDimension = TInputImage::ImageDimension;
 
  using InputFieldType = TInputImage;
  using InputPointSetType = TInputPointSet;
  using OutputFieldType = TOutputImage;
 
  using DisplacementFieldType = InputFieldType;
  using InverseDisplacementFieldType = OutputFieldType;
  using InputFieldPointType = typename InputFieldType::PointType;

  using PixelType = typename OutputFieldType::PixelType;
  using VectorType = typename OutputFieldType::PixelType;
  using RegionType = typename OutputFieldType::RegionType;
  using IndexType = typename OutputFieldType::IndexType;
 
  using SpacingType = typename OutputFieldType::SpacingType;
  using OriginType = typename OutputFieldType::PointType;
  using SizeType = typename OutputFieldType::SizeType;
  using DirectionType = typename OutputFieldType::DirectionType;
 
  using RealType = typename VectorType::RealValueType;
  using RealImageType = Image<RealType, ImageDimension>;

  using PointType = typename InputPointSetType::PointType;
  using PointDataType = typename InputPointSetType::PixelType;
  using PointsContainerType = typename InputPointSetType::PointsContainer;
  using PointDataContainerType = typename InputPointSetType::PointDataContainer;

  using BSplineFilterType = BSplineScatteredDataPointSetToImageFilter<InputPointSetType, OutputFieldType>;
  using WeightsContainerType = typename BSplineFilterType::WeightsContainerType;
  using DisplacementFieldControlPointLatticeType = typename BSplineFilterType::PointDataImageType;
  using ArrayType = typename BSplineFilterType::ArrayType;

  void
  SetDisplacementField(const InputFieldType * field)
  {
    this->SetInput(0, field);
  }

  const InputFieldType *
  GetDisplacementField() const
  {
    return this->GetInput(0);
  }

  void
  SetConfidenceImage(const RealImageType * image)
  {
    this->SetNthInput(1, const_cast<RealImageType *>(image));
  }
  void
  SetInput1(const RealImageType * image)
  {
    this->SetConfidenceImage(image);
  }


  const RealImageType *
  GetConfidenceImage() const
  {
    return static_cast<const RealImageType *>(this->ProcessObject::GetInput(1));
  }

  void
  SetPointSet(const InputPointSetType * points)
  {
    this->SetNthInput(2, const_cast<InputPointSetType *>(points));
  }
  void
  SetInput2(const InputPointSetType * points)
  {
    this->SetPointSet(points);
  }


  const InputPointSetType *
  GetPointSet() const
  {
    return static_cast<const InputPointSetType *>(this->ProcessObject::GetInput(2));
  }

  void
  SetPointSetConfidenceWeights(WeightsContainerType * weights);

  const DisplacementFieldControlPointLatticeType *
  GetDisplacementFieldControlPointLattice() const
  {
    return static_cast<const DisplacementFieldControlPointLatticeType *>(this->GetOutput(1));
  }

  void
  SetBSplineDomainFromImage(RealImageType *);

  void
  SetBSplineDomainFromImage(const RealImageType * image)
  {
    this->SetBSplineDomainFromImage(const_cast<RealImageType *>(image));
  }

  void
  SetBSplineDomainFromImage(InputFieldType *);

  void
  SetBSplineDomainFromImage(const InputFieldType * field)
  {
    this->SetBSplineDomainFromImage(const_cast<InputFieldType *>(field));
  }

  void SetBSplineDomain(OriginType, SpacingType, SizeType, DirectionType);
 
  /* Set/Get b-spline domain origin. */
  itkGetConstMacro(BSplineDomainOrigin, OriginType);
 
  /* Set/Get b-spline domain spacing. */
  itkGetConstMacro(BSplineDomainSpacing, SpacingType);
 
  /* Set/Get b-spline domain size. */
  itkGetConstMacro(BSplineDomainSize, SizeType);
 
  /* Set/Get b-spline domain direction. */
  itkGetConstMacro(BSplineDomainDirection, DirectionType);
 
  /* Use input field to define the B-spline domain. */
  itkSetMacro(UseInputFieldToDefineTheBSplineDomain, bool);
  itkGetConstMacro(UseInputFieldToDefineTheBSplineDomain, bool);
  itkBooleanMacro(UseInputFieldToDefineTheBSplineDomain);

  itkSetMacro(SplineOrder, unsigned int);

  itkGetConstMacro(SplineOrder, unsigned int);

  itkSetMacro(NumberOfControlPoints, ArrayType);

  itkGetConstMacro(NumberOfControlPoints, ArrayType);

  itkSetMacro(NumberOfFittingLevels, ArrayType);

  void
  SetNumberOfFittingLevels(unsigned int n)
  {
    auto nlevels = MakeFilled<ArrayType>(n);
    this->SetNumberOfFittingLevels(nlevels);
  }

  itkGetConstMacro(NumberOfFittingLevels, ArrayType);

  itkBooleanMacro(EstimateInverse);
  itkSetMacro(EstimateInverse, bool);
  itkGetConstMacro(EstimateInverse, bool);

  itkBooleanMacro(EnforceStationaryBoundary);
  itkSetMacro(EnforceStationaryBoundary, bool);
  itkGetConstMacro(EnforceStationaryBoundary, bool);
 
protected:
  DisplacementFieldToBSplineImageFilter();

  ~DisplacementFieldToBSplineImageFilter() override = default;

  void
  PrintSelf(std::ostream & os, Indent indent) const override;

  void
  GenerateData() override;
 
private:
  bool         m_EstimateInverse{ false };
  bool         m_EnforceStationaryBoundary{ true };
  unsigned int m_SplineOrder{ 3 };
  ArrayType    m_NumberOfControlPoints{};
  ArrayType    m_NumberOfFittingLevels{};
 
  typename WeightsContainerType::Pointer m_PointWeights{};
  bool                                   m_UsePointWeights{ false };
 
  OriginType    m_BSplineDomainOrigin{};
  SpacingType   m_BSplineDomainSpacing{};
  SizeType      m_BSplineDomainSize{};
  DirectionType m_BSplineDomainDirection{};
 
  bool m_BSplineDomainIsDefined{ true };
  bool m_UseInputFieldToDefineTheBSplineDomain{ false };
};
 
} // end namespace itk
 
#ifndef ITK_MANUAL_INSTANTIATION
#  include "itkDisplacementFieldToBSplineImageFilter.hxx"
#endif
 
#endif