STYLE: Remove redundant typename in type aliases

Examples/Filtering/SpatialObjectToImage1.cxx

@@ -186,9 +186,9 @@ main(int argc, char * argv[])
   // Software Guide : BeginCodeSnippet
   ellipse->SetRadiusInObjectSpace(size[0] * 0.2 * spacing[0]);
 
-  typename TubeType::PointType         point;
-  typename TubeType::TubePointType     tubePoint;
-  typename TubeType::TubePointListType tubePointList;
+  TubeType::PointType         point;
+  TubeType::TubePointType     tubePoint;
+  TubeType::TubePointListType tubePointList;
   point[0] = size[0] * 0.2 * spacing[0];
   point[1] = size[1] * 0.2 * spacing[1];
   point[2] = size[2] * 0.2 * spacing[2];

Examples/Filtering/SpatialObjectToImage3.cxx

@@ -142,21 +142,21 @@ main(int argc, char * argv[])
   //  Software Guide : EndLatex
 
   // Software Guide : BeginCodeSnippet
-  constexpr unsigned int                      numberOfPoints = 6;
-  typename PolygonType::PointType             point;
-  typename PolygonType::PointType::VectorType radial;
+  constexpr unsigned int             numberOfPoints = 6;
+  PolygonType::PointType             point;
+  PolygonType::PointType::VectorType radial;
   radial[0] = 0.0;
   radial[1] = 0.0;
   radial[2] = 0.0;
 
-  typename PolygonType::PointType center;
+  PolygonType::PointType center;
   center[0] = 50.0;
   center[1] = 50.0;
   center[2] = 0.0;
 
   constexpr double radius = 40.0;
 
