rtkProjectionStackToFourDImageFilter.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 rtkProjectionStackToFourDImageFilter_h
#define rtkProjectionStackToFourDImageFilter_h

#include <itkExtractImageFilter.h>
#include <itkArray2D.h>

#include "rtkBackProjectionImageFilter.h"
#include "rtkSplatWithKnownWeightsImageFilter.h"
#include "rtkConstantImageSource.h"
#include "rtkThreeDCircularProjectionGeometry.h"

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

namespace rtk
{
template <typename VolumeSeriesType, typename ProjectionStackType, typename TFFTPrecision = double>
class ITK_TEMPLATE_EXPORT ProjectionStackToFourDImageFilter
  : public itk::ImageToImageFilter<VolumeSeriesType, VolumeSeriesType>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ProjectionStackToFourDImageFilter);

  using Self = ProjectionStackToFourDImageFilter;
  using Superclass = itk::ImageToImageFilter<VolumeSeriesType, VolumeSeriesType>;
  using Pointer = itk::SmartPointer<Self>;

  using VolumeType = ProjectionStackType;

  itkNewMacro(Self);

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


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

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

  using BackProjectionFilterType = rtk::BackProjectionImageFilter<VolumeType, VolumeType>;
  using ExtractFilterType = itk::ExtractImageFilter<ProjectionStackType, ProjectionStackType>;
  using ConstantVolumeSourceType = rtk::ConstantImageSource<VolumeType>;
  using ConstantVolumeSeriesSourceType = rtk::ConstantImageSource<VolumeSeriesType>;
  using SplatFilterType = rtk::SplatWithKnownWeightsImageFilter<VolumeSeriesType, VolumeType>;

  using GeometryType = rtk::ThreeDCircularProjectionGeometry;

  using CPUVolumeSeriesType =
    typename itk::Image<typename VolumeSeriesType::PixelType, VolumeSeriesType::ImageDimension>;
#ifdef RTK_USE_CUDA
  typedef typename std::conditional<std::is_same<VolumeSeriesType, CPUVolumeSeriesType>::value,
                                    SplatFilterType,
                                    CudaSplatImageFilter>::type           CudaSplatImageFilterType;
  typedef typename std::conditional<std::is_same<VolumeSeriesType, CPUVolumeSeriesType>::value,
                                    ConstantVolumeSourceType,
                                    CudaConstantVolumeSource>::type       CudaConstantVolumeSourceType;
  typedef typename std::conditional<std::is_same<VolumeSeriesType, CPUVolumeSeriesType>::value,
                                    ConstantVolumeSeriesSourceType,
                                    CudaConstantVolumeSeriesSource>::type CudaConstantVolumeSeriesSourceType;
#else
  using CudaSplatImageFilterType = SplatFilterType;
  using CudaConstantVolumeSourceType = ConstantVolumeSourceType;
  using CudaConstantVolumeSeriesSourceType = ConstantVolumeSeriesSourceType;
#endif

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

  itkSetConstObjectMacro(Geometry, GeometryType);

  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);

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

  void
  VerifyPreconditions() const override;

  void
  GenerateData() override;

  void
  GenerateOutputInformation() override;

  void
  GenerateInputRequestedRegion() override;

  void
  InitializeConstantSource();

  typename SplatFilterType::Pointer                m_SplatFilter;
  typename BackProjectionFilterType::Pointer       m_BackProjectionFilter;
  typename ExtractFilterType::Pointer              m_ExtractFilter;
  typename ConstantVolumeSourceType::Pointer       m_ConstantVolumeSource;
  typename ConstantVolumeSeriesSourceType::Pointer m_ConstantVolumeSeriesSource;

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


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

#endif