ENH: Use full explicit template parameters in python filter instantia…

applications/rtkamsterdamshroud/rtkamsterdamshroud.py

@@ -47,7 +47,9 @@ def process(args_info: argparse.Namespace):
     rtk.SetProjectionsReaderFromArgParse(reader, args_info)
 
     # Amsterdam Shroud
-    shroudFilter = rtk.AmsterdamShroudImageFilter[OutputImageType].New()
+    shroudFilter = rtk.AmsterdamShroudImageFilter[
+        OutputImageType, OutputImageType
+    ].New()
     shroudFilter.SetInput(reader.GetOutput())
     shroudFilter.SetUnsharpMaskSize(args_info.unsharp)
 

applications/rtkconjugategradient/rtkconjugategradient.py

@@ -101,7 +101,7 @@ def process(args_info: argparse.Namespace):
     if hasattr(itk, "CudaImage"):
         OutputCudaImageType = itk.CudaImage[OutputPixelType, Dimension]
         ConjugateGradientFilterType = rtk.ConjugateGradientConeBeamReconstructionFilter[
-            OutputCudaImageType
+            OutputCudaImageType, OutputCudaImageType, OutputCudaImageType
         ]
         conjugategradient = ConjugateGradientFilterType.New()
         conjugategradient.SetInput(itk.cuda_image_from_image(inputFilter.GetOutput()))
@@ -114,7 +114,7 @@ def process(args_info: argparse.Namespace):
             conjugategradient.SetSupportMask(itk.cuda_image_from_image(supportmask))
     else:
         ConjugateGradientFilterType = rtk.ConjugateGradientConeBeamReconstructionFilter[
-            OutputImageType
+            OutputImageType, OutputImageType, OutputImageType
         ]
         conjugategradient = ConjugateGradientFilterType.New()
         conjugategradient.SetInput(inputFilter.GetOutput())

applications/rtkfdk/rtkfdk.py

@@ -123,10 +123,10 @@ def process(args_info: argparse.Namespace):
         pssf = rtk.CudaParkerShortScanImageFilter.New()
     else:
         ddf = rtk.DisplacedDetectorForOffsetFieldOfViewImageFilter[
-            OutputImageType
+            OutputImageType, OutputImageType
         ].New()
         ddf.SetInput(reader.GetOutput())
-        pssf = rtk.ParkerShortScanImageFilter[OutputImageType].New()
+        pssf = rtk.ParkerShortScanImageFilter[OutputImageType, OutputImageType].New()
 
     # Displaced detector weighting
     ddf.SetGeometry(geometry)
@@ -169,7 +169,9 @@ def process(args_info: argparse.Namespace):
         feldkamp = rtk.CudaFDKConeBeamReconstructionFilter.New()
         feldkamp.SetInput(0, itk.cuda_image_from_image(constantImageSource.GetOutput()))
     else:
-        feldkamp = rtk.FDKConeBeamReconstructionFilter[OutputImageType].New()
+        feldkamp = rtk.FDKConeBeamReconstructionFilter[
+            OutputImageType, OutputImageType, OutputPixelType
+        ].New()
         feldkamp.SetInput(0, constantImageSource.GetOutput())
 
     # Set inputs and options for the FDK filter

applications/rtkforwardprojections/rtkforwardprojections.py

@@ -167,7 +167,7 @@ def process(args_info):
     elif args_info.fp == "CudaRayCast":
         if hasattr(itk, "CudaImage"):
             forwardProjection = rtk.CudaForwardProjectionImageFilter[
-                OutputCudaImageType
+                OutputCudaImageType, OutputCudaImageType
             ].New()
             forwardProjection.SetStepSize(args_info.step)
         else:

applications/rtksart/rtksart.py

@@ -111,7 +111,7 @@ def process(args_info: argparse.Namespace):
     geometry = rtk.read_geometry(args_info.geometry)
 
     # Phase gating weights reader
-    phaseGating = rtk.PhaseGatingImageFilter[OutputImageType].New()
+    phaseGating = rtk.PhaseGatingImageFilter[OutputImageType, OutputImageType].New()
     if args_info.signal:
         phaseGating.SetPhasesFileName(args_info.signal)
         phaseGating.SetGatingWindowWidth(args_info.windowwidth)

