rtkProjectionsReader.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 rtkProjectionsReader_h
#define rtkProjectionsReader_h

// ITK
#include <itkImageSource.h>
#include <itkImageIOFactory.h>
#include <itkStreamingImageFilter.h>

// RTK
#include "rtkWaterPrecorrectionImageFilter.h"
#include "rtkConditionalMedianImageFilter.h"

// Standard lib
#include <vector>
#include <string>

namespace rtk
{

template <class TOutputImage>
class ITK_TEMPLATE_EXPORT ProjectionsReader : public itk::ImageSource<TOutputImage>
{
public:
  ITK_DISALLOW_COPY_AND_MOVE(ProjectionsReader);

  using Self = ProjectionsReader;
  using Superclass = itk::ImageSource<TOutputImage>;
  using Pointer = itk::SmartPointer<Self>;

  itkNewMacro(Self);

#ifdef itkOverrideGetNameOfClassMacro
  itkOverrideGetNameOfClassMacro(ProjectionsReader);
#else
  itkTypeMacro(ProjectionsReader, itk::ImageSource);
#endif


  using OutputImageType = TOutputImage;
  using OutputImagePointer = typename OutputImageType::Pointer;
  using OutputImageRegionType = typename OutputImageType::RegionType;
  using OutputImagePixelType = typename OutputImageType::PixelType;
  using OutputImageDirectionType = typename OutputImageType::DirectionType;
  using OutputImageSpacingType = typename OutputImageType::SpacingType;
  using OutputImagePointType = typename OutputImageType::PointType;
  using OutputImageSizeType = typename OutputImageType::SizeType;

  using FileNamesContainer = std::vector<std::string>;
  using ShrinkFactorsType = itk::FixedArray<unsigned int, TOutputImage::ImageDimension>;
  using MedianRadiusType = typename rtk::ConditionalMedianImageFilter<TOutputImage>::MedianRadiusType;
  using WaterPrecorrectionVectorType = std::vector<double>;

  using WaterPrecorrectionType = rtk::WaterPrecorrectionImageFilter<TOutputImage, TOutputImage>;
  using StreamingType = itk::StreamingImageFilter<TOutputImage, TOutputImage>;

  static constexpr unsigned int OutputImageDimension = TOutputImage::ImageDimension;

  void
  SetFileNames(const FileNamesContainer & name)
  {
    if (m_FileNames != name)
    {
      m_FileNames = name;
      this->Modified();
    }
  }
  const FileNamesContainer &
  GetFileNames() const
  {
    return m_FileNames;
  }

  itkSetMacro(Origin, OutputImagePointType);
  itkGetConstMacro(Origin, OutputImagePointType);

  itkSetMacro(Spacing, OutputImageSpacingType);
  itkGetConstMacro(Spacing, OutputImageSpacingType);

  itkSetMacro(Direction, OutputImageDirectionType);
  itkGetConstMacro(Direction, OutputImageDirectionType);

  itkSetMacro(UpperBoundaryCropSize, OutputImageSizeType);
  itkGetConstMacro(UpperBoundaryCropSize, OutputImageSizeType);
  itkSetMacro(LowerBoundaryCropSize, OutputImageSizeType);
  itkGetConstMacro(LowerBoundaryCropSize, OutputImageSizeType);

  itkSetMacro(ShrinkFactors, ShrinkFactorsType);
  itkGetConstReferenceMacro(ShrinkFactors, ShrinkFactorsType);

  itkSetMacro(MedianRadius, MedianRadiusType);
  itkGetConstReferenceMacro(MedianRadius, MedianRadiusType);
  itkGetMacro(ConditionalMedianThresholdMultiplier, double);
  itkSetMacro(ConditionalMedianThresholdMultiplier, double);

  itkGetMacro(AirThreshold, double);
  itkSetMacro(AirThreshold, double);

  itkGetMacro(ScatterToPrimaryRatio, double);
  itkSetMacro(ScatterToPrimaryRatio, double);

  itkGetMacro(NonNegativityConstraintThreshold, double);
  itkSetMacro(NonNegativityConstraintThreshold, double);

  itkGetMacro(I0, double);
  itkSetMacro(I0, double);

  itkGetMacro(IDark, double);
  itkSetMacro(IDark, double);

  itkGetMacro(WaterPrecorrectionCoefficients, WaterPrecorrectionVectorType);
  virtual void
  SetWaterPrecorrectionCoefficients(const WaterPrecorrectionVectorType _arg)
  {
    if (this->m_WaterPrecorrectionCoefficients != _arg)
    {
      this->m_WaterPrecorrectionCoefficients = _arg;
      this->Modified();
    }
  }

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

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

  itkSetObjectMacro(ImageIO, itk::ImageIOBase);
  itkGetConstObjectMacro(ImageIO, itk::ImageIOBase);

  void
  GenerateOutputInformation() override;

protected:
  ProjectionsReader();
  ~ProjectionsReader() override = default;
  void
  PrintSelf(std::ostream & os, itk::Indent indent) const override;

  void
  GenerateData() override;

  FileNamesContainer m_FileNames;

private:
  template <class TInputImage>
  void
  PropagateParametersToMiniPipeline();
  void
  ConnectElektaRawFilter(itk::ImageBase<OutputImageDimension> ** nextInputBase);
  void
  PropagateI0(itk::ImageBase<OutputImageDimension> ** nextInputBase);

  itk::ProcessObject::Pointer m_RawDataReader;

  itk::ProcessObject::Pointer m_VectorComponentSelectionFilter;
  itk::ProcessObject::Pointer m_ChangeInformationFilter;
  itk::ProcessObject::Pointer m_ElektaRawFilter;
  itk::ProcessObject::Pointer m_CropFilter;
  itk::ProcessObject::Pointer m_ConditionalMedianFilter;
  itk::ProcessObject::Pointer m_BinningFilter;
  itk::ProcessObject::Pointer m_ScatterFilter;
  itk::ProcessObject::Pointer m_I0EstimationFilter;

  typename itk::ImageSource<TOutputImage>::Pointer m_RawToAttenuationFilter;

  typename itk::ImageSource<TOutputImage>::Pointer m_RawCastFilter;

  typename WaterPrecorrectionType::Pointer m_WaterPrecorrectionFilter;
  typename StreamingType::Pointer          m_StreamingFilter;

  itk::ImageIOBase::Pointer m_ImageIO{ nullptr };

  OutputImagePointType         m_Origin;
  OutputImageSpacingType       m_Spacing;
  OutputImageDirectionType     m_Direction;
  OutputImageSizeType          m_LowerBoundaryCropSize;
  OutputImageSizeType          m_UpperBoundaryCropSize;
  ShrinkFactorsType            m_ShrinkFactors;
  MedianRadiusType             m_MedianRadius;
  double                       m_AirThreshold{ 32000 };
  double                       m_ScatterToPrimaryRatio{ 0. };
  double                       m_NonNegativityConstraintThreshold{ itk::NumericTraits<double>::NonpositiveMin() };
  double                       m_I0{ itk::NumericTraits<double>::NonpositiveMin() };
  double                       m_IDark{ 0. };
  double                       m_ConditionalMedianThresholdMultiplier{ 1. };
  WaterPrecorrectionVectorType m_WaterPrecorrectionCoefficients;
  bool                         m_ComputeLineIntegral{ true };
  unsigned int                 m_VectorComponent{ 0 };
};

} // namespace rtk

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

#endif // rtkProjectionsReader_h