ENH: Use RebindImageType to replace manual itk::Image vs itk::CudaImage selection

axel-grc · SimonRit · commit cacffcb2c402 · 2025-10-13T00:48:16.000+02:00
diff --git a/.github/workflows/build-test-cxx-cuda.yml b/.github/workflows/build-test-cxx-cuda.yml
@@ -4,7 +4,7 @@ on: [push,pull_request]
 
 env:
   itk-git-tag: "v5.4.4"
-  itk-module-deps: "CudaCommon@8baef219d19d8f320898c3c649539bbb5ba3f509"
+  itk-module-deps: "CudaCommon@main"
 
 concurrency:
   group: '${{ github.workflow }}@${{ github.head_ref || github.run_id }}'
diff --git a/include/rtkADMMTotalVariationConeBeamReconstructionFilter.h b/include/rtkADMMTotalVariationConeBeamReconstructionFilter.h
@@ -158,14 +158,8 @@ class ITK_TEMPLATE_EXPORT ADMMTotalVariationConeBeamReconstructionFilter
   using BackProjectionFilterPointer = typename BackProjectionFilterType::Pointer;
   using ConjugateGradientFilterType = rtk::ConjugateGradientImageFilter<TOutputImage>;
   using VectorPixelType = itk::CovariantVector<typename TOutputImage::ValueType, TOutputImage::ImageDimension>;
-  using CPUImageType = itk::Image<typename TOutputImage::PixelType, TOutputImage::ImageDimension>;
-#ifdef RTK_USE_CUDA
-  using GradientImageType = typename std::conditional_t<std::is_same_v<TOutputImage, CPUImageType>,
-                                                        itk::Image<VectorPixelType, TOutputImage::ImageDimension>,
-                                                        itk::CudaImage<VectorPixelType, TOutputImage::ImageDimension>>;
-#else
-  using GradientImageType = itk::Image<VectorPixelType, TOutputImage::ImageDimension>;
-#endif
+  using GradientImageType =
+    typename TOutputImage::template RebindImageType<VectorPixelType, TOutputImage::ImageDimension>;
   using ImageGradientFilterType = ForwardDifferenceGradientImageFilter<TOutputImage,
                                                                        typename TOutputImage::ValueType,
                                                                        typename TOutputImage::ValueType,
diff --git a/include/rtkADMMTotalVariationConjugateGradientOperator.h b/include/rtkADMMTotalVariationConjugateGradientOperator.h
@@ -31,10 +31,6 @@
 #include "rtkMultiplyByVectorImageFilter.h"
 #include "rtkThreeDCircularProjectionGeometry.h"
 