documentation/docs/rtk_3_migration_guide.md

@@ -36,6 +36,26 @@ git branch -u origin/main main
 git remote set-head origin -a
 ```
 
+## Python class instantiations: required explicit template arguments
+
+RTK requires callers to provide the full template argument list in Python. You must explicitly supply every template parameter the wrapped C++ class expects (for example `Filter[InputImageType, OutputImageType]`). The single-argument shorthand `Filter[InputImageType]` is no longer supported in RTK and should not be used.
+
+Affected classes:
+
+- `ADMMTotalVariationConeBeamReconstructionFilter`
+- `AmsterdamShroudImageFilter`
+- `BoellaardScatterCorrectionImageFilter`
+- `ConjugateGradientConeBeamReconstructionFilter`
+- `CudaForwardProjectionImageFilter`
+- `DisplacedDetectorForOffsetFieldOfViewImageFilter`
+- `DisplacedDetectorImageFilter`
+- `FDKConeBeamReconstructionFilter`
+- `FDKVarianceReconstructionFilter`
+- `FDKWeightProjectionFilter`
+- `IterativeConeBeamReconstructionFilter`
+- `ParkerShortScanImageFilter`
+- `PhaseGatingImageFilter`
+
 ## Removed `m_Normalize` from `rtk::CudaRayCastBackProjectionImageFilter`
 
 Most users intuitively expect this for the backprojector matched to `rtk::CudaForwardProjectionFilter`. The filter was originally implemented with the normalization for SART and OSEM reconstruction but the normalization is now done in the reconstruction filters so it can be removed.

examples/ConjugateGradient/ConjugateGradient.py

@@ -45,7 +45,7 @@
 if hasattr(itk, "CudaImage"):
     OutputCudaImageType = itk.CudaImage[itk.F, Dimension]
     ConjugateGradientFilterType = rtk.ConjugateGradientConeBeamReconstructionFilter[
-        OutputCudaImageType
+        OutputCudaImageType, OutputCudaImageType, OutputCudaImageType
     ]
     conjugategradient = ConjugateGradientFilterType.New()
     conjugategradient.SetCudaConjugateGradient(True)
@@ -60,7 +60,7 @@
 
 else:
     ConjugateGradientFilterType = rtk.ConjugateGradientConeBeamReconstructionFilter[
-        OutputImageType
+        OutputImageType, OutputImageType, OutputImageType
     ]
     conjugategradient = ConjugateGradientFilterType.New()
     conjugategradient.SetInput(conjugate_gradient_source)

examples/FirstReconstruction/FirstReconstruction.py

@@ -59,7 +59,7 @@
 
 # FDK reconstruction
 print("Reconstructing...")
-FDKCPUType = rtk.FDKConeBeamReconstructionFilter[ImageType]
+FDKCPUType = rtk.FDKConeBeamReconstructionFilter[ImageType, ImageType, itk.F]
 feldkamp = FDKCPUType.New()
 feldkamp.SetInput(0, constantImageSource2.GetOutput())
 feldkamp.SetInput(1, rei.GetOutput())

examples/InlineReconstruction/InlineReconstruction.py

@@ -69,15 +69,17 @@ def acquisition():
     )
     fdk = rtk.CudaFDKConeBeamReconstructionFilter.New(Geometry=geometry_rec)
 else:
-    parker = rtk.ParkerShortScanImageFilter[image_type].New(
+    parker = rtk.ParkerShortScanImageFilter[image_type, image_type].New(
         Input=extractor.GetOutput(), Geometry=geometry_rec
     )
     reconstruction_source = rtk.ConstantImageSource[image_type].New(
         Origin=[origin * sid / sdd] * 3,
         Spacing=[spacing * sid / sdd] * 3,
         Size=[size] * 3,
     )
-    fdk = rtk.FDKConeBeamReconstructionFilter[image_type].New(Geometry=geometry_rec)
+    fdk = rtk.FDKConeBeamReconstructionFilter[image_type, image_type, itk.F].New(
+        Geometry=geometry_rec
+    )
 fdk.SetInput(0, reconstruction_source.GetOutput())
 fdk.SetInput(1, parker.GetOutput())
 

wrapping/itkCudaInPlaceImageFilterRTK.wrap

@@ -19,7 +19,7 @@ if(RTK_USE_CUDA)
     endforeach()
 
     itk_wrap_template("CIF3CIF3PSCIF3"
-      "itk::CudaImage<float, 3>, itk::CudaImage<float, 3>, rtk::ParkerShortScanImageFilter< itk::CudaImage<float, 3>>")
+      "itk::CudaImage<float, 3>, itk::CudaImage<float, 3>, rtk::ParkerShortScanImageFilter< itk::CudaImage<float, 3>, itk::CudaImage<float, 3> >")
   itk_end_wrap_class()
 
   itk_wrap_class("itk::CudaImageToImageFilter" POINTER)
@@ -39,7 +39,7 @@ if(RTK_USE_CUDA)
     endforeach()
 
     itk_wrap_template("CIF3CIF3PSCIF3"
-      "itk::CudaImage<float, 3>, itk::CudaImage<float, 3>, rtk::ParkerShortScanImageFilter< itk::CudaImage<float, 3>>")
+      "itk::CudaImage<float, 3>, itk::CudaImage<float, 3>, rtk::ParkerShortScanImageFilter< itk::CudaImage<float, 3>, itk::CudaImage<float, 3> >")
   itk_end_wrap_class()
 
 endif()

wrapping/rtkBoellaardScatterCorrectionImageFilter.wrap

@@ -1,3 +1,3 @@
 itk_wrap_class("rtk::BoellaardScatterCorrectionImageFilter" POINTER)
-  itk_wrap_image_filter("${WRAP_ITK_REAL}" 1 3)
+  itk_wrap_image_filter("${WRAP_ITK_REAL}" 2 3)
 itk_end_wrap_class()

wrapping/rtkConjugateGradientConeBeamReconstructionFilter.wrap

@@ -1,8 +1,8 @@
 itk_wrap_class("rtk::ConjugateGradientConeBeamReconstructionFilter" POINTER)
 
  if(RTK_USE_CUDA)
-    itk_wrap_template("CIF3" "itk::CudaImage<${ITKT_F}, 3>")
+    itk_wrap_template("CIF3CIF3CIF3" "itk::CudaImage<${ITKT_F}, 3>,itk::CudaImage<${ITKT_F}, 3>,itk::CudaImage<${ITKT_F}, 3>")
   endif()
-  itk_wrap_image_filter("${WRAP_ITK_REAL}" 1 3)
+  itk_wrap_image_filter("${WRAP_ITK_REAL}" 3 3)
 
 itk_end_wrap_class()

wrapping/rtkCudaForwardProjectionImageFilter.wrap

@@ -30,12 +30,12 @@ if(RTK_USE_CUDA)
 
   itk_wrap_class("rtk::CudaForwardProjectionImageFilter" POINTER)
 
-    itk_wrap_template("CIF3" "itk::CudaImage<float, 3>")
+    itk_wrap_template("CIF3CIF3" "itk::CudaImage<float, 3>, itk::CudaImage<float, 3>")
 
     # Force VECTOR_COMPONENTS to "2;3;4;5"
     set(vectorComponents 2 3 4 5)
     foreach(component ${vectorComponents})
-      itk_wrap_template("CI${ITKM_VF${component}}3" "itk::CudaImage<${ITKT_VF${component}}, 3>")
+      itk_wrap_template("CI${ITKM_VF${component}}3CI${ITKM_VF${component}}3" "itk::CudaImage<${ITKT_VF${component}}, 3>, itk::CudaImage<${ITKT_VF${component}}, 3>")
     endforeach()
 
   itk_end_wrap_class()

wrapping/rtkDisplacedDetectorForOffsetFieldOfViewImageFilter.wrap

@@ -1,3 +1,3 @@
 itk_wrap_class("rtk::DisplacedDetectorForOffsetFieldOfViewImageFilter" POINTER)
-  itk_wrap_image_filter("${WRAP_ITK_REAL}" 1 3)
+  itk_wrap_image_filter("${WRAP_ITK_REAL}" 2 3)
 itk_end_wrap_class()

wrapping/rtkDisplacedDetectorImageFilter.wrap

@@ -3,22 +3,19 @@ if(RTK_USE_CUDA)
 endif()
 
 itk_wrap_class("rtk::DisplacedDetectorImageFilter" POINTER)
-  itk_wrap_image_filter("${WRAP_ITK_REAL}" 1 3;4)
-
-  if(RTK_USE_CUDA)
-    foreach(d ${ITK_WRAP_IMAGE_DIMS})
-      itk_wrap_template("CI${ITKM_F}${d}" "itk::CudaImage<${ITKT_F}, ${d}>")
-    endforeach()
-  endif()
-
+  itk_wrap_image_filter("${WRAP_ITK_REAL}" 2 3;4)
 itk_end_wrap_class()
 
 if(RTK_USE_CUDA)
+  foreach(d ${ITK_WRAP_IMAGE_DIMS})
+    itk_wrap_template("CI${ITKM_F}${d}" "itk::CudaImage<${ITKT_F}, ${d}>, itk::CudaImage<${ITKT_F}, ${d}>")
+  endforeach()
+
   itk_wrap_class("itk::CudaImageToImageFilter" POINTER)
-    itk_wrap_template("CIF3CIF3DDCIF3" "itk::CudaImage<${ITKT_F}, 3>, itk::CudaImage<${ITKT_F}, 3>, rtk::DisplacedDetectorImageFilter< itk::CudaImage<${ITKT_F}, 3> >")
+    itk_wrap_template("CIF3CIF3DDCIF3CIF3" "itk::CudaImage<${ITKT_F}, 3>, itk::CudaImage<${ITKT_F}, 3>, rtk::DisplacedDetectorImageFilter< itk::CudaImage<${ITKT_F}, 3>, itk::CudaImage<${ITKT_F}, 3> >")
   itk_end_wrap_class()
 
   itk_wrap_class("itk::CudaInPlaceImageFilter" POINTER)
-    itk_wrap_template("CIF3CIF3DDCIF3" "itk::CudaImage<${ITKT_F}, 3>, itk::CudaImage<${ITKT_F}, 3>, rtk::DisplacedDetectorImageFilter< itk::CudaImage<${ITKT_F}, 3> >")
+    itk_wrap_template("CIF3CIF3DDCIF3CIF3" "itk::CudaImage<${ITKT_F}, 3>, itk::CudaImage<${ITKT_F}, 3>, rtk::DisplacedDetectorImageFilter< itk::CudaImage<${ITKT_F}, 3>, itk::CudaImage<${ITKT_F}, 3> >")
   itk_end_wrap_class()
 endif()

wrapping/rtkFDKConeBeamReconstructionFilter.wrap

@@ -4,7 +4,7 @@ endif()
 
 itk_wrap_class("rtk::FDKConeBeamReconstructionFilter"  POINTER)
   foreach(t ${WRAP_ITK_REAL})
-    itk_wrap_template("I${ITKM_${t}}3" "itk::Image<${ITKT_${t}}, 3>")
+    itk_wrap_template("I${ITKM_${t}}3I${ITKM_${t}}3${ITKM_F}" "itk::Image<${ITKT_${t}}, 3>, itk::Image<${ITKT_${t}}, 3>, float")
   endforeach()
   if(RTK_USE_CUDA)
     itk_wrap_template("CIF3CIF3F" "itk::CudaImage<${ITKT_F}, 3>, itk::CudaImage<${ITKT_F}, 3>, float")

wrapping/rtkFDKVarianceReconstructionFilter.wrap

@@ -4,7 +4,7 @@ endif()
 
 itk_wrap_class("rtk::FDKVarianceReconstructionFilter"  POINTER)
   foreach(t ${WRAP_ITK_REAL})
-    itk_wrap_template("I${ITKM_${t}}3" "itk::Image<${ITKT_${t}}, 3>")
+    itk_wrap_template("I${ITKM_${t}}3I${ITKM_${t}}3" "itk::Image<${ITKT_${t}}, 3>, itk::Image<${ITKT_${t}}, 3>, float")
   endforeach()
   if(RTK_USE_CUDA)
     itk_wrap_template("CIF3CIF3F" "itk::CudaImage<${ITKT_F}, 3>, itk::CudaImage<${ITKT_F}, 3>, float")

wrapping/rtkFDKWeightProjectionFilter.wrap

@@ -3,8 +3,7 @@ if(RTK_USE_CUDA)
 endif()
 
 itk_wrap_class("rtk::FDKWeightProjectionFilter" POINTER)
-  #WARNING: Only wrapping one image template because TInputImage == TOutputImage
-  itk_wrap_image_filter("${WRAP_ITK_REAL}" 1)
+  itk_wrap_image_filter("${WRAP_ITK_REAL}" 2)
   if(RTK_USE_CUDA)
     itk_wrap_template("CIF3CIF3F" "itk::CudaImage<${ITKT_F}, 3>" "itk::CudaImage<${ITKT_F}, 3>" "${ITKT_F}")
   endif()

wrapping/rtkFFTRampImageFilter.wrap

@@ -4,7 +4,7 @@ endif()
 
 itk_wrap_class("rtk::FFTRampImageFilter"  POINTER)
   foreach(t ${WRAP_ITK_REAL})
-    itk_wrap_template("I${ITKM_${t}}3I${ITKM_${t}}3${ITKM_D}" "itk::Image<${ITKT_${t}}, 3>, itk::Image<${ITKT_${t}}, 3>, ${ITKT_D}")
+    itk_wrap_template("I${ITKM_${t}}3I${ITKM_${t}}3${ITKM_${t}}" "itk::Image<${ITKT_${t}}, 3>, itk::Image<${ITKT_${t}}, 3>, ${ITKT_${t}}")
   endforeach()
   if(RTK_USE_CUDA)
     itk_wrap_template("CI${ITKM_F}3CI${ITKM_F}3${ITKM_F}" "itk::CudaImage<${ITKT_F}, 3>, itk::CudaImage<${ITKT_F}, 3>, ${ITKT_F}")

wrapping/rtkFFTVarianceRampImageFilter.wrap

@@ -4,7 +4,7 @@ endif()
 
 itk_wrap_class("rtk::FFTVarianceRampImageFilter"  POINTER)
   foreach(t ${WRAP_ITK_REAL})
-    itk_wrap_template("I${ITKM_${t}}3I${ITKM_${t}}3${ITKM_D}" "itk::Image<${ITKT_${t}}, 3>, itk::Image<${ITKT_${t}}, 3>, ${ITKT_D}")
+    itk_wrap_template("I${ITKM_${t}}3I${ITKM_${t}}3${ITKM_D}" "itk::Image<${ITKT_${t}}, 3>, itk::Image<${ITKT_${t}}, 3>, ${ITKT_${t}}")
   endforeach()
   if(RTK_USE_CUDA)
     itk_wrap_template("CI${ITKM_F}3CI${ITKM_F}3${ITKM_F}" "itk::CudaImage<${ITKT_F}, 3>, itk::CudaImage<${ITKT_F}, 3>, ${ITKT_F}")

wrapping/rtkIterativeConeBeamReconstructionFilter.wrap

@@ -4,7 +4,7 @@ itk_wrap_class("rtk::IterativeConeBeamReconstructionFilter" POINTER)
     itk_wrap_template("CIF3CIF3" "itk::CudaImage<float, 3>, itk::CudaImage<float, 3>")
     itk_wrap_template("CIF4CIF3" "itk::CudaImage<float, 4>, itk::CudaImage<float, 3>")
   endif()
-  itk_wrap_image_filter("${WRAP_ITK_REAL}" 1 3)
+  itk_wrap_image_filter("${WRAP_ITK_REAL}" 2 3)
   #-------------------------------------------------------------------------
   # Wrap template :
   #   -rtk::IterativeConeBeamReconstructionFilter< itk::Image< float,4 >,itk::Image< float,3 > >

wrapping/rtkParkerShortScanImageFilter.wrap

@@ -3,8 +3,8 @@ if(RTK_USE_CUDA)
 endif()
 
 itk_wrap_class("rtk::ParkerShortScanImageFilter" POINTER)
-  itk_wrap_image_filter("${WRAP_ITK_REAL}" 1)
+  itk_wrap_image_filter("${WRAP_ITK_REAL}" 2)
   if(RTK_USE_CUDA)
-    itk_wrap_template("CIF3" "itk::CudaImage<float, 3>")
+    itk_wrap_template("CIF3" "itk::CudaImage<float, 3>, itk::CudaImage<float, 3>")
   endif()
 itk_end_wrap_class()