Merge pull request InsightSoftwareConsortium#5989 from N-Dekker/Remove-local-type-aliases-Image-Iterators

hjmjohnson · web-flow · commit 151d64f0f0d5 · 2026-03-30T13:01:58.000-05:00
Remove local type aliases of Image Iterators in `*.hxx`, use CTAD
diff --git a/Modules/Core/Common/include/itkImageAlgorithm.hxx b/Modules/Core/Common/include/itkImageAlgorithm.hxx
@@ -36,8 +36,8 @@ ImageAlgorithm::ReferenceCopy(const InputImageType *                       inIma
 {
   if (inRegion.GetSize()[0] == outRegion.GetSize()[0])
   {
-    ImageScanlineConstIterator<InputImageType> it(inImage, inRegion);
-    ImageScanlineIterator                      ot(outImage, outRegion);
+    ImageScanlineConstIterator it(inImage, inRegion);
+    ImageScanlineIterator      ot(outImage, outRegion);
 
     while (!it.IsAtEnd())
     {
diff --git a/Modules/Core/Transform/include/itkBSplineDeformableTransform.hxx b/Modules/Core/Transform/include/itkBSplineDeformableTransform.hxx
@@ -496,13 +496,12 @@ BSplineDeformableTransform<TParametersValueType, VDimension, VSplineOrder>::Tran
 
   outputPoint.Fill(ScalarType{});
 
-  using IteratorType = ImageScanlineConstIterator<ImageType>;
-  IteratorType                coeffIterator[SpaceDimension];
-  unsigned long               counter = 0;
-  const ParametersValueType * basePointer = this->m_CoefficientImages[0]->GetBufferPointer();
+  ImageScanlineConstIterator<ImageType> coeffIterator[SpaceDimension];
+  unsigned long                         counter = 0;
+  const ParametersValueType *           basePointer = this->m_CoefficientImages[0]->GetBufferPointer();
   for (unsigned int j = 0; j < SpaceDimension; ++j)
   {
-    coeffIterator[j] = IteratorType(this->m_CoefficientImages[j], supportRegion);
+    coeffIterator[j] = ImageScanlineConstIterator(this->m_CoefficientImages[j], supportRegion);
   }
 
   while (!coeffIterator[0].IsAtEnd())
diff --git a/Modules/Core/Transform/include/itkBSplineTransform.hxx b/Modules/Core/Transform/include/itkBSplineTransform.hxx
@@ -540,13 +540,12 @@ BSplineTransform<TParametersValueType, VDimension, VSplineOrder>::TransformPoint
 
     outputPoint.Fill(ScalarType{});
 
-    using IteratorType = ImageScanlineConstIterator<ImageType>;
-    IteratorType                coeffIterator[SpaceDimension];
-    unsigned long               counter = 0;
-    const ParametersValueType * basePointer = this->m_CoefficientImages[0]->GetBufferPointer();
+    ImageScanlineConstIterator<ImageType> coeffIterator[SpaceDimension];
+    unsigned long                         counter = 0;
+    const ParametersValueType *           basePointer = this->m_CoefficientImages[0]->GetBufferPointer();
     for (unsigned int j = 0; j < SpaceDimension; ++j)
     {
-      coeffIterator[j] = IteratorType(this->m_CoefficientImages[j], supportRegion);
+      coeffIterator[j] = ImageScanlineConstIterator(this->m_CoefficientImages[j], supportRegion);
     }
 
     while (!coeffIterator[0].IsAtEnd())
diff --git a/Modules/Filtering/BinaryMathematicalMorphology/include/itkBinaryMorphologyImageFilter.hxx b/Modules/Filtering/BinaryMathematicalMorphology/include/itkBinaryMorphologyImageFilter.hxx
@@ -115,7 +115,7 @@ BinaryMorphologyImageFilter<TInputImage, TOutputImage, TKernel>::AnalyzeKernel()
 
   // copy
   ImageRegionIterator<BoolImageType> kernelImageIt; // iterator on image
-  kernelImageIt = ImageRegionIterator<BoolImageType>(tmpSEImage, tmpSEImage->GetRequestedRegion());
+  kernelImageIt = ImageRegionIterator(tmpSEImage, tmpSEImage->GetRequestedRegion());
 
   kernel_it = KernelBegin;
 
diff --git a/Modules/Filtering/BinaryMathematicalMorphology/include/itkObjectMorphologyImageFilter.hxx b/Modules/Filtering/BinaryMathematicalMorphology/include/itkObjectMorphologyImageFilter.hxx
@@ -98,8 +98,8 @@ ObjectMorphologyImageFilter<TInputImage, TOutputImage, TKernel>::BeforeThreadedG
 
   const RegionType requestedRegion = this->GetOutput()->GetRequestedRegion();
 
-  auto iRegIter = ImageRegionConstIterator<InputImageType>(this->GetInput(), requestedRegion);
-  auto oRegIter = ImageRegionIterator<OutputImageType>(this->GetOutput(), requestedRegion);
+  auto iRegIter = ImageRegionConstIterator(this->GetInput(), requestedRegion);
+  auto oRegIter = ImageRegionIterator(this->GetOutput(), requestedRegion);
   /* Copy the input image to the output image - then only boundary pixels
    * need to be changed in the output image */
   while (!oRegIter.IsAtEnd())
diff --git a/Modules/Filtering/DisplacementField/include/itkDisplacementFieldJacobianDeterminantFilter.hxx b/Modules/Filtering/DisplacementField/include/itkDisplacementFieldJacobianDeterminantFilter.hxx
@@ -189,7 +189,7 @@ DisplacementFieldJacobianDeterminantFilter<TInputImage, TRealType, TOutputImage>
   {
     bit = ConstNeighborhoodIteratorType(
       m_NeighborhoodRadius, dynamic_cast<const RealVectorImageType *>(m_RealValuedInputImage.GetPointer()), face);
-    it = ImageRegionIterator<TOutputImage>(this->GetOutput(), face);
+    it = ImageRegionIterator(this->GetOutput(), face);
     bit.OverrideBoundaryCondition(&nbc);
     bit.GoToBegin();
 
diff --git a/Modules/Filtering/ImageCompare/include/itkSTAPLEImageFilter.hxx b/Modules/Filtering/ImageCompare/include/itkSTAPLEImageFilter.hxx
@@ -49,8 +49,6 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()
 {
   constexpr double epsilon{ 1.0e-10 };
 
-  using IteratorType = ImageScanlineConstIterator<TInputImage>;
-  using FuzzyIteratorType = ImageScanlineIterator<TOutputImage>;
 
   constexpr double min_rms_error{ 1.0e-14 }; // 7 digits of precision
 
@@ -65,7 +63,7 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()
   // Record the number of input files.
   const ProcessObject::DataObjectPointerArraySizeType number_of_input_files = this->GetNumberOfIndexedInputs();
 
-  const auto D_it = make_unique_for_overwrite<IteratorType[]>(number_of_input_files);
+  const auto D_it = make_unique_for_overwrite<ImageScanlineConstIterator<TInputImage>[]>(number_of_input_files);
 
   const auto p = make_unique_for_overwrite<double[]>(number_of_input_files); // sensitivity
   const auto q = make_unique_for_overwrite<double[]>(number_of_input_files); // specificity
@@ -88,8 +86,8 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()
       itkExceptionStringMacro("One or more input images do not contain matching RequestedRegions");
     }
 
-    IteratorType      in(this->GetInput(i), W->GetRequestedRegion());
-    FuzzyIteratorType out(W, W->GetRequestedRegion());
+    ImageScanlineConstIterator in(this->GetInput(i), W->GetRequestedRegion());
+    ImageScanlineIterator      out(W, W->GetRequestedRegion());
 
     while (!in.IsAtEnd())
     {
@@ -112,7 +110,7 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()
   double N = 0.0;
   double g_t = 0.0;
   {
-    FuzzyIteratorType out(W, W->GetRequestedRegion());
+    ImageScanlineIterator out(W, W->GetRequestedRegion());
     while (!out.IsAtEnd())
     {
       while (!out.IsAtEndOfLine())
@@ -132,8 +130,8 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()
     // Now iterate on estimating specificity and sensitivity
     for (unsigned int i = 0; i < number_of_input_files; ++i)
     {
-      IteratorType      in(this->GetInput(i), W->GetRequestedRegion());
-      FuzzyIteratorType out(W, W->GetRequestedRegion());
+      ImageScanlineConstIterator in(this->GetInput(i), W->GetRequestedRegion());
+      ImageScanlineIterator      out(W, W->GetRequestedRegion());
 
       double p_num{};
       double p_denom{};
@@ -172,10 +170,10 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()
     // segmentation
     for (unsigned int i = 0; i < number_of_input_files; ++i)
     {
-      D_it[i] = IteratorType(this->GetInput(i), W->GetRequestedRegion());
+      D_it[i] = ImageScanlineConstIterator(this->GetInput(i), W->GetRequestedRegion());
     }
 
-    FuzzyIteratorType out(W, W->GetRequestedRegion());
+    ImageScanlineIterator out(W, W->GetRequestedRegion());
     while (!out.IsAtEnd())
     {
       while (!out.IsAtEndOfLine())
diff --git a/Modules/Filtering/ImageFeature/include/itkCannyEdgeDetectionImageFilter.hxx b/Modules/Filtering/ImageFeature/include/itkCannyEdgeDetectionImageFilter.hxx
@@ -118,7 +118,7 @@ CannyEdgeDetectionImageFilter<TInputImage, TOutputImage>::ThreadedCompute2ndDeri
   {
     NeighborhoodType bit(radius, input, face);
 
-    it = ImageRegionIterator<OutputImageType>(this->m_OutputImage, face);
+    it = ImageRegionIterator(this->m_OutputImage, face);
     bit.OverrideBoundaryCondition(&nbc);
     bit.GoToBegin();
 
@@ -416,7 +416,7 @@ CannyEdgeDetectionImageFilter<TInputImage, TOutputImage>::ThreadedCompute2ndDeri
   {
     bit = ConstNeighborhoodIterator<InputImageType>(radius, input, face);
     bit1 = ConstNeighborhoodIterator<InputImageType>(radius, input1, face);
-    it = ImageRegionIterator<OutputImageType>(output, face);
+    it = ImageRegionIterator(output, face);
     bit.OverrideBoundaryCondition(&nbc);
     bit.GoToBegin();
     bit1.GoToBegin();
diff --git a/Modules/Filtering/ImageFeature/include/itkHessian3DToVesselnessMeasureImageFilter.hxx b/Modules/Filtering/ImageFeature/include/itkHessian3DToVesselnessMeasureImageFilter.hxx
@@ -55,7 +55,7 @@ Hessian3DToVesselnessMeasureImageFilter<TPixel>::GenerateData()
   ImageRegionConstIterator             it(eigenImage, eigenImage->GetRequestedRegion());
   ImageRegionIterator<OutputImageType> oit;
   this->AllocateOutputs();
-  oit = ImageRegionIterator<OutputImageType>(output, output->GetRequestedRegion());
+  oit = ImageRegionIterator(output, output->GetRequestedRegion());
   while (!it.IsAtEnd())
   {
     // Get the eigen value
diff --git a/Modules/Filtering/ImageFeature/include/itkMultiScaleHessianBasedMeasureImageFilter.hxx b/Modules/Filtering/ImageFeature/include/itkMultiScaleHessianBasedMeasureImageFilter.hxx
@@ -224,12 +224,12 @@ MultiScaleHessianBasedMeasureImageFilter<TInputImage, THessianImage, TOutputImag
 
   if (m_GenerateScalesOutput)
   {
-    osit = ImageRegionIterator<ScalesImageType>(scalesImage, outputRegion);
+    osit = ImageRegionIterator(scalesImage, outputRegion);
     osit.GoToBegin();
   }
   if (m_GenerateHessianOutput)
   {
-    ohit = ImageRegionIterator<HessianImageType>(hessianImage, outputRegion);
+    ohit = ImageRegionIterator(hessianImage, outputRegion);
     ohit.GoToBegin();
   }
 
diff --git a/Modules/Filtering/ImageFeature/include/itkZeroCrossingImageFilter.hxx b/Modules/Filtering/ImageFeature/include/itkZeroCrossingImageFilter.hxx
@@ -125,7 +125,7 @@ ZeroCrossingImageFilter<TInputImage, TOutputImage>::DynamicThreadedGenerateData(
 
     static constexpr SizeValueType    neighborhoodSize = Math::UnsignedPower(3, ImageDimension);
     static constexpr SizeValueType    center = neighborhoodSize / 2;
-    ImageRegionIterator<TOutputImage> it = ImageRegionIterator<OutputImageType>(output, face);
+    ImageRegionIterator<TOutputImage> it = ImageRegionIterator(output, face);
     while (!bit.IsAtEnd())
     {
       const InputImagePixelType this_one = bit.GetPixel(center);
diff --git a/Modules/Filtering/ImageFilterBase/include/itkMaskNeighborhoodOperatorImageFilter.hxx b/Modules/Filtering/ImageFilterBase/include/itkMaskNeighborhoodOperatorImageFilter.hxx
@@ -132,8 +132,8 @@ MaskNeighborhoodOperatorImageFilter<TInputImage, TMaskImage, TOutputImage, TOper
     bit.OverrideBoundaryCondition(this->GetBoundaryCondition());
     bit.GoToBegin();
 
-    it = ImageRegionIterator<OutputImageType>(output, face);
-    mit = ImageRegionConstIterator<MaskImageType>(mask, face);
+    it = ImageRegionIterator(output, face);
+    mit = ImageRegionConstIterator(mask, face);
     while (!bit.IsAtEnd())
     {
       if (mit.Get())
diff --git a/Modules/Filtering/ImageFilterBase/include/itkNeighborhoodOperatorImageFilter.hxx b/Modules/Filtering/ImageFilterBase/include/itkNeighborhoodOperatorImageFilter.hxx
@@ -103,7 +103,7 @@ NeighborhoodOperatorImageFilter<TInputImage, TOutputImage, TOperatorValueType>::
   {
     bit = ConstNeighborhoodIterator<InputImageType>(m_Operator.GetRadius(), input, face);
     bit.OverrideBoundaryCondition(m_BoundsCondition);
-    it = ImageRegionIterator<OutputImageType>(output, face);
+    it = ImageRegionIterator(output, face);
     bit.GoToBegin();
     while (!bit.IsAtEnd())
     {
diff --git a/Modules/Filtering/ImageFilterBase/include/itkVectorNeighborhoodOperatorImageFilter.hxx b/Modules/Filtering/ImageFilterBase/include/itkVectorNeighborhoodOperatorImageFilter.hxx
@@ -102,7 +102,7 @@ VectorNeighborhoodOperatorImageFilter<TInputImage, TOutputImage>::DynamicThreade
   for (const auto & face : faceList)
   {
     bit = ConstNeighborhoodIterator<InputImageType>(m_Operator.GetRadius(), input, face);
-    it = ImageRegionIterator<OutputImageType>(output, face);
+    it = ImageRegionIterator(output, face);
     bit.GoToBegin();
     while (!bit.IsAtEnd())
     {
diff --git a/Modules/Filtering/ImageGradient/include/itkGradientMagnitudeImageFilter.hxx b/Modules/Filtering/ImageGradient/include/itkGradientMagnitudeImageFilter.hxx
@@ -157,7 +157,7 @@ GradientMagnitudeImageFilter<TInputImage, TOutputImage>::DynamicThreadedGenerate
   for (const auto & face : faceList)
   {
     bit = ConstNeighborhoodIterator<InputImageType>(radius, input, face);
-    it = ImageRegionIterator<OutputImageType>(output, face);
+    it = ImageRegionIterator(output, face);
     bit.OverrideBoundaryCondition(&nbc);
     bit.GoToBegin();
 
diff --git a/Modules/Filtering/ImageGradient/include/itkVectorGradientMagnitudeImageFilter.hxx b/Modules/Filtering/ImageGradient/include/itkVectorGradientMagnitudeImageFilter.hxx
@@ -204,7 +204,7 @@ VectorGradientMagnitudeImageFilter<TInputImage, TRealType, TOutputImage>::Dynami
   for (const auto & face : faceList)
   {
     bit = ConstNeighborhoodIteratorType(r1, m_RealValuedInputImage.GetPointer(), face);
-    it = ImageRegionIterator<TOutputImage>(this->GetOutput(), face);
+    it = ImageRegionIterator(this->GetOutput(), face);
     bit.OverrideBoundaryCondition(&nbc);
     bit.GoToBegin();
 
diff --git a/Modules/Filtering/ImageIntensity/include/itkNaryFunctorImageFilter.hxx b/Modules/Filtering/ImageIntensity/include/itkNaryFunctorImageFilter.hxx
@@ -45,8 +45,7 @@ NaryFunctorImageFilter<TInputImage, TOutputImage, TFunction>::DynamicThreadedGen
   }
   const auto numberOfInputImages = static_cast<unsigned int>(this->GetNumberOfIndexedInputs());
 
-  using ImageScanlineConstIteratorType = ImageScanlineConstIterator<TInputImage>;
-  std::vector<ImageScanlineConstIteratorType *> inputItrVector;
+  std::vector<ImageScanlineConstIterator<TInputImage> *> inputItrVector;
   inputItrVector.reserve(numberOfInputImages);
 
   // count the number of inputs that are non-null
@@ -56,7 +55,7 @@ NaryFunctorImageFilter<TInputImage, TOutputImage, TFunction>::DynamicThreadedGen
 
     if (inputPtr)
     {
-      inputItrVector.push_back(new ImageScanlineConstIteratorType(inputPtr, outputRegionForThread));
+      inputItrVector.push_back(new ImageScanlineConstIterator<TInputImage>(inputPtr, outputRegionForThread));
     }
   }
 
@@ -73,8 +72,8 @@ NaryFunctorImageFilter<TInputImage, TOutputImage, TFunction>::DynamicThreadedGen
 
   const OutputImagePointer outputPtr = this->GetOutput(0);
 
-  typename std::vector<ImageScanlineConstIteratorType *>::iterator regionIterators;
-  const auto                                                       regionItEnd = inputItrVector.end();
+  typename std::vector<ImageScanlineConstIterator<TInputImage> *>::iterator regionIterators;
+  const auto                                                                regionItEnd = inputItrVector.end();
 
   typename NaryArrayType::iterator arrayIt;
 
diff --git a/Modules/Filtering/MathematicalMorphology/include/itkGrayscaleGeodesicDilateImageFilter.hxx b/Modules/Filtering/MathematicalMorphology/include/itkGrayscaleGeodesicDilateImageFilter.hxx
@@ -290,8 +290,8 @@ GrayscaleGeodesicDilateImageFilter<TInputImage, TOutputImage>::DynamicThreadedGe
   for (const auto & face : faceList)
   {
     NeighborhoodIteratorType markerIt(kernelRadius, this->GetMarkerImage(), face);
-    maskIt = ImageRegionConstIterator<MaskImageType>(this->GetMaskImage(), face);
-    oIt = ImageRegionIterator<OutputImageType>(this->GetOutput(), face);
+    maskIt = ImageRegionConstIterator(this->GetMaskImage(), face);
+    oIt = ImageRegionIterator(this->GetOutput(), face);
 
     markerIt.OverrideBoundaryCondition(&BC);
     markerIt.GoToBegin();
diff --git a/Modules/Filtering/MathematicalMorphology/include/itkMorphologyImageFilter.hxx b/Modules/Filtering/MathematicalMorphology/include/itkMorphologyImageFilter.hxx
@@ -62,7 +62,7 @@ MorphologyImageFilter<TInputImage, TOutputImage, TKernel>::DynamicThreadedGenera
   {
     b_iter = NeighborhoodIteratorType(this->GetKernel().GetRadius(), this->GetInput(), face);
 
-    o_iter = ImageRegionIterator<OutputImageType>(this->GetOutput(), face);
+    o_iter = ImageRegionIterator(this->GetOutput(), face);
     b_iter.OverrideBoundaryCondition(m_BoundaryCondition);
     b_iter.GoToBegin();
 
diff --git a/Modules/Filtering/Smoothing/include/itkBinomialBlurImageFilter.hxx b/Modules/Filtering/Smoothing/include/itkBinomialBlurImageFilter.hxx
@@ -116,7 +116,6 @@ BinomialBlurImageFilter<TInputImage, TOutputImage>::GenerateData()
   typename TInputImage::IndexType startIndex = inputPtr->GetRequestedRegion().GetIndex();
 
   // Iterator Typedefs for this routine
-  using TempReverseIterator = ImageRegionReverseIterator<TTempImage>;
 
   // Create a progress reporter
   ProgressReporter progress(
@@ -183,7 +182,7 @@ BinomialBlurImageFilter<TInputImage, TOutputImage>::GenerateData()
       itkDebugMacro("End processing forward dimension " << dim);
 
       //----------------------Reverse pass----------------------
-      TempReverseIterator tempReverseIt(tempPtr, tempPtr->GetRequestedRegion());
+      ImageRegionReverseIterator tempReverseIt(tempPtr, tempPtr->GetRequestedRegion());
 
       tempReverseIt.GoToBegin();
 
diff --git a/Modules/Registration/PDEDeformable/include/itkCurvatureRegistrationFilter.hxx b/Modules/Registration/PDEDeformable/include/itkCurvatureRegistrationFilter.hxx
@@ -209,11 +209,11 @@ CurvatureRegistrationFilter<TFixedImage, TMovingImage, TDisplacementField, TImag
   ImageRegionConstIterator<DisplacementFieldType>   itInUpdate;
   ImageRegionConstIteratorWithIndex<FixedImageType> fixedImageIteratorWithIndex;
 
-  itInDeformation = ImageRegionConstIterator<DisplacementFieldType>(
-    this->GetDisplacementField(), this->GetDisplacementField()->GetLargestPossibleRegion());
-  itOutDeformation = ImageRegionIterator<DisplacementFieldType>(
-    this->GetDisplacementField(), this->GetDisplacementField()->GetLargestPossibleRegion());
-  itInUpdate = ImageRegionConstIterator<DisplacementFieldType>(update, update->GetLargestPossibleRegion());
+  itInDeformation =
+    ImageRegionConstIterator(this->GetDisplacementField(), this->GetDisplacementField()->GetLargestPossibleRegion());
+  itOutDeformation =
+    ImageRegionIterator(this->GetDisplacementField(), this->GetDisplacementField()->GetLargestPossibleRegion());
+  itInUpdate = ImageRegionConstIterator(update, update->GetLargestPossibleRegion());
   fixedImageIteratorWithIndex = ImageRegionConstIteratorWithIndex<FixedImageType>(
     this->GetFixedImage(), this->GetFixedImage()->GetLargestPossibleRegion());
 
diff --git a/Modules/Segmentation/LabelVoting/include/itkBinaryMedianImageFilter.hxx b/Modules/Segmentation/LabelVoting/include/itkBinaryMedianImageFilter.hxx
@@ -110,7 +110,7 @@ BinaryMedianImageFilter<TInputImage, TOutputImage>::DynamicThreadedGenerateData(
   for (const auto & face : faceList)
   {
     bit = ConstNeighborhoodIterator<InputImageType>(m_Radius, input, face);
-    it = ImageRegionIterator<OutputImageType>(output, face);
+    it = ImageRegionIterator(output, face);
     bit.OverrideBoundaryCondition(&nbc);
     bit.GoToBegin();
 
diff --git a/Modules/Segmentation/LabelVoting/include/itkLabelVotingImageFilter.hxx b/Modules/Segmentation/LabelVoting/include/itkLabelVotingImageFilter.hxx
@@ -98,7 +98,7 @@ LabelVotingImageFilter<TInputImage, TOutputImage>::DynamicThreadedGenerateData(
   std::vector<ImageRegionConstIterator<TInputImage>> it(numberOfInputIndexes);
   for (size_t i = 0; i < numberOfInputIndexes; ++i)
   {
-    it[i] = ImageRegionConstIterator<TInputImage>(this->GetInput(i), outputRegionForThread);
+    it[i] = ImageRegionConstIterator(this->GetInput(i), outputRegionForThread);
   }
 
   std::vector<unsigned int> votesByLabel(this->m_TotalLabelCount);
diff --git a/Modules/Segmentation/LabelVoting/include/itkVotingBinaryHoleFillingImageFilter.hxx b/Modules/Segmentation/LabelVoting/include/itkVotingBinaryHoleFillingImageFilter.hxx
@@ -103,7 +103,7 @@ VotingBinaryHoleFillingImageFilter<TInputImage, TOutputImage>::ThreadedGenerateD
   for (const auto & face : faceList)
   {
     bit = ConstNeighborhoodIterator<InputImageType>(this->GetRadius(), input, face);
-    it = ImageRegionIterator<OutputImageType>(output, face);
+    it = ImageRegionIterator(output, face);
     bit.OverrideBoundaryCondition(&nbc);
     bit.GoToBegin();
 
diff --git a/Modules/Segmentation/LabelVoting/include/itkVotingBinaryImageFilter.hxx b/Modules/Segmentation/LabelVoting/include/itkVotingBinaryImageFilter.hxx
@@ -108,7 +108,7 @@ VotingBinaryImageFilter<TInputImage, TOutputImage>::DynamicThreadedGenerateData(
   for (const auto & face : faceList)
   {
     bit = ConstNeighborhoodIterator<InputImageType>(m_Radius, input, face);
-    it = ImageRegionIterator<OutputImageType>(output, face);
+    it = ImageRegionIterator(output, face);
     bit.OverrideBoundaryCondition(&nbc);
     bit.GoToBegin();
 
diff --git a/Modules/Segmentation/LevelSets/include/itkExtensionVelocitiesImageFilter.hxx b/Modules/Segmentation/LevelSets/include/itkExtensionVelocitiesImageFilter.hxx
@@ -157,7 +157,7 @@ ExtensionVelocitiesImageFilter<TLevelSet, TAuxValue, VAuxDimension>::GenerateDat
   for (unsigned int k = 0; k < VAuxDimension; ++k)
   {
     const AuxImagePointer ptr = this->GetOutputVelocityImage(k);
-    auxOutputIt[k] = ImageRegionIterator<AuxImageType>(ptr, ptr->GetBufferedRegion());
+    auxOutputIt[k] = ImageRegionIterator(ptr, ptr->GetBufferedRegion());
   }
 
   this->UpdateProgress(0.0);
@@ -178,12 +178,12 @@ ExtensionVelocitiesImageFilter<TLevelSet, TAuxValue, VAuxDimension>::GenerateDat
   m_Marcher->SetAuxiliaryTrialValues(m_Locator->GetModifiableAuxOutsideValues());
   m_Marcher->Update();
 
-  tempIt = ImageRegionIterator<LocalLevelSetImageType>(tempLevelSet, tempLevelSet->GetBufferedRegion());
+  tempIt = ImageRegionIterator(tempLevelSet, tempLevelSet->GetBufferedRegion());
 
   for (unsigned int k = 0; k < VAuxDimension; ++k)
   {
     const AuxImagePointer ptr = m_Marcher->GetAuxiliaryImage(k);
-    auxTempIt[k] = ImageRegionIterator<AuxImageType>(ptr, ptr->GetBufferedRegion());
+    auxTempIt[k] = ImageRegionIterator(ptr, ptr->GetBufferedRegion());
   }
 
   inputIt.GoToBegin();
@@ -315,7 +315,7 @@ ExtensionVelocitiesImageFilter<TLevelSet, TAuxValue, VAuxDimension>::GenerateDat
   for (unsigned int k = 0; k < VAuxDimension; ++k)
   {
     const AuxImagePointer ptr = this->GetOutputVelocityImage(k);
-    auxOutputIt[k] = ImageRegionIterator<AuxImageType>(ptr, ptr->GetBufferedRegion());
+    auxOutputIt[k] = ImageRegionIterator(ptr, ptr->GetBufferedRegion());
     auxOutputIt[k].GoToBegin();
   }
   while (!auxOutputIt[0].IsAtEnd())
diff --git a/Modules/Segmentation/LevelSets/include/itkParallelSparseFieldLevelSetImageFilter.hxx b/Modules/Segmentation/LevelSets/include/itkParallelSparseFieldLevelSetImageFilter.hxx
@@ -230,7 +230,7 @@ ParallelSparseFieldLevelSetImageFilter<TInputImage, TOutputImage>::Initialize()
   // skip the first (nonboundary) region
   for (auto fit = ++faceList.begin(); fit != faceList.end(); ++fit)
   {
-    statusIt = ImageRegionIterator<StatusImageType>(m_StatusImage, *fit);
+    statusIt = ImageRegionIterator(m_StatusImage, *fit);
     for (statusIt.GoToBegin(); !statusIt.IsAtEnd(); ++statusIt)
     {
       statusIt.Set(m_StatusBoundaryPixel);
diff --git a/Modules/Segmentation/LevelSets/include/itkSparseFieldLevelSetImageFilter.hxx b/Modules/Segmentation/LevelSets/include/itkSparseFieldLevelSetImageFilter.hxx
diff --git a/Modules/Segmentation/LevelSets/include/itkThresholdSegmentationLevelSetFunction.hxx b/Modules/Segmentation/LevelSets/include/itkThresholdSegmentationLevelSetFunction.hxx

Original file line number	Diff line number	Diff line change
`@@ -36,8 +36,8 @@ ImageAlgorithm::ReferenceCopy(const InputImageType * inIma`
`36`	`36`	`{`
`37`	`37`	`if (inRegion.GetSize()[0] == outRegion.GetSize()[0])`
`38`	`38`	`{`
`39`		`- ImageScanlineConstIterator<InputImageType> it(inImage, inRegion);`
`40`		`- ImageScanlineIterator ot(outImage, outRegion);`
	`39`	`+ ImageScanlineConstIterator it(inImage, inRegion);`
	`40`	`+ ImageScanlineIterator ot(outImage, outRegion);`
`41`	`41`
`42`	`42`	`while (!it.IsAtEnd())`
`43`	`43`	`{`
Original file line number	Diff line number	Diff line change
`@@ -189,7 +189,7 @@ DisplacementFieldJacobianDeterminantFilter<TInputImage, TRealType, TOutputImage>`
`189`	`189`	`{`
`190`	`190`	`bit = ConstNeighborhoodIteratorType(`
`191`	`191`	`m_NeighborhoodRadius, dynamic_cast<const RealVectorImageType *>(m_RealValuedInputImage.GetPointer()), face);`
`192`		`- it = ImageRegionIterator<TOutputImage>(this->GetOutput(), face);`
	`192`	`+ it = ImageRegionIterator(this->GetOutput(), face);`
`193`	`193`	`bit.OverrideBoundaryCondition(&nbc);`
`194`	`194`	`bit.GoToBegin();`
`195`	`195`
Original file line number	Diff line number	Diff line change
`@@ -49,8 +49,6 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()`
`49`	`49`	`{`
`50`	`50`	`constexpr double epsilon{ 1.0e-10 };`
`51`	`51`
`52`		`- using IteratorType = ImageScanlineConstIterator<TInputImage>;`
`53`		`- using FuzzyIteratorType = ImageScanlineIterator<TOutputImage>;`
`54`	`52`
`55`	`53`	`constexpr double min_rms_error{ 1.0e-14 }; // 7 digits of precision`
`56`	`54`
`@@ -65,7 +63,7 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()`
`65`	`63`	`// Record the number of input files.`
`66`	`64`	`const ProcessObject::DataObjectPointerArraySizeType number_of_input_files = this->GetNumberOfIndexedInputs();`
`67`	`65`
`68`		`- const auto D_it = make_unique_for_overwrite<IteratorType[]>(number_of_input_files);`
	`66`	`+ const auto D_it = make_unique_for_overwrite<ImageScanlineConstIterator<TInputImage>[]>(number_of_input_files);`
`69`	`67`
`70`	`68`	`const auto p = make_unique_for_overwrite<double[]>(number_of_input_files); // sensitivity`
`71`	`69`	`const auto q = make_unique_for_overwrite<double[]>(number_of_input_files); // specificity`
`@@ -88,8 +86,8 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()`
`88`	`86`	`itkExceptionStringMacro("One or more input images do not contain matching RequestedRegions");`
`89`	`87`	`}`
`90`	`88`
`91`		`- IteratorType in(this->GetInput(i), W->GetRequestedRegion());`
`92`		`- FuzzyIteratorType out(W, W->GetRequestedRegion());`
	`89`	`+ ImageScanlineConstIterator in(this->GetInput(i), W->GetRequestedRegion());`
	`90`	`+ ImageScanlineIterator out(W, W->GetRequestedRegion());`
`93`	`91`
`94`	`92`	`while (!in.IsAtEnd())`
`95`	`93`	`{`
`@@ -112,7 +110,7 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()`
`112`	`110`	`double N = 0.0;`
`113`	`111`	`double g_t = 0.0;`
`114`	`112`	`{`
`115`		`- FuzzyIteratorType out(W, W->GetRequestedRegion());`
	`113`	`+ ImageScanlineIterator out(W, W->GetRequestedRegion());`
`116`	`114`	`while (!out.IsAtEnd())`
`117`	`115`	`{`
`118`	`116`	`while (!out.IsAtEndOfLine())`
`@@ -132,8 +130,8 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()`
`132`	`130`	`// Now iterate on estimating specificity and sensitivity`
`133`	`131`	`for (unsigned int i = 0; i < number_of_input_files; ++i)`
`134`	`132`	`{`
`135`		`- IteratorType in(this->GetInput(i), W->GetRequestedRegion());`
`136`		`- FuzzyIteratorType out(W, W->GetRequestedRegion());`
	`133`	`+ ImageScanlineConstIterator in(this->GetInput(i), W->GetRequestedRegion());`
	`134`	`+ ImageScanlineIterator out(W, W->GetRequestedRegion());`
`137`	`135`
`138`	`136`	`double p_num{};`
`139`	`137`	`double p_denom{};`
`@@ -172,10 +170,10 @@ STAPLEImageFilter<TInputImage, TOutputImage>::GenerateData()`
`172`	`170`	`// segmentation`
`173`	`171`	`for (unsigned int i = 0; i < number_of_input_files; ++i)`
`174`	`172`	`{`
`175`		`- D_it[i] = IteratorType(this->GetInput(i), W->GetRequestedRegion());`
	`173`	`+ D_it[i] = ImageScanlineConstIterator(this->GetInput(i), W->GetRequestedRegion());`
`176`	`174`	`}`
`177`	`175`
`178`		`- FuzzyIteratorType out(W, W->GetRequestedRegion());`
	`176`	`+ ImageScanlineIterator out(W, W->GetRequestedRegion());`
`179`	`177`	`while (!out.IsAtEnd())`
`180`	`178`	`{`
`181`	`179`	`while (!out.IsAtEndOfLine())`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ Hessian3DToVesselnessMeasureImageFilter<TPixel>::GenerateData()`
`55`	`55`	`ImageRegionConstIterator it(eigenImage, eigenImage->GetRequestedRegion());`
`56`	`56`	`ImageRegionIterator<OutputImageType> oit;`
`57`	`57`	`this->AllocateOutputs();`
`58`		`- oit = ImageRegionIterator<OutputImageType>(output, output->GetRequestedRegion());`
	`58`	`+ oit = ImageRegionIterator(output, output->GetRequestedRegion());`
`59`	`59`	`while (!it.IsAtEnd())`
`60`	`60`	`{`
`61`	`61`	`// Get the eigen value`
Original file line number	Diff line number	Diff line change
`@@ -224,12 +224,12 @@ MultiScaleHessianBasedMeasureImageFilter<TInputImage, THessianImage, TOutputImag`
`224`	`224`
`225`	`225`	`if (m_GenerateScalesOutput)`
`226`	`226`	`{`
`227`		`- osit = ImageRegionIterator<ScalesImageType>(scalesImage, outputRegion);`
	`227`	`+ osit = ImageRegionIterator(scalesImage, outputRegion);`
`228`	`228`	`osit.GoToBegin();`
`229`	`229`	`}`
`230`	`230`	`if (m_GenerateHessianOutput)`
`231`	`231`	`{`
`232`		`- ohit = ImageRegionIterator<HessianImageType>(hessianImage, outputRegion);`
	`232`	`+ ohit = ImageRegionIterator(hessianImage, outputRegion);`
`233`	`233`	`ohit.GoToBegin();`
`234`	`234`	`}`
`235`	`235`