-#ifdef RTK_USE_CUDA
-#  include <itkCudaImage.h>
-#endif
-
 namespace rtk
 {
 
@@ -131,14 +127,8 @@ class ITK_TEMPLATE_EXPORT ADMMTotalVariationConjugateGradientOperator : public C
   using SubtractFilterType = itk::SubtractImageFilter<TOutputImage>;
 
   using VectorPixelType = itk::CovariantVector<typename TOutputImage::ValueType, TOutputImage::ImageDimension>;
-  using CPUImageType = itk::Image<typename TOutputImage::PixelType, TOutputImage::ImageDimension>;
-#ifdef RTK_USE_CUDA
-  using GradientImageType = typename std::conditional_t<std::is_same_v<TOutputImage, CPUImageType>,
-                                                        itk::Image<VectorPixelType, TOutputImage::ImageDimension>,
-                                                        itk::CudaImage<VectorPixelType, TOutputImage::ImageDimension>>;
-#else
-  using GradientImageType = itk::Image<VectorPixelType, TOutputImage::ImageDimension>;
-#endif
+  using GradientImageType =
+    typename TOutputImage::template RebindImageType<VectorPixelType, TOutputImage::ImageDimension>;
 
   using GradientFilterType = ForwardDifferenceGradientImageFilter<TOutputImage,
                                                                   typename TOutputImage::ValueType,
diff --git a/include/rtkFourDROOSTERConeBeamReconstructionFilter.h b/include/rtkFourDROOSTERConeBeamReconstructionFilter.h
@@ -219,42 +219,33 @@ class ITK_TEMPLATE_EXPORT FourDROOSTERConeBeamReconstructionFilter
     itk::CovariantVector<typename VolumeSeriesType::ValueType, VolumeSeriesType::ImageDimension - 1>;
   using CovariantVectorForTemporalGradient = itk::CovariantVector<typename VolumeSeriesType::ValueType, 1>;
   using DVFVectorType = CovariantVectorForSpatialGradient;
-
-  /** SFINAE type alias, depending on whether a CUDA image is used. */
   using CPUVolumeSeriesType =
     typename itk::Image<typename VolumeSeriesType::PixelType, VolumeSeriesType::ImageDimension>;
-#ifdef RTK_USE_CUDA
+
   using SpatialGradientImageType =
-    typename std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
-                                itk::Image<CovariantVectorForSpatialGradient, VolumeSeriesType::ImageDimension>,
-                                itk::CudaImage<CovariantVectorForSpatialGradient, VolumeSeriesType::ImageDimension>>;
+    typename VolumeSeriesType::template RebindImageType<CovariantVectorForSpatialGradient,
+                                                        VolumeSeriesType::ImageDimension>;
   using TemporalGradientImageType =
-    typename std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
-                                itk::Image<CovariantVectorForTemporalGradient, VolumeSeriesType::ImageDimension>,
-                                itk::CudaImage<CovariantVectorForTemporalGradient, VolumeSeriesType::ImageDimension>>;
+    typename VolumeSeriesType::template RebindImageType<CovariantVectorForTemporalGradient,
+                                                        VolumeSeriesType::ImageDimension>;
+
   using DVFSequenceImageType =
-    typename std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
-                                itk::Image<DVFVectorType, VolumeSeriesType::ImageDimension>,
-                                itk::CudaImage<DVFVectorType, VolumeSeriesType::ImageDimension>>;
-  using DVFImageType = typename std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
-                                                   itk::Image<DVFVectorType, VolumeSeriesType::ImageDimension - 1>,
-                                                   itk::CudaImage<DVFVectorType, VolumeSeriesType::ImageDimension - 1>>;
-  using AverageOutOfROIFilterType =
-    typename std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
-                                AverageOutOfROIImageFilter<VolumeSeriesType, VolumeType>,
-                                CudaAverageOutOfROIImageFilter>;
+    typename VolumeSeriesType::template RebindImageType<DVFVectorType, VolumeSeriesType::ImageDimension>;
+  using DVFImageType =
+    typename VolumeSeriesType::template RebindImageType<DVFVectorType, VolumeSeriesType::ImageDimension - 1>;
+
+#ifdef RTK_USE_CUDA
+  using AverageOutOfROIFilterType = std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
+                                                       AverageOutOfROIImageFilter<VolumeSeriesType, VolumeType>,
+                                                       CudaAverageOutOfROIImageFilter>;
   using TemporalTVDenoisingFilterType =
-    typename std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
-                                TotalVariationDenoisingBPDQImageFilter<VolumeSeriesType, TemporalGradientImageType>,
-                                CudaLastDimensionTVDenoisingImageFilter>;
+    std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
+                       TotalVariationDenoisingBPDQImageFilter<VolumeSeriesType, TemporalGradientImageType>,
+                       CudaLastDimensionTVDenoisingImageFilter>;
 #else
-  using SpatialGradientImageType = itk::Image<CovariantVectorForSpatialGradient, VolumeSeriesType::ImageDimension>;
-  using TemporalGradientImageType = itk::Image<CovariantVectorForTemporalGradient, VolumeSeriesType::ImageDimension>;
-  using DVFSequenceImageType = itk::Image<DVFVectorType, VolumeSeriesType::ImageDimension>;
-  using DVFImageType = itk::Image<DVFVectorType, VolumeSeriesType::ImageDimension - 1>;
-  using AverageOutOfROIFilterType = AverageOutOfROIImageFilter<VolumeSeriesType, VolumeType>;
+  using AverageOutOfROIFilterType = rtk::AverageOutOfROIImageFilter<VolumeSeriesType, VolumeType>;
   using TemporalTVDenoisingFilterType =
-    TotalVariationDenoisingBPDQImageFilter<VolumeSeriesType, TemporalGradientImageType>;
+    rtk::TotalVariationDenoisingBPDQImageFilter<VolumeSeriesType, TemporalGradientImageType>;
 #endif
 
   /** Method for creation through the object factory. */
diff --git a/include/rtkLaplacianImageFilter.h b/include/rtkLaplacianImageFilter.h
@@ -23,10 +23,6 @@
 #include "rtkBackwardDifferenceDivergenceImageFilter.h"
 #include "itkMultiplyImageFilter.h"
 
-#ifdef RTK_USE_CUDA
-#  include <itkCudaImage.h>
-#endif
-
 namespace rtk
 {
 
@@ -53,16 +49,9 @@ class ITK_TEMPLATE_EXPORT LaplacianImageFilter : public itk::ImageToImageFilter<
   using Superclass = itk::ImageToImageFilter<TOutputImage, TOutputImage>;
   using Pointer = itk::SmartPointer<Self>;
   using OutputImagePointer = typename TOutputImage::Pointer;
-  using CPUImageType = itk::Image<typename TOutputImage::PixelType, TOutputImage::ImageDimension>;
   using VectorPixelType = itk::CovariantVector<typename TOutputImage::ValueType, TOutputImage::ImageDimension>;
-
-#ifdef RTK_USE_CUDA
-  using GradientImageType = typename std::conditional_t<std::is_same_v<TOutputImage, CPUImageType>,
-                                                        itk::Image<VectorPixelType, TOutputImage::ImageDimension>,
-                                                        itk::CudaImage<VectorPixelType, TOutputImage::ImageDimension>>;
-#else
-  using GradientImageType = itk::Image<VectorPixelType, TOutputImage::ImageDimension>;
-#endif
+  using GradientImageType =
+    typename TOutputImage::template RebindImageType<VectorPixelType, TOutputImage::ImageDimension>;
   using GradientFilterType = rtk::ForwardDifferenceGradientImageFilter<TOutputImage,
                                                                        typename TOutputImage::ValueType,
                                                                        typename TOutputImage::ValueType,
diff --git a/include/rtkMechlemOneStepSpectralReconstructionFilter.h b/include/rtkMechlemOneStepSpectralReconstructionFilter.h
@@ -179,19 +179,11 @@ class ITK_TEMPLATE_EXPORT MechlemOneStepSpectralReconstructionFilter
 
   /** SFINAE type alias, depending on whether a CUDA image is used. */
   using CPUOutputImageType = typename itk::Image<typename TOutputImage::PixelType, TOutputImage::ImageDimension>;
-#ifdef RTK_USE_CUDA
-  using HessiansImageType = typename std::conditional_t<
-    std::is_same_v<TOutputImage, CPUOutputImageType>,
-    itk::Image<itk::Vector<dataType, nMaterials * nMaterials>, TOutputImage::ImageDimension>,
-    itk::CudaImage<itk::Vector<dataType, nMaterials * nMaterials>, TOutputImage::ImageDimension>>;
-  using SingleComponentImageType = typename std::conditional_t<std::is_same_v<TOutputImage, CPUOutputImageType>,
-                                                               itk::Image<dataType, TOutputImage::ImageDimension>,
-                                                               itk::CudaImage<dataType, TOutputImage::ImageDimension>>;
-#else
   using HessiansImageType =
-    typename itk::Image<itk::Vector<dataType, nMaterials * nMaterials>, TOutputImage::ImageDimension>;
-  using SingleComponentImageType = typename itk::Image<dataType, TOutputImage::ImageDimension>;
-#endif
+    typename TOutputImage::template RebindImageType<itk::Vector<dataType, nMaterials * nMaterials>,
+                                                    TOutputImage::ImageDimension>;
+  using SingleComponentImageType =
+    typename TOutputImage::template RebindImageType<dataType, TOutputImage::ImageDimension>;
 
 #if !defined(ITK_WRAPPING_PARSER)
 #  ifdef RTK_USE_CUDA
diff --git a/include/rtkMotionCompensatedFourDConjugateGradientConeBeamReconstructionFilter.h b/include/rtkMotionCompensatedFourDConjugateGradientConeBeamReconstructionFilter.h
@@ -87,22 +87,10 @@ class ITK_TEMPLATE_EXPORT MotionCompensatedFourDConjugateGradientConeBeamReconst
 
   using ForwardProjectionType = typename Superclass::ForwardProjectionType;
   using BackProjectionType = typename Superclass::BackProjectionType;
-
-  /** SFINAE type alias, depending on whether a CUDA image is used. */
-  using CPUVolumeSeriesType =
-    typename itk::Image<typename VolumeSeriesType::PixelType, VolumeSeriesType::ImageDimension>;
-#ifdef RTK_USE_CUDA
   using DVFSequenceImageType =
-    typename std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
-                                itk::Image<VectorForDVF, VolumeSeriesType::ImageDimension>,
-                                itk::CudaImage<VectorForDVF, VolumeSeriesType::ImageDimension>>;
-  using DVFImageType = typename std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
-                                                   itk::Image<VectorForDVF, VolumeSeriesType::ImageDimension - 1>,
-                                                   itk::CudaImage<VectorForDVF, VolumeSeriesType::ImageDimension - 1>>;
-#else
-  using DVFSequenceImageType = itk::Image<VectorForDVF, VolumeSeriesType::ImageDimension>;
-  using DVFImageType = itk::Image<VectorForDVF, VolumeSeriesType::ImageDimension - 1>;
-#endif
+    typename VolumeSeriesType::template RebindImageType<VectorForDVF, VolumeSeriesType::ImageDimension>;
+  using DVFImageType =
+    typename VolumeSeriesType::template RebindImageType<VectorForDVF, VolumeSeriesType::ImageDimension - 1>;
 
   /** Typedefs of each subfilter of this composite filter */
 
diff --git a/include/rtkMotionCompensatedFourDROOSTERConeBeamReconstructionFilter.h b/include/rtkMotionCompensatedFourDROOSTERConeBeamReconstructionFilter.h
@@ -154,19 +154,16 @@ class ITK_TEMPLATE_EXPORT MotionCompensatedFourDROOSTERConeBeamReconstructionFil
 
   using ForwardProjectionType = typename Superclass::ForwardProjectionType;
   using BackProjectionType = typename Superclass::BackProjectionType;
-
-#ifdef RTK_USE_CUDA
-  using SpatialGradientImageType = itk::CudaImage<CovariantVectorForSpatialGradient, VolumeSeriesType::ImageDimension>;
+  using SpatialGradientImageType =
+    typename VolumeSeriesType::template RebindImageType<CovariantVectorForSpatialGradient,
+                                                        VolumeSeriesType::ImageDimension>;
   using TemporalGradientImageType =
-    itk::CudaImage<CovariantVectorForTemporalGradient, VolumeSeriesType::ImageDimension>;
-  using DVFSequenceImageType = itk::CudaImage<DVFVectorType, VolumeSeriesType::ImageDimension>;
-  using DVFImageType = itk::CudaImage<DVFVectorType, VolumeSeriesType::ImageDimension - 1>;
-#else
-  using SpatialGradientImageType = itk::Image<CovariantVectorForSpatialGradient, VolumeSeriesType::ImageDimension>;
-  using TemporalGradientImageType = itk::Image<CovariantVectorForTemporalGradient, VolumeSeriesType::ImageDimension>;
-  using DVFSequenceImageType = itk::Image<DVFVectorType, VolumeSeriesType::ImageDimension>;
-  using DVFImageType = itk::Image<DVFVectorType, VolumeSeriesType::ImageDimension - 1>;
-#endif
+    typename VolumeSeriesType::template RebindImageType<CovariantVectorForTemporalGradient,
+                                                        VolumeSeriesType::ImageDimension>;
+  using DVFSequenceImageType =
+    typename VolumeSeriesType::template RebindImageType<DVFVectorType, VolumeSeriesType::ImageDimension>;
+  using DVFImageType =
+    typename VolumeSeriesType::template RebindImageType<DVFVectorType, VolumeSeriesType::ImageDimension - 1>;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self);
diff --git a/include/rtkMotionCompensatedFourDReconstructionConjugateGradientOperator.h b/include/rtkMotionCompensatedFourDReconstructionConjugateGradientOperator.h
@@ -115,14 +115,11 @@ class ITK_TEMPLATE_EXPORT MotionCompensatedFourDReconstructionConjugateGradientO
   /** SFINAE type alias, depending on whether a CUDA image is used. */
   using CPUVolumeSeriesType =
     typename itk::Image<typename VolumeSeriesType::PixelType, VolumeSeriesType::ImageDimension>;
-#ifdef RTK_USE_CUDA
   using DVFSequenceImageType =
-    typename std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
-                                itk::Image<VectorForDVF, VolumeSeriesType::ImageDimension>,
-                                itk::CudaImage<VectorForDVF, VolumeSeriesType::ImageDimension>>;
-  using DVFImageType = typename std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
-                                                   itk::Image<VectorForDVF, VolumeSeriesType::ImageDimension - 1>,
-                                                   itk::CudaImage<VectorForDVF, VolumeSeriesType::ImageDimension - 1>>;
+    typename VolumeSeriesType::template RebindImageType<VectorForDVF, VolumeSeriesType::ImageDimension>;
+  using DVFImageType =
+    typename VolumeSeriesType::template RebindImageType<VectorForDVF, VolumeSeriesType::ImageDimension - 1>;
+#ifdef RTK_USE_CUDA
   using WarpForwardProjectionImageFilterType =
     typename std::conditional_t<std::is_same_v<VolumeSeriesType, CPUVolumeSeriesType>,
                                 JosephForwardProjectionImageFilter<ProjectionStackType, ProjectionStackType>,
@@ -132,8 +129,6 @@ class ITK_TEMPLATE_EXPORT MotionCompensatedFourDReconstructionConjugateGradientO
                                 BackProjectionImageFilter<VolumeType, VolumeType>,
                                 CudaWarpBackProjectionImageFilter>;
 #else
-  using DVFSequenceImageType = itk::Image<VectorForDVF, VolumeSeriesType::ImageDimension>;
-  using DVFImageType = itk::Image<VectorForDVF, VolumeSeriesType::ImageDimension - 1>;
   using WarpForwardProjectionImageFilterType =
     JosephForwardProjectionImageFilter<ProjectionStackType, ProjectionStackType>;
   using WarpBackProjectionImageFilterType = BackProjectionImageFilter<VolumeType, VolumeType>;
diff --git a/include/rtkReconstructionConjugateGradientOperator.h b/include/rtkReconstructionConjugateGradientOperator.h
@@ -124,15 +124,9 @@ class ITK_TEMPLATE_EXPORT ReconstructionConjugateGradientOperator : public Conju
   using Self = ReconstructionConjugateGradientOperator;
   using Superclass = ConjugateGradientOperator<TOutputImage>;
   using Pointer = itk::SmartPointer<Self>;
-#ifdef RTK_USE_CUDA
-  using GradientImageType =
-    itk::CudaImage<itk::CovariantVector<typename TOutputImage::PixelType, TOutputImage::ImageDimension>,
-                   TOutputImage::ImageDimension>;
-#else
+  using VectorPixelType = itk::CovariantVector<typename TOutputImage::ValueType, TOutputImage::ImageDimension>;
   using GradientImageType =
-    itk::Image<itk::CovariantVector<typename TOutputImage::PixelType, TOutputImage::ImageDimension>,
-               TOutputImage::ImageDimension>;
-#endif
+    typename TOutputImage::template RebindImageType<VectorPixelType, TOutputImage::ImageDimension>;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self);
diff --git a/include/rtkRegularizedConjugateGradientConeBeamReconstructionFilter.h b/include/rtkRegularizedConjugateGradientConeBeamReconstructionFilter.h
@@ -115,13 +115,8 @@ class ITK_TEMPLATE_EXPORT RegularizedConjugateGradientConeBeamReconstructionFilt
   using Superclass = rtk::IterativeConeBeamReconstructionFilter<TImage, TImage>;
   using Pointer = itk::SmartPointer<Self>;
   using CovariantVectorForSpatialGradient = itk::CovariantVector<typename TImage::ValueType, TImage::ImageDimension>;