-  typename PolygonType::PolygonPointType polygonPoint;
+  PolygonType::PolygonPointType polygonPoint;
 
   for (unsigned int i = 0; i < numberOfPoints; ++i)
   {

Modules/Core/Common/include/itkAnatomicalOrientation.h

@@ -54,7 +54,7 @@ class ITKCommon_EXPORT AnatomicalOrientation
 {
 public:
   static constexpr unsigned int Dimension = 3;
-  using DirectionType = typename ImageBase<Dimension>::DirectionType;
+  using DirectionType = ImageBase<Dimension>::DirectionType;
   static constexpr unsigned int ImageDimension = Dimension;
 
 #ifndef ITK_FUTURE_LEGACY_REMOVE
@@ -563,16 +563,16 @@ class ITKCommon_EXPORT AnatomicalOrientation
 
 /** Outputs unambiguous anatomical orientation names such as "right-to-left". */
 ITKCommon_EXPORT std::ostream &
-                 operator<<(std::ostream & out, typename AnatomicalOrientation::CoordinateEnum value);
+                 operator<<(std::ostream & out, AnatomicalOrientation::CoordinateEnum value);
 
 /** Outputs the PositiveEnum encoding as a string such as "LPS". */
 ITKCommon_EXPORT std::ostream &
-                 operator<<(std::ostream & out, typename AnatomicalOrientation::PositiveEnum value);
+                 operator<<(std::ostream & out, AnatomicalOrientation::PositiveEnum value);
 
 
 /** Outputs the NegativeEnum encoding as a string such as "RAI" */
 ITKCommon_EXPORT std::ostream &
-                 operator<<(std::ostream & out, typename AnatomicalOrientation::NegativeEnum value);
+                 operator<<(std::ostream & out, AnatomicalOrientation::NegativeEnum value);
 
 ITKCommon_EXPORT std::ostream &
                  operator<<(std::ostream & out, const AnatomicalOrientation & orientation);

Modules/Core/Common/include/itkCompensatedSummation.hxx

@@ -142,7 +142,7 @@ CompensatedSummation<TFloat>::GetSum() const -> const AccumulateType &
 
 
 template <typename TFloat>
-CompensatedSummation<TFloat>::operator typename CompensatedSummation<TFloat>::FloatType() const
+CompensatedSummation<TFloat>::operator FloatType() const
 {
   return this->m_Sum;
 }

Modules/Core/Common/include/itkFloodFilledFunctionConditionalConstIterator.h

@@ -52,7 +52,7 @@ class ITK_TEMPLATE_EXPORT FloodFilledFunctionConditionalConstIterator : public C
   using IndexType = typename TImage::IndexType;
 
   /** Index ContainerType */
-  using SeedsContainerType = typename std::vector<IndexType>;
+  using SeedsContainerType = std::vector<IndexType>;
 
   /** Size type alias support. */
   using SizeType = typename TImage::SizeType;

Modules/Core/Common/include/itkFloodFilledFunctionConditionalConstIterator.hxx

@@ -105,7 +105,7 @@ void
 FloodFilledFunctionConditionalConstIterator<TImage, TFunction>::FindSeedPixel()
 {
   // Create an iterator that will walk the input image
-  using IRIType = typename itk::ImageRegionConstIterator<TImage>;
+  using IRIType = itk::ImageRegionConstIterator<TImage>;
 
   // Now we search the input image for the first pixel which is inside
   // the function of interest

Modules/Core/Common/include/itkImageDuplicator.hxx

@@ -64,8 +64,7 @@ ImageDuplicator<TInputImage>::PrintSelf(std::ostream & os, Indent indent) const
   itkPrintSelfObjectMacro(InputImage);
   itkPrintSelfObjectMacro(DuplicateImage);
 
-  os << indent
-     << "InternalImageTime: " << static_cast<typename NumericTraits<ModifiedTimeType>::PrintType>(m_InternalImageTime)
+  os << indent << "InternalImageTime: " << static_cast<NumericTraits<ModifiedTimeType>::PrintType>(m_InternalImageTime)
      << std::endl;
 }
 } // end namespace itk

Modules/Core/Common/include/itkImageRandomConstIteratorWithIndex.h

@@ -230,7 +230,7 @@ class ITK_TEMPLATE_EXPORT ImageRandomConstIteratorWithIndex : public ImageConstI
   void
   RandomJump();
 
-  using GeneratorPointer = typename Statistics::MersenneTwisterRandomVariateGenerator::Pointer;
+  using GeneratorPointer = Statistics::MersenneTwisterRandomVariateGenerator::Pointer;
   GeneratorPointer m_Generator{ Statistics::MersenneTwisterRandomVariateGenerator::New() };
   SizeValueType    m_NumberOfSamplesRequested{};
   SizeValueType    m_NumberOfSamplesDone{};

Modules/Core/Common/include/itkImageRandomConstIteratorWithOnlyIndex.h

@@ -232,7 +232,7 @@ class ITK_TEMPLATE_EXPORT ImageRandomConstIteratorWithOnlyIndex : public ImageCo
   void
   RandomJump();
 
-  using GeneratorPointer = typename Statistics::MersenneTwisterRandomVariateGenerator::Pointer;
+  using GeneratorPointer = Statistics::MersenneTwisterRandomVariateGenerator::Pointer;
   GeneratorPointer m_Generator{ Statistics::MersenneTwisterRandomVariateGenerator::New() };
   SizeValueType    m_NumberOfSamplesRequested{};
   SizeValueType    m_NumberOfSamplesDone{};

Modules/Core/Common/include/itkImageRandomNonRepeatingConstIteratorWithIndex.h

@@ -65,7 +65,7 @@ class NodeOfPermutation
 class RandomPermutation
 {
 public:
-  using GeneratorPointer = typename Statistics::MersenneTwisterRandomVariateGenerator::Pointer;
+  using GeneratorPointer = Statistics::MersenneTwisterRandomVariateGenerator::Pointer;
   NodeOfPermutation * m_Permutation;
   GeneratorPointer    m_Generator;
   SizeValueType       m_Size;

Modules/Core/Common/include/itkImageSink.h

@@ -77,7 +77,7 @@ class ImageSink
 
   /** SmartPointer to a region splitting object */
   using SplitterType = ImageRegionSplitterBase;
-  using RegionSplitterPointer = typename SplitterType::Pointer;
+  using RegionSplitterPointer = SplitterType::Pointer;
 
   using typename Superclass::DataObjectIdentifierType;
 

Modules/Core/Common/include/itkObjectStore.hxx

@@ -134,9 +134,8 @@ ObjectStore<TObjectType>::PrintSelf(std::ostream & os, Indent indent) const
   Superclass::PrintSelf(os, indent);
 
   os << indent << "GrowthStrategy: " << m_GrowthStrategy << std::endl;
-  os << indent << "Size: " << static_cast<typename NumericTraits<SizeValueType>::PrintType>(m_Size) << std::endl;
-  os << indent
-     << "LinearGrowthSize: " << static_cast<typename NumericTraits<SizeValueType>::PrintType>(m_LinearGrowthSize)
+  os << indent << "Size: " << static_cast<NumericTraits<SizeValueType>::PrintType>(m_Size) << std::endl;
+  os << indent << "LinearGrowthSize: " << static_cast<NumericTraits<SizeValueType>::PrintType>(m_LinearGrowthSize)
      << std::endl;
   os << indent << "FreeList: " << m_FreeList << std::endl;
 }

Modules/Core/Common/include/itkResourceProbe.hxx

@@ -72,12 +72,9 @@ ResourceProbe<ValueType, MeanType>::Print(std::ostream & os, Indent indent) cons
   os << indent << "StandardError: " << static_cast<typename NumericTraits<ValueType>::PrintType>(m_StandardError)
      << std::endl;
 
-  os << indent << "NumberOfStarts: " << static_cast<typename NumericTraits<CountType>::PrintType>(m_NumberOfStarts)
-     << std::endl;
-  os << indent << "NumberOfStops: " << static_cast<typename NumericTraits<CountType>::PrintType>(m_NumberOfStops)
-     << std::endl;
-  os << indent
-     << "NumberOfIteration: " << static_cast<typename NumericTraits<CountType>::PrintType>(m_NumberOfIteration)
+  os << indent << "NumberOfStarts: " << static_cast<NumericTraits<CountType>::PrintType>(m_NumberOfStarts) << std::endl;
+  os << indent << "NumberOfStops: " << static_cast<NumericTraits<CountType>::PrintType>(m_NumberOfStops) << std::endl;
+  os << indent << "NumberOfIteration: " << static_cast<NumericTraits<CountType>::PrintType>(m_NumberOfIteration)
      << std::endl;
 
   os << indent << "ProbeValueList: " << m_ProbeValueList << std::endl;

Modules/Core/Common/include/itkSpatialOrientationAdapter.h

@@ -88,7 +88,7 @@ class ITKCommon_EXPORT SpatialOrientationAdapter
   using ImageType = ImageBase<3>;
 
   /** Direction Cosines type alias. */
-  using DirectionType = typename ImageType::DirectionType;
+  using DirectionType = ImageType::DirectionType;
 
   /** Constructor */
   SpatialOrientationAdapter() = default;

Modules/Core/Common/include/itkStreamingImageFilter.h

@@ -76,7 +76,7 @@ class ITK_TEMPLATE_EXPORT StreamingImageFilter : public ImageToImageFilter<TInpu
 
   /** SmartPointer to a region splitting object */
   using SplitterType = ImageRegionSplitterBase;
-  using RegionSplitterPointer = typename SplitterType::Pointer;
+  using RegionSplitterPointer = SplitterType::Pointer;
 
   /** Set the number of pieces to divide the input.  The upstream pipeline
    * will be executed this many times. */

Modules/Core/Common/src/itkAnatomicalOrientation.cxx

@@ -79,8 +79,8 @@ AnatomicalOrientation::CreateFromPositiveStringEncoding(std::string str)
 {
   std::transform(str.begin(), str.end(), str.begin(), ::toupper);
 
-  const std::map<std::string, typename AnatomicalOrientation::PositiveEnum> & stringToCode = GetStringToCode();
-  auto                                                                        iter = stringToCode.find(str);
+  const std::map<std::string, AnatomicalOrientation::PositiveEnum> & stringToCode = GetStringToCode();
+  auto                                                               iter = stringToCode.find(str);
   if (iter == stringToCode.end())
   {
     return { PositiveEnum::INVALID };
@@ -136,7 +136,7 @@ AnatomicalOrientation::GetCoordinateTerm(CoordinateMajornessTermsEnum cmt) const
 }
 
 
-const std::map<typename AnatomicalOrientation::PositiveEnum, std::string> &
+const std::map<AnatomicalOrientation::PositiveEnum, std::string> &
 AnatomicalOrientation::GetCodeToString()
 {
   auto createCodeToString = []() -> std::map<PositiveEnum, std::string> {
@@ -247,7 +247,7 @@ AnatomicalOrientation::ConvertDirectionToPositiveEnum(const DirectionType & dir)
 }
 
 
-typename AnatomicalOrientation::DirectionType
+AnatomicalOrientation::DirectionType
 AnatomicalOrientation::ConvertPositiveEnumToDirection(PositiveEnum orientationEnum)
 {
   const AnatomicalOrientation o(orientationEnum);
@@ -281,7 +281,7 @@ AnatomicalOrientation::ConvertPositiveEnumToDirection(PositiveEnum orientationEn
 }
 
 std::ostream &
-operator<<(std::ostream & out, typename AnatomicalOrientation::CoordinateEnum value)
+operator<<(std::ostream & out, AnatomicalOrientation::CoordinateEnum value)
 {
   switch (value)
   {
@@ -305,13 +305,13 @@ operator<<(std::ostream & out, typename AnatomicalOrientation::CoordinateEnum va
 }
 
 std::ostream &
-operator<<(std::ostream & out, typename AnatomicalOrientation::PositiveEnum value)
+operator<<(std::ostream & out, AnatomicalOrientation::PositiveEnum value)
 {
   return out << AnatomicalOrientation(value).GetAsPositiveStringEncoding();
 }
 
 std::ostream &
-operator<<(std::ostream & out, typename AnatomicalOrientation::NegativeEnum value)
+operator<<(std::ostream & out, AnatomicalOrientation::NegativeEnum value)
 {
   return out << AnatomicalOrientation(value).GetAsNegativeStringEncoding();
 }

Modules/Core/Common/test/itkAnnulusOperatorTest.cxx

@@ -118,15 +118,15 @@ itkAnnulusOperatorTest(int, char *[])
   annulus.SetThickness(thickness);
   ITK_TEST_SET_GET_VALUE(thickness, annulus.GetThickness());
 
-  constexpr typename OperatorType::PixelType exteriorValue{ 1 };
+  constexpr OperatorType::PixelType exteriorValue{ 1 };
   annulus.SetExteriorValue(exteriorValue);
   ITK_TEST_SET_GET_VALUE(exteriorValue, annulus.GetExteriorValue());
 
-  constexpr typename OperatorType::PixelType annulusValue{ 8 };
+  constexpr OperatorType::PixelType annulusValue{ 8 };
   annulus.SetAnnulusValue(annulusValue);
   ITK_TEST_SET_GET_VALUE(annulusValue, annulus.GetAnnulusValue());
 
-  constexpr typename OperatorType::PixelType interiorValue{ 4 };
+  constexpr OperatorType::PixelType interiorValue{ 4 };
   annulus.SetInteriorValue(interiorValue);
   ITK_TEST_SET_GET_VALUE(interiorValue, annulus.GetInteriorValue());
 

Modules/Core/Common/test/itkConstShapedNeighborhoodIteratorTest.cxx

@@ -519,7 +519,7 @@ template <typename ImageType>
 class MyDerivedCSNI : public itk::ConstShapedNeighborhoodIterator<ImageType>
 {
 public:
-  using Superclass = typename itk::ConstShapedNeighborhoodIterator<ImageType>;
+  using Superclass = itk::ConstShapedNeighborhoodIterator<ImageType>;
   using typename Superclass::SizeType;
   using typename Superclass::IndexType;
   using typename Superclass::RadiusType;

Modules/Core/Common/test/itkConstShapedNeighborhoodIteratorTest2.cxx

@@ -27,7 +27,7 @@ template <typename ImageType>
 class MyDerivedCSNI : public itk::ConstShapedNeighborhoodIterator<ImageType>
 {
 public:
-  using Superclass = typename itk::ConstShapedNeighborhoodIterator<ImageType>;
+  using Superclass = itk::ConstShapedNeighborhoodIterator<ImageType>;
   using typename Superclass::SizeType;
   using typename Superclass::IndexType;
   using typename Superclass::RadiusType;

Modules/Core/Common/test/itkMetaDataDictionaryGTest.cxx

@@ -39,7 +39,7 @@ createMetaDataDictionary()
   itk::EncapsulateMetaData<float>(metaDataDictionary, "two", static_cast<float>(2));
 
   using ObjectType = itk::LightObject;
-  using PointerType = typename ObjectType::Pointer;
+  using PointerType = ObjectType::Pointer;
   const PointerType obj = ObjectType::New();
   itk::EncapsulateMetaData<PointerType>(metaDataDictionary, "object", obj);
 

Modules/Core/Common/test/itkPointSetTest.cxx

@@ -31,7 +31,7 @@
 using PointSet = itk::PointSet<int>;
 using PointType = PointSet::PointType;
 using PointsVectorContainer = PointSet::PointsVectorContainer;
-using PointsVectorContainerPointer = typename PointsVectorContainer::Pointer;
+using PointsVectorContainerPointer = PointsVectorContainer::Pointer;
 
 /**
  * The point set that is created consists of a 100 random points.

Modules/Core/Common/test/itkPointSetToImageFilterTest1.cxx

@@ -76,14 +76,13 @@ itkPointSetToImageFilterTest1(int argc, char * argv[])
   filter->SetOrigin(origin);
   ITK_TEST_SET_GET_VALUE(origin, filter->GetOrigin());
 
-  typename BinaryImageType::DirectionType direction;
+  BinaryImageType::DirectionType direction;
   direction.SetIdentity();
   filter->SetDirection(direction);
   ITK_TEST_SET_GET_VALUE(direction, filter->GetDirection());
 
-  constexpr typename BinaryImageType::ValueType insideValue{
-    itk::NumericTraits<typename BinaryImageType::ValueType>::OneValue()
-  };
+  constexpr
+    typename BinaryImageType::ValueType insideValue{ itk::NumericTraits<BinaryImageType::ValueType>::OneValue() };
   filter->SetInsideValue(insideValue);
   ITK_TEST_SET_GET_VALUE(insideValue, filter->GetInsideValue());
 

Modules/Core/Common/test/itkSpatialOrientationAdaptorGTest.cxx

@@ -24,7 +24,7 @@
 TEST(SpatialOrientationAdaptor, test1)
 {
   using ImageType = itk::Image<float, 3>;
-  using DirectionType = typename ImageType::DirectionType;
+  using DirectionType = ImageType::DirectionType;
 
   itk::SpatialOrientationAdapter adapter;
 

Modules/Core/GPUCommon/include/itkGPUImageDataManager.h

@@ -88,10 +88,10 @@ class ITK_TEMPLATE_EXPORT GPUImageDataManager : public GPUDataManager
 private:
   WeakPointer<ImageType> m_Image{}; // WeakPointer has to be used here
                                     // to avoid SmartPointer loop
-  int                              m_BufferedRegionIndex[ImageType::ImageDimension]{};
-  int                              m_BufferedRegionSize[ImageType::ImageDimension]{};
-  typename GPUDataManager::Pointer m_GPUBufferedRegionIndex{};
-  typename GPUDataManager::Pointer m_GPUBufferedRegionSize{};
+  int                     m_BufferedRegionIndex[ImageType::ImageDimension]{};
+  int                     m_BufferedRegionSize[ImageType::ImageDimension]{};
+  GPUDataManager::Pointer m_GPUBufferedRegionIndex{};
+  GPUDataManager::Pointer m_GPUBufferedRegionSize{};
 };
 
 } // namespace itk

Modules/Core/GPUCommon/include/itkGPUImageToImageFilter.h

@@ -98,7 +98,7 @@ class ITK_TEMPLATE_EXPORT GPUImageToImageFilter : public TParentImageFilter
   {}
 
   // GPU kernel manager
-  typename GPUKernelManager::Pointer m_GPUKernelManager{};
+  GPUKernelManager::Pointer m_GPUKernelManager{};
 
   // GPU kernel handle - kernel should be defined in specific filter (not in the
   // base class)

Modules/Core/ImageAdaptors/include/itkImageAdaptor.h

@@ -522,7 +522,7 @@ class ITK_TEMPLATE_EXPORT ImageAdaptor : public ImageBase<TImage::ImageDimension
   // to have the correct vector length of the image.
   template <typename TPixelType>
   void
-  UpdateAccessor(typename itk::VectorImage<TPixelType, ImageDimension> * itkNotUsed(dummy))
+  UpdateAccessor(itk::VectorImage<TPixelType, ImageDimension> * itkNotUsed(dummy))
   {
     this->m_PixelAccessor.SetVectorLength(this->m_Image->GetNumberOfComponentsPerPixel());
   }

Modules/Core/ImageFunction/include/itkBSplineInterpolateImageFunction.hxx

@@ -75,8 +75,7 @@ BSplineInterpolateImageFunction<TImageType, TCoordinate, TCoefficientType>::Prin
 
   itkPrintSelfBooleanMacro(UseImageDirection);
 
-  os << indent
-     << "NumberOfWorkUnits: " << static_cast<typename NumericTraits<ThreadIdType>::PrintType>(m_NumberOfWorkUnits)
+  os << indent << "NumberOfWorkUnits: " << static_cast<NumericTraits<ThreadIdType>::PrintType>(m_NumberOfWorkUnits)
      << std::endl;
 
   os << indent << "ThreadedEvaluateIndex: ";

Modules/Core/ImageFunction/test/itkLinearInterpolateImageFunctionTest.cxx

@@ -41,16 +41,15 @@ RunLinearInterpolateTest()
   using IndexType = typename ImageType::IndexType;
 
   using CoordinateType = float;
-  using ContinuousIndexType = typename itk::ContinuousIndex<CoordinateType, Dimensions>;
+  using ContinuousIndexType = itk::ContinuousIndex<CoordinateType, Dimensions>;
 
   using AccumulatorType = typename ContinuousIndexType::ValueType;
 
-  using PointType = typename itk::Point<CoordinateType, Dimensions>;
+  using PointType = itk::Point<CoordinateType, Dimensions>;
 
-  using InterpolatorType = typename itk::LinearInterpolateImageFunction<ImageType, CoordinateType>;
-  using VectorInterpolatorType = typename itk::LinearInterpolateImageFunction<VectorImageType, CoordinateType>;
-  using VariableVectorInterpolatorType =
-    typename itk::LinearInterpolateImageFunction<VariableVectorImageType, CoordinateType>;
+  using InterpolatorType = itk::LinearInterpolateImageFunction<ImageType, CoordinateType>;
+  using VectorInterpolatorType = itk::LinearInterpolateImageFunction<VectorImageType, CoordinateType>;
+  using VariableVectorInterpolatorType = itk::LinearInterpolateImageFunction<VariableVectorImageType, CoordinateType>;
 
   using InterpolatedVectorType = typename VectorInterpolatorType::OutputType;
   using InterpolatedVariableVectorType = typename VariableVectorInterpolatorType::OutputType;

Modules/Core/ImageFunction/test/itkNearestNeighborInterpolateImageFunctionTest.cxx

@@ -126,7 +126,7 @@ itkNearestNeighborInterpolateImageFunctionTest(int, char *[])
 
   interpolator->SetInputImage(image);
 
-  typename ImageType::SizeType radius{};
+  ImageType::SizeType radius{};
   for (unsigned int d = 0; d < Dimension; ++d)
   {
     ITK_TEST_SET_GET_VALUE(radius[d], interpolator->GetRadius()[d]);