rtkFourDConjugateGradientConeBeamReconstructionFilter.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 rtkFourDConjugateGradientConeBeamReconstructionFilter_h
#define rtkFourDConjugateGradientConeBeamReconstructionFilter_h

#include "rtkBackProjectionImageFilter.h"
#include "rtkForwardProjectionImageFilter.h"
#include "rtkIterativeConeBeamReconstructionFilter.h"
#include "rtkConjugateGradientImageFilter.h"
#include "rtkFourDReconstructionConjugateGradientOperator.h"
#include "rtkProjectionStackToFourDImageFilter.h"
#include "rtkDisplacedDetectorImageFilter.h"

#include <itkExtractImageFilter.h>
#include <itkSubtractImageFilter.h>
#include <itkMultiplyImageFilter.h>
#include <itkIterationReporter.h>
#ifdef RTK_USE_CUDA
#  include "rtkCudaConjugateGradientImageFilter.h"
#endif

namespace rtk
{

template <typename VolumeSeriesType, typename ProjectionStackType>
class ITK_TEMPLATE_EXPORT FourDConjugateGradientConeBeamReconstructionFilter
  : public rtk::IterativeConeBeamReconstructionFilter<VolumeSeriesType, ProjectionStackType>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(FourDConjugateGradientConeBeamReconstructionFilter);

  using Self = FourDConjugateGradientConeBeamReconstructionFilter;
  using Superclass = IterativeConeBeamReconstructionFilter<VolumeSeriesType, ProjectionStackType>;
  using Pointer = itk::SmartPointer<Self>;
  using ConstPointer = itk::SmartPointer<const Self>;

  using InputImageType = VolumeSeriesType;
  using OutputImageType = VolumeSeriesType;
  using VolumeType = ProjectionStackType;

  using ForwardProjectionFilterType = ForwardProjectionImageFilter<VolumeType, ProjectionStackType>;
  using BackProjectionFilterType = BackProjectionImageFilter<ProjectionStackType, VolumeType>;
  using ConjugateGradientFilterType = ConjugateGradientImageFilter<VolumeSeriesType>;
  using CGOperatorFilterType = FourDReconstructionConjugateGradientOperator<VolumeSeriesType, ProjectionStackType>;
  using ProjStackToFourDFilterType = ProjectionStackToFourDImageFilter<VolumeSeriesType, ProjectionStackType>;
  using DisplacedDetectorFilterType = DisplacedDetectorImageFilter<ProjectionStackType>;

  using ForwardProjectionType = typename Superclass::ForwardProjectionType;
  using BackProjectionType = typename Superclass::BackProjectionType;

  using CPUVolumeSeriesType =
    typename itk::Image<typename VolumeSeriesType::PixelType, VolumeSeriesType::ImageDimension>;
#ifdef RTK_USE_CUDA
  typedef typename std::conditional<std::is_same<VolumeSeriesType, CPUVolumeSeriesType>::value,
                                    ConjugateGradientImageFilter<VolumeSeriesType>,
                                    CudaConjugateGradientImageFilter<VolumeSeriesType>>::type
    CudaConjugateGradientImageFilterType;
#else
  using CudaConjugateGradientImageFilterType = ConjugateGradientImageFilter<VolumeSeriesType>;
#endif

  itkNewMacro(Self);

#ifdef itkOverrideGetNameOfClassMacro
  itkOverrideGetNameOfClassMacro(FourDConjugateGradientConeBeamReconstructionFilter);
#else
  itkTypeMacro(FourDConjugateGradientConeBeamReconstructionFilter, itk::ImageToImageFilter);
#endif


  itkGetConstObjectMacro(Geometry, ThreeDCircularProjectionGeometry);
  itkSetConstObjectMacro(Geometry, ThreeDCircularProjectionGeometry);

  itkGetMacro(NumberOfIterations, unsigned int);
  itkSetMacro(NumberOfIterations, unsigned int);

  itkGetMacro(CudaConjugateGradient, bool);
  itkSetMacro(CudaConjugateGradient, bool);

  void
  SetInputVolumeSeries(const VolumeSeriesType * VolumeSeries);
  typename VolumeSeriesType::ConstPointer
  GetInputVolumeSeries();

  void
  SetInputProjectionStack(const ProjectionStackType * Projections);
  typename ProjectionStackType::ConstPointer
  GetInputProjectionStack();

  void
  SetWeights(const itk::Array2D<float> _arg);

  virtual void
  SetSignal(const std::vector<double> signal);

  itkSetMacro(DisableDisplacedDetectorFilter, bool);
  itkGetMacro(DisableDisplacedDetectorFilter, bool);

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

  void
  VerifyPreconditions() const override;

  void
  GenerateOutputInformation() override;

  void
  GenerateInputRequestedRegion() override;

  void
  GenerateData() override;

  void
  VerifyInputInformation() const override
  {}

  typename ForwardProjectionFilterType::Pointer m_ForwardProjectionFilter;
  typename BackProjectionFilterType::Pointer    m_BackProjectionFilter;
  typename BackProjectionFilterType::Pointer    m_BackProjectionFilterForB;
  typename ConjugateGradientFilterType::Pointer m_ConjugateGradientFilter;
  typename CGOperatorFilterType::Pointer        m_CGOperator;
  typename ProjStackToFourDFilterType::Pointer  m_ProjStackToFourDFilter;
  typename DisplacedDetectorFilterType::Pointer m_DisplacedDetectorFilter;

  bool                m_CudaConjugateGradient;
  std::vector<double> m_Signal;
  bool                m_DisableDisplacedDetectorFilter;

  // Iteration reporting
  itk::IterationReporter m_IterationReporter;

private:
  ThreeDCircularProjectionGeometry::ConstPointer m_Geometry;

  unsigned int m_NumberOfIterations;

  void
  ReportProgress(itk::Object *, const itk::EventObject &);

}; // end of class

} // end namespace rtk

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

#endif