-
-#ifdef RTK_USE_CUDA
-  using GradientImageType = itk::CudaImage<CovariantVectorForSpatialGradient, TImage::ImageDimension>;
-#else
-  using GradientImageType = itk::Image<CovariantVectorForSpatialGradient, TImage::ImageDimension>;
-#endif
-
+  using GradientImageType =
+    typename TImage::template RebindImageType<CovariantVectorForSpatialGradient, TImage::ImageDimension>;
   using ForwardProjectionType = typename Superclass::ForwardProjectionType;
   using BackProjectionType = typename Superclass::BackProjectionType;
 
diff --git a/include/rtkTotalVariationDenoiseSequenceImageFilter.h b/include/rtkTotalVariationDenoiseSequenceImageFilter.h
@@ -105,16 +105,13 @@ class ITK_TEMPLATE_EXPORT TotalVariationDenoiseSequenceImageFilter
 
   /** SFINAE type alias, depending on whether a CUDA image is used. */
   using CPUImageSequenceType = typename itk::Image<typename TImageSequence::PixelType, TImageSequence::ImageDimension>;
+  using ImageType = typename TImageSequence::template RebindImageType<typename TImageSequence::PixelType,
+                                                                      TImageSequence::ImageDimension - 1>;
 #ifdef RTK_USE_CUDA
-  using ImageType =
-    typename std::conditional_t<std::is_same_v<TImageSequence, CPUImageSequenceType>,
-                                itk::Image<typename TImageSequence::PixelType, TImageSequence::ImageDimension - 1>,
-                                itk::CudaImage<typename TImageSequence::PixelType, TImageSequence::ImageDimension - 1>>;
   using TVDenoisingFilterType = typename std::conditional_t<std::is_same_v<TImageSequence, CPUImageSequenceType>,
                                                             TotalVariationDenoisingBPDQImageFilter<ImageType>,
                                                             CudaTotalVariationDenoisingBPDQImageFilter>;
 #else
-  using ImageType = itk::Image<typename TImageSequence::PixelType, TImageSequence::ImageDimension - 1>;
   using TVDenoisingFilterType = rtk::TotalVariationDenoisingBPDQImageFilter<ImageType>;
 #endif
   using ExtractFilterType = itk::ExtractImageFilter<TImageSequence, ImageType>;
diff --git a/include/rtkWarpFourDToProjectionStackImageFilter.h b/include/rtkWarpFourDToProjectionStackImageFilter.h
diff --git a/include/rtkWarpProjectionStackToFourDImageFilter.h b/include/rtkWarpProjectionStackToFourDImageFilter.h
