rtkFourDReconstructionConjugateGradientOperator.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 rtkFourDReconstructionConjugateGradientOperator_h
#define rtkFourDReconstructionConjugateGradientOperator_h

#include "rtkConjugateGradientOperator.h"

#include <itkArray2D.h>
#include <itkMultiplyImageFilter.h>

#include "rtkConstantImageSource.h"
#include "rtkInterpolatorWithKnownWeightsImageFilter.h"
#include "rtkForwardProjectionImageFilter.h"
#include "rtkSplatWithKnownWeightsImageFilter.h"
#include "rtkBackProjectionImageFilter.h"
#include "rtkThreeDCircularProjectionGeometry.h"
#include "rtkDisplacedDetectorImageFilter.h"

#ifdef RTK_USE_CUDA
#  include "rtkCudaInterpolateImageFilter.h"
#  include "rtkCudaSplatImageFilter.h"
#  include "rtkCudaConstantVolumeSource.h"
#  include "rtkCudaConstantVolumeSeriesSource.h"
#  include "rtkCudaDisplacedDetectorImageFilter.h"
#endif

namespace rtk
{
template <typename VolumeSeriesType, typename ProjectionStackType>
class ITK_TEMPLATE_EXPORT FourDReconstructionConjugateGradientOperator
  : public ConjugateGradientOperator<VolumeSeriesType>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(FourDReconstructionConjugateGradientOperator);

  using Self = FourDReconstructionConjugateGradientOperator;
  using Superclass = ConjugateGradientOperator<VolumeSeriesType>;
  using Pointer = itk::SmartPointer<Self>;

  using VolumeType = ProjectionStackType;

  itkNewMacro(Self);

#ifdef itkOverrideGetNameOfClassMacro
  itkOverrideGetNameOfClassMacro(FourDReconstructionConjugateGradientOperator);
#else
  itkTypeMacro(FourDReconstructionConjugateGradientOperator, ConjugateGradientOperator);
#endif


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

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

  using BackProjectionFilterType = BackProjectionImageFilter<ProjectionStackType, ProjectionStackType>;
  using ForwardProjectionFilterType = ForwardProjectionImageFilter<ProjectionStackType, ProjectionStackType>;
  using InterpolationFilterType = InterpolatorWithKnownWeightsImageFilter<VolumeType, VolumeSeriesType>;
  using SplatFilterType = SplatWithKnownWeightsImageFilter<VolumeSeriesType, VolumeType>;
  using ConstantVolumeSourceType = ConstantImageSource<VolumeType>;
  using ConstantProjectionStackSourceType = ConstantImageSource<ProjectionStackType>;
  using ConstantVolumeSeriesSourceType = ConstantImageSource<VolumeSeriesType>;

  using CPUProjectionStackType =
    typename itk::Image<typename ProjectionStackType::PixelType, ProjectionStackType::ImageDimension>;
#ifdef RTK_USE_CUDA
  typedef typename std::conditional<std::is_same<ProjectionStackType, CPUProjectionStackType>::value,
                                    DisplacedDetectorImageFilter<ProjectionStackType>,
                                    CudaDisplacedDetectorImageFilter>::type DisplacedDetectorFilterType;
  typedef typename std::conditional<std::is_same<ProjectionStackType, CPUProjectionStackType>::value,
                                    InterpolationFilterType,
                                    CudaInterpolateImageFilter>::type       CudaInterpolateImageFilterType;
  typedef typename std::conditional<std::is_same<ProjectionStackType, CPUProjectionStackType>::value,
                                    SplatFilterType,
                                    CudaSplatImageFilter>::type             CudaSplatImageFilterType;
  typedef typename std::conditional<std::is_same<ProjectionStackType, CPUProjectionStackType>::value,
                                    ConstantVolumeSourceType,
                                    CudaConstantVolumeSource>::type         CudaConstantVolumeSourceType;
  typedef typename std::conditional<std::is_same<ProjectionStackType, CPUProjectionStackType>::value,
                                    ConstantVolumeSeriesSourceType,
                                    CudaConstantVolumeSeriesSource>::type   CudaConstantVolumeSeriesSourceType;
#else
  using DisplacedDetectorFilterType = DisplacedDetectorImageFilter<ProjectionStackType>;
  using CudaInterpolateImageFilterType = InterpolationFilterType;
  using CudaSplatImageFilterType = SplatFilterType;
  using CudaConstantVolumeSourceType = ConstantVolumeSourceType;
  using CudaConstantVolumeSeriesSourceType = ConstantVolumeSeriesSourceType;
#endif

  void
  SetBackProjectionFilter(const typename BackProjectionFilterType::Pointer _arg);

  void
  SetForwardProjectionFilter(const typename ForwardProjectionFilterType::Pointer _arg);

  itkSetConstObjectMacro(Geometry, ThreeDCircularProjectionGeometry);

  itkSetMacro(UseCudaInterpolation, bool);
  itkGetMacro(UseCudaInterpolation, bool);
  itkSetMacro(UseCudaSplat, bool);
  itkGetMacro(UseCudaSplat, bool);
  itkSetMacro(UseCudaSources, bool);
  itkGetMacro(UseCudaSources, bool);

  itkGetMacro(Weights, itk::Array2D<float>);
  itkSetMacro(Weights, itk::Array2D<float>);

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

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

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

  void
  VerifyPreconditions() const override;

  void
  GenerateOutputInformation() override;

  void
  GenerateInputRequestedRegion() override;

  void
  GenerateData() override;

  void
  InitializeConstantSources();

  typename BackProjectionFilterType::Pointer          m_BackProjectionFilter;
  typename ForwardProjectionFilterType::Pointer       m_ForwardProjectionFilter;
  typename InterpolationFilterType::Pointer           m_InterpolationFilter;
  typename SplatFilterType::Pointer                   m_SplatFilter;
  typename ConstantVolumeSourceType::Pointer          m_ConstantVolumeSource1;
  typename ConstantVolumeSourceType::Pointer          m_ConstantVolumeSource2;
  typename ConstantProjectionStackSourceType::Pointer m_ConstantProjectionStackSource;
  typename ConstantVolumeSeriesSourceType::Pointer    m_ConstantVolumeSeriesSource;
  typename DisplacedDetectorFilterType::Pointer       m_DisplacedDetectorFilter;

  ThreeDCircularProjectionGeometry::ConstPointer m_Geometry;
  bool                                           m_UseCudaInterpolation;
  bool                                           m_UseCudaSplat;
  bool                                           m_UseCudaSources;
  itk::Array2D<float>                            m_Weights;
  std::vector<double>                            m_Signal;
  bool                                           m_DisableDisplacedDetectorFilter;
};
} // namespace rtk


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

#endif