WIP: STYLE: Use ImageRegion auto [index, size] = region structured bindings

Modules/Bridge/VTK/include/itkVTKImageExport.hxx

@@ -144,9 +144,7 @@ VTKImageExport<TInputImage>::WholeExtentCallback()
     itkExceptionMacro("Need to set an input");
   }
 
-  InputRegionType region = input->GetLargestPossibleRegion();
-  InputSizeType   size = region.GetSize();
-  InputIndexType  index = region.GetIndex();
+  const auto [index, size] = input->GetLargestPossibleRegion();
 
   unsigned int i = 0;
   // Fill in the known portion of the extent.
@@ -386,9 +384,7 @@ VTKImageExport<TInputImage>::DataExtentCallback()
     itkExceptionMacro("Need to set an input");
   }
 
-  InputRegionType region = input->GetBufferedRegion();
-  InputSizeType   size = region.GetSize();
-  InputIndexType  index = region.GetIndex();
+  const auto [index, size] = input->GetBufferedRegion();
 
   unsigned int i = 0;
   for (; i < InputImageDimension; ++i)

Modules/Bridge/VTK/include/itkVTKImageImport.hxx

@@ -112,9 +112,7 @@ VTKImageImport<TOutputImage>::PropagateRequestedRegion(DataObject * outputPtr)
   Superclass::PropagateRequestedRegion(output);
   if (m_PropagateUpdateExtentCallback)
   {
-    OutputRegionType region = output->GetRequestedRegion();
-    OutputSizeType   size = region.GetSize();
-    OutputIndexType  index = region.GetIndex();
+    const auto [index, size] = output->GetRequestedRegion();
 
     int          updateExtent[6];
     unsigned int i = 0;

Modules/Core/Common/include/itkConstNeighborhoodIterator.hxx

@@ -392,10 +392,8 @@ ConstNeighborhoodIterator<TImage, TBoundaryCondition>::SetRegion(const RegionTyp
   m_End = m_ConstImage->GetBufferPointer() + m_ConstImage->ComputeOffset(m_EndIndex);
 
   // now determine whether boundary conditions are going to be needed
-  const IndexType bStart = m_ConstImage->GetBufferedRegion().GetIndex();
-  const SizeType  bSize = m_ConstImage->GetBufferedRegion().GetSize();
-  const IndexType rStart = region.GetIndex();
-  const SizeType  rSize = region.GetSize();
+  const auto [bStart, bSize] = m_ConstImage->GetBufferedRegion();
+  const auto [rStart, rSize] = region;
 
   m_NeedToUseBoundaryCondition = false;
   for (DimensionValueType i = 0; i < Dimension; ++i)
@@ -627,8 +625,7 @@ ConstNeighborhoodIterator<TImage, TBoundaryCondition>::SetBound(const SizeType &
 {
   SizeType                radius = this->GetRadius();
   const OffsetValueType * offset = m_ConstImage->GetOffsetTable();
-  const IndexType         imageBRStart = m_ConstImage->GetBufferedRegion().GetIndex();
-  SizeType                imageBRSize = m_ConstImage->GetBufferedRegion().GetSize();
+  const auto [imageBRStart, imageBRSize] = m_ConstImage->GetBufferedRegion();
 
   // Set the bounds and the wrapping offsets. Inner bounds are the loop
   // indices where the iterator will begin to overlap the edge of the image

Modules/Core/Common/include/itkConstNeighborhoodIteratorWithOnlyIndex.hxx

@@ -205,10 +205,8 @@ ConstNeighborhoodIteratorWithOnlyIndex<TImage>::Initialize(const SizeType &   ra
   this->SetEndIndex();
 
   // now determine whether boundary conditions are going to be needed
-  const IndexType bStart = ptr->GetBufferedRegion().GetIndex();
-  const SizeType  bSize = ptr->GetBufferedRegion().GetSize();
-  const IndexType rStart = region.GetIndex();
-  const SizeType  rSize = region.GetSize();
+  const auto [bStart, bSize] = ptr->GetBufferedRegion();
+  const auto [rStart, rSize] = region;
 
   m_NeedToUseBoundaryCondition = false;
   for (DimensionValueType i = 0; i < Dimension; ++i)
@@ -456,9 +454,8 @@ template <typename TImage>
 void
 ConstNeighborhoodIteratorWithOnlyIndex<TImage>::SetBound(const SizeType & size)
 {
-  SizeType        radius = this->GetRadius();
-  const IndexType imageBRStart = m_ConstImage->GetBufferedRegion().GetIndex();
-  SizeType        imageBRSize = m_ConstImage->GetBufferedRegion().GetSize();
+  SizeType radius = this->GetRadius();
+  const auto [imageBRStart, imageBRSize] = m_ConstImage->GetBufferedRegion();
 
   // Set the bounds and the wrapping offsets. Inner bounds are the loop
   // indices where the iterator will begin to overlap the edge of the image

Modules/Core/Common/include/itkNeighborhoodAlgorithm.hxx

@@ -49,10 +49,8 @@ ImageBoundaryFacesCalculator<TImage>::Compute(const TImage & img, RegionType reg
     return result;
   }
 
-  const IndexType bStart = bufferedRegion.GetIndex();
-  const SizeType  bSize = bufferedRegion.GetSize();
-  const IndexType rStart = regionToProcess.GetIndex();
-  const SizeType  rSize = regionToProcess.GetSize();
+  const auto [bStart, bSize] = bufferedRegion;
+  const auto [rStart, rSize] = regionToProcess;
 
   SizeType  nbSize = rSize;   // Non-boundary region
   IndexType nbStart = rStart; // data.

Modules/Core/Common/include/itkPeriodicBoundaryCondition.hxx

@@ -138,11 +138,9 @@ PeriodicBoundaryCondition<TInputImage, TOutputImage>::GetInputRequestedRegion(
   const RegionType & inputLargestPossibleRegion,
   const RegionType & outputRequestedRegion) const -> RegionType
 {
-  IndexType imageIndex = inputLargestPossibleRegion.GetIndex();
-  SizeType  imageSize = inputLargestPossibleRegion.GetSize();
+  const auto [imageIndex, imageSize] = inputLargestPossibleRegion;
 
-  IndexType outputIndex = outputRequestedRegion.GetIndex();
-  SizeType  outputSize = outputRequestedRegion.GetSize();
+  const auto [outputIndex, outputSize] = outputRequestedRegion;
 
   IndexType inputRequestedIndex;
   SizeType  inputRequestedSize;
@@ -183,9 +181,7 @@ auto
 PeriodicBoundaryCondition<TInputImage, TOutputImage>::GetPixel(const IndexType & index, const TInputImage * image) const
   -> OutputPixelType
 {
-  RegionType imageRegion = image->GetLargestPossibleRegion();
-  IndexType  imageIndex = imageRegion.GetIndex();
-  SizeType   imageSize = imageRegion.GetSize();
+  const auto [imageIndex, imageSize] = image->GetLargestPossibleRegion();
 
   IndexType lookupIndex;
 

Modules/Core/Common/include/itkZeroFluxNeumannBoundaryCondition.hxx

@@ -86,11 +86,9 @@ ZeroFluxNeumannBoundaryCondition<TInputImage, TOutputImage>::GetInputRequestedRe
   const RegionType & inputLargestPossibleRegion,
   const RegionType & outputRequestedRegion) const -> RegionType
 {
-  IndexType inputIndex = inputLargestPossibleRegion.GetIndex();
-  SizeType  inputSize = inputLargestPossibleRegion.GetSize();
+  const auto [inputIndex, inputSize] = inputLargestPossibleRegion;
 
-  IndexType outputIndex = outputRequestedRegion.GetIndex();
-  SizeType  outputSize = outputRequestedRegion.GetSize();
+  const auto [outputIndex, outputSize] = outputRequestedRegion;
 
   IndexType requestIndex;
   SizeType  requestSize;
@@ -156,8 +154,7 @@ ZeroFluxNeumannBoundaryCondition<TInputImage, TOutputImage>::GetPixel(const Inde
   -> OutputPixelType
 {
   RegionType imageRegion = image->GetLargestPossibleRegion();
-  IndexType  imageIndex = imageRegion.GetIndex();
-  SizeType   imageSize = imageRegion.GetSize();
+  const auto [imageIndex, imageSize] = imageRegion;
 
   IndexType lookupIndex;
 

Modules/Core/GPUCommon/include/itkGPUImageDataManager.hxx

@@ -32,9 +32,7 @@ GPUImageDataManager<ImageType>::SetImagePointer(ImageType * img)
   using IndexType = typename ImageType::IndexType;
   using SizeType = typename ImageType::SizeType;
 
-  RegionType region = m_Image->GetBufferedRegion();
-  IndexType  index = region.GetIndex();
-  SizeType   size = region.GetSize();
+  const auto [index, size] = m_Image->GetBufferedRegion();
 
   for (unsigned int d = 0; d < ImageDimension; ++d)
   {

Modules/Core/ImageFunction/include/itkGaussianInterpolateImageFunction.hxx

@@ -58,8 +58,7 @@ GaussianInterpolateImageFunction<TImageType, TCoordRep>::ComputeBoundingBox()
 
   typename InputImageType::ConstPointer input = this->GetInputImage();
   typename InputImageType::SpacingType  spacing = input->GetSpacing();
-  typename InputImageType::IndexType    index = input->GetLargestPossibleRegion().GetIndex();
-  typename InputImageType::SizeType     size = input->GetLargestPossibleRegion().GetSize();
+  const auto [index, size] = input->GetLargestPossibleRegion();
 
   for (unsigned int d = 0; d < ImageDimension; ++d)
   {

Modules/Core/SpatialObjects/include/itkSpatialObjectToImageStatisticsCalculator.hxx

@@ -161,10 +161,9 @@ SpatialObjectToImageStatisticsCalculator<TInputImage, TInputSpatialObject, TSamp
       ptMin[i] = bounds[i * 2];
       ptMax[i] = bounds[i * 2 + 1];
     }
-    auto      indMin = m_Image->TransformPhysicalPointToIndex(ptMin);
-    auto      indMax = m_Image->TransformPhysicalPointToIndex(ptMax);
-    IndexType imageIndex = m_Image->GetLargestPossibleRegion().GetIndex();
-    SizeType  imageSize = m_Image->GetLargestPossibleRegion().GetSize();
+    auto indMin = m_Image->TransformPhysicalPointToIndex(ptMin);
+    auto indMax = m_Image->TransformPhysicalPointToIndex(ptMax);
+    const auto [imageIndex, imageSize] = m_Image->GetLargestPossibleRegion();
     for (unsigned int i = 0; i < Self::ObjectDimension; ++i)
     {
       if (indMin[i] > indMax[i])

Modules/Filtering/BiasCorrection/include/itkMRIBiasFieldCorrectionFilter.hxx

@@ -599,8 +599,7 @@ MRIBiasFieldCorrectionFilter<TInputImage, TOutputImage, TMaskImage>::CorrectInte
   IndexValueType lastSlice =
     region.GetIndex()[m_SlicingDirection] + static_cast<IndexValueType>(region.GetSize()[m_SlicingDirection]);
   InputImageRegionType sliceRegion;
-  InputImageIndexType  index = region.GetIndex();
-  InputImageSizeType   size = region.GetSize();
+  auto [index, size] = region;
 
   sliceRegion.SetSize(size);
   BiasFieldType bias = this->EstimateBiasField(sliceRegion, 0, m_InterSliceCorrectionMaximumIteration);
@@ -882,8 +881,7 @@ MRIBiasFieldCorrectionFilter<TInputImage, TOutputImage, TMaskImage>::AdjustSlabR
   SlabRegionVectorType & slabs,
   OutputImageRegionType  requestedRegion)
 {
-  OutputImageIndexType indexFirst = requestedRegion.GetIndex();
-  OutputImageSizeType  size = requestedRegion.GetSize();
+  const auto [indexFirst, size] = requestedRegion;
   OutputImageIndexType indexLast = indexFirst;
 
   for (SizeValueType i = 0; i < ImageDimension; ++i)

Modules/Filtering/Convolution/include/itkConvolutionImageFilterBase.hxx

@@ -52,10 +52,7 @@ ConvolutionImageFilterBase<TInputImage, TKernelImage, TOutputImage>::GetValidReg
 {
   typename InputImageType::ConstPointer inputPtr = this->GetInput();
 
-  InputRegionType inputLargestPossibleRegion = inputPtr->GetLargestPossibleRegion();
-
-  OutputIndexType validIndex = inputLargestPossibleRegion.GetIndex();
-  OutputSizeType  validSize = inputLargestPossibleRegion.GetSize();
+  auto [validIndex, validSize] = inputPtr->GetLargestPossibleRegion();
 
   // Shrink the output largest possible region by the kernel radius.
   KernelSizeType kernelSize = this->GetKernelImage()->GetLargestPossibleRegion().GetSize();

Modules/Filtering/Convolution/include/itkFFTConvolutionImageFilter.hxx

@@ -149,15 +149,11 @@ FFTConvolutionImageFilter<TInputImage, TKernelImage, TOutputImage, TInternalPrec
 {
   float remainingProgress = 1.0f;
 
-  InputRegionType  inputLargestRegion = input->GetLargestPossibleRegion();
-  InputSizeType    inputLargestSize = inputLargestRegion.GetSize();
-  InputIndexType   inputLargestIndex = inputLargestRegion.GetIndex();
-  InputRegionType  inputRequestedRegion = input->GetRequestedRegion();
-  InputSizeType    inputRequestedSize = inputRequestedRegion.GetSize();
-  InputIndexType   inputRequestedIndex = inputRequestedRegion.GetIndex();
+  InputRegionType inputLargestRegion = input->GetLargestPossibleRegion();
+  const auto [inputLargestIndex, inputLargestSize] = inputLargestRegion;
+  const auto [inputRequestedIndex, inputRequestedSize] = input->GetRequestedRegion();
   OutputRegionType outputRequestedRegion = this->GetOutput()->GetRequestedRegion();
-  OutputSizeType   outputRequestedSize = outputRequestedRegion.GetSize();
-  OutputIndexType  outputRequestedIndex = outputRequestedRegion.GetIndex();
+  const auto [outputRequestedIndex, outputRequestedSize] = outputRequestedRegion;
 
   // Pad the input image such that the requested region, expanded by
   // twice the kernel radius, lies entirely within the buffered region.

Modules/Filtering/DisplacementField/include/itkGaussianExponentialDiffeomorphicTransform.hxx

@@ -190,9 +190,7 @@ GaussianExponentialDiffeomorphicTransform<TParametersValueType, VDimension>::Gau
   }
   ScalarType weight2 = 1.0 - weight1;
 
-  const typename ConstantVelocityFieldType::RegionType region = field->GetLargestPossibleRegion();
-  const typename ConstantVelocityFieldType::SizeType   size = region.GetSize();
-  const typename ConstantVelocityFieldType::IndexType  startIndex = region.GetIndex();
+  const auto [startIndex, size] = field->GetLargestPossibleRegion();
 
   ImageRegionIteratorWithIndex<ConstantVelocityFieldType>      fieldIt(field, field->GetLargestPossibleRegion());
   ImageRegionConstIteratorWithIndex<ConstantVelocityFieldType> smoothedFieldIt(smoothField,

Modules/Filtering/DisplacementField/include/itkGaussianSmoothingOnUpdateDisplacementFieldTransform.hxx

@@ -184,8 +184,7 @@ GaussianSmoothingOnUpdateDisplacementFieldTransform<TParametersValueType, VDimen
   ScalarType weight2 = 1.0 - weight1;
 
   const typename DisplacementFieldType::RegionType region = field->GetLargestPossibleRegion();
-  const typename DisplacementFieldType::SizeType   size = region.GetSize();
-  const typename DisplacementFieldType::IndexType  startIndex = region.GetIndex();
+  const auto [startIndex, size] = region;
 
   ImageRegionIteratorWithIndex<DisplacementFieldType>      fieldIt(field, field->GetLargestPossibleRegion());
   ImageRegionConstIteratorWithIndex<DisplacementFieldType> smoothedFieldIt(smoothField,

Modules/Filtering/DisplacementField/include/itkGaussianSmoothingOnUpdateTimeVaryingVelocityFieldTransform.hxx

@@ -196,11 +196,9 @@ GaussianSmoothingOnUpdateTimeVaryingVelocityFieldTransform<TParametersValueType,
   }
   ScalarType weight2 = 1.0 - weight1;
 
-  using TimeVaryingVelocityFieldSizeType = typename VelocityFieldType::SizeType;
   using TimeVaryingVelocityFieldIndexType = typename VelocityFieldType::IndexType;
 
-  TimeVaryingVelocityFieldSizeType  size = field->GetLargestPossibleRegion().GetSize();
-  TimeVaryingVelocityFieldIndexType startIndex = field->GetLargestPossibleRegion().GetIndex();
+  const auto [startIndex, size] = field->GetLargestPossibleRegion();
 
   ImageRegionIteratorWithIndex<VelocityFieldType>      fieldIt(field, field->GetLargestPossibleRegion());
   ImageRegionConstIteratorWithIndex<VelocityFieldType> smoothedFieldIt(smoothField,

Modules/Filtering/DisplacementField/include/itkInvertDisplacementFieldImageFilter.hxx

@@ -168,10 +168,8 @@ template <typename TInputImage, typename TOutputImage>
 void
 InvertDisplacementFieldImageFilter<TInputImage, TOutputImage>::DynamicThreadedGenerateData(const RegionType & region)
 {
-  const typename DisplacementFieldType::RegionType fullRegion = this->m_ComposedField->GetRequestedRegion();
-  const typename DisplacementFieldType::SizeType   size = fullRegion.GetSize();
-  const typename DisplacementFieldType::IndexType  startIndex = fullRegion.GetIndex();
-  const typename DisplacementFieldType::PixelType  zeroVector{};
+  const auto [startIndex, size] = this->m_ComposedField->GetRequestedRegion();
+  const typename DisplacementFieldType::PixelType zeroVector{};
 
   ImageRegionIterator<DisplacementFieldType> ItE(this->m_ComposedField, region);
   ImageRegionIterator<RealImageType>         ItS(this->m_ScaledNormImage, region);

Modules/Filtering/DisplacementField/include/itkTimeVaryingVelocityFieldIntegrationImageFilter.hxx

@@ -187,11 +187,7 @@ TimeVaryingVelocityFieldIntegrationImageFilter<TTimeVaryingVelocityField, TDispl
   {
     typename TimeVaryingVelocityFieldType::PointType spaceTimeOrigin = inputField->GetOrigin();
 
-    using RegionType = typename TimeVaryingVelocityFieldType::RegionType;
-    RegionType region = inputField->GetLargestPossibleRegion();
-
-    typename RegionType::IndexType lastIndex = region.GetIndex();
-    typename RegionType::SizeType  size = region.GetSize();
+    auto [lastIndex, size] = inputField->GetLargestPossibleRegion();
     for (unsigned int d = 0; d < InputImageDimension; ++d)
     {
       lastIndex[d] += (size[d] - 1);

Modules/Filtering/DistanceMap/include/itkSignedMaurerDistanceMapImageFilter.hxx

@@ -53,8 +53,7 @@ SignedMaurerDistanceMapImageFilter<TInputImage, TOutputImage>::SplitRequestedReg
 
   const OutputSizeType & requestedRegionSize = splitRegion.GetSize();
 
-  OutputIndexType splitIndex = splitRegion.GetIndex();
-  OutputSizeType  splitSize = splitRegion.GetSize();
+  auto [splitIndex, splitSize] = splitRegion;
 
   // split on the outermost dimension available
   // and avoid the current dimension

Modules/Filtering/FFT/include/itkHalfToFullHermitianImageFilter.hxx

@@ -119,8 +119,7 @@ HalfToFullHermitianImageFilter<TInputImage>::DynamicThreadedGenerateData(
 
   // Now copy the redundant complex conjugate region, if there is one
   // in this thread's output region.
-  OutputImageIndexType outputRegionIndex = outputRegionForThread.GetIndex();
-  OutputImageSizeType  outputRegionSize = outputRegionForThread.GetSize();
+  const auto [outputRegionIndex, outputRegionSize] = outputRegionForThread;
   OutputImageIndexType outputRegionMaximumIndex = outputRegionIndex + outputRegionSize;
 
   if (outputRegionMaximumIndex[0] > inputRegionMaximumIndex[0])
@@ -140,9 +139,8 @@ HalfToFullHermitianImageFilter<TInputImage>::DynamicThreadedGenerateData(
       OutputImageIndexType index(conjugateIndex);
       for (unsigned int i = 0; i < ImageDimension; ++i)
       {
-        OutputImageRegionType outputLargestPossibleRegion = outputPtr->GetLargestPossibleRegion();
-        OutputImageIndexType  outputLargestPossibleRegionIndex = outputLargestPossibleRegion.GetIndex();
-        OutputImageSizeType   outputLargestPossibleRegionSize = outputLargestPossibleRegion.GetSize();
+        const auto [outputLargestPossibleRegionIndex, outputLargestPossibleRegionSize] =
+          outputPtr->GetLargestPossibleRegion();
         if (conjugateIndex[i] != outputLargestPossibleRegionIndex[i])
         {
           index[i] = outputLargestPossibleRegionSize[i] - conjugateIndex[i] + 2 * outputLargestPossibleRegionIndex[i];

Modules/Filtering/FFT/include/itkRealToHalfHermitianForwardFFTImageFilter.hxx

@@ -43,8 +43,7 @@ RealToHalfHermitianForwardFFTImageFilter<TInputImage, TOutputImage>::GenerateOut
   // This is all based on the same function in itk::ShrinkImageFilter
   // ShrinkImageFilter also modifies the image spacing, but spacing
   // has no meaning in the result of an FFT.
-  const InputSizeType  inputSize = inputPtr->GetLargestPossibleRegion().GetSize();
-  const InputIndexType inputStartIndex = inputPtr->GetLargestPossibleRegion().GetIndex();
+  const auto [inputStartIndex, inputSize] = inputPtr->GetLargestPossibleRegion();
 
   OutputSizeType  outputSize;
   OutputIndexType outputStartIndex;

Modules/Filtering/FFT/include/itkVnlHalfHermitianToRealInverseFFTImageFilter.hxx

@@ -41,10 +41,8 @@ VnlHalfHermitianToRealInverseFFTImageFilter<TInputImage, TOutputImage>::Generate
   // reports the beginning and the end of the process.
   ProgressReporter progress(this, 0, 1);
 
-  const InputSizeType   inputSize = inputPtr->GetLargestPossibleRegion().GetSize();
-  const InputIndexType  inputIndex = inputPtr->GetLargestPossibleRegion().GetIndex();
-  const OutputSizeType  outputSize = outputPtr->GetLargestPossibleRegion().GetSize();
-  const OutputIndexType outputIndex = outputPtr->GetLargestPossibleRegion().GetIndex();
+  const auto [inputIndex, inputSize] = inputPtr->GetLargestPossibleRegion();
+  const auto [outputIndex, outputSize] = outputPtr->GetLargestPossibleRegion();
 
   // Allocate output buffer memory
   outputPtr->SetBufferedRegion(outputPtr->GetRequestedRegion());

Modules/Filtering/ImageFeature/include/itkMaskFeaturePointSelectionFilter.hxx

@@ -146,8 +146,7 @@ MaskFeaturePointSelectionFilter<TImage, TMask, TFeatures>::GenerateData()
   }
 
   // set safe region for picking feature points depending on whether tensors are computed
-  IndexType safeIndex = region.GetIndex();
-  SizeType  safeSize = region.GetSize();
+  auto [safeIndex, safeSize] = region;
 
   if (m_ComputeStructureTensors)
   {

Modules/Filtering/ImageFrequency/include/itkFrequencyShiftedFFTLayoutImageRegionConstIteratorWithIndex.h

@@ -249,8 +249,7 @@ class ITK_TEMPLATE_EXPORT FrequencyShiftedFFTLayoutImageRegionConstIteratorWithI
   void
   Init()
   {
-    IndexType minIndex = this->m_Image->GetLargestPossibleRegion().GetIndex();
-    SizeType  sizeImage = this->m_Image->GetLargestPossibleRegion().GetSize();
+    const auto [minIndex, sizeImage] = this->m_Image->GetLargestPossibleRegion();
     for (unsigned int dim = 0; dim < ImageType::ImageDimension; ++dim)
     {
       this->m_ZeroFrequencyIndex[dim] =

Modules/Filtering/ImageGrid/include/itkCropImageFilter.hxx

@@ -36,8 +36,7 @@ CropImageFilter<TInputImage, TOutputImage>::GenerateOutputInformation()
   SizeType             sz;
   OutputImageIndexType idx;
 
-  InputImageSizeType  input_sz = inputPtr->GetLargestPossibleRegion().GetSize();
-  InputImageIndexType input_idx = inputPtr->GetLargestPossibleRegion().GetIndex();
+  const auto [input_idx, input_sz] = inputPtr->GetLargestPossibleRegion();
 
   for (unsigned int i = 0; i < InputImageDimension; ++i)
   {

Modules/Filtering/ImageGrid/include/itkCyclicShiftImageFilter.hxx

@@ -57,8 +57,7 @@ CyclicShiftImageFilter<TInputImage, TOutputImage>::DynamicThreadedGenerateData(
   const InputImageType * inputImage = this->GetInput();
 
   // The index and size of the image needed to compute the shift
-  const IndexType outIdx = this->GetOutput()->GetLargestPossibleRegion().GetIndex();
-  const SizeType  outSize = this->GetOutput()->GetLargestPossibleRegion().GetSize();
+  const auto [outIdx, outSize] = this->GetOutput()->GetLargestPossibleRegion();
 
   TotalProgressReporter progress(this, this->GetOutput()->GetRequestedRegion().GetNumberOfPixels());