diff --git a/applications/rtkprojectionmatrix/rtkprojectionmatrix.cxx b/applications/rtkprojectionmatrix/rtkprojectionmatrix.cxx
index 10b3c15f7..99f393691 100644
--- a/applications/rtkprojectionmatrix/rtkprojectionmatrix.cxx
+++ b/applications/rtkprojectionmatrix/rtkprojectionmatrix.cxx
@@ -30,7 +30,7 @@ namespace rtk
 {
 namespace Functor
 {
-template <class TInput, class TCoordRepType, class TOutput = TCoordRepType>
+template <class TInput, class TCoordinateType, class TOutput = TCoordinateType>
 class StoreSparseMatrixSplatWeightMultiplication
 {
 public:
@@ -53,7 +53,7 @@ class StoreSparseMatrixSplatWeightMultiplication
              TOutput &           output,
              const double        stepLengthInVoxel,
              const double        voxelSize,
-             const TCoordRepType weight)
+             const TCoordinateType weight)
   {
     // One row of the matrix is one ray, it should be thread safe
     m_SystemMatrix.put(
diff --git a/include/rtkForwardWarpImageFilter.h b/include/rtkForwardWarpImageFilter.h
index 155bb62c0..b8cb8c55b 100644
--- a/include/rtkForwardWarpImageFilter.h
+++ b/include/rtkForwardWarpImageFilter.h
@@ -60,8 +60,8 @@ class ITK_TEMPLATE_EXPORT ForwardWarpImageFilter : public itk::WarpImageFilter<T
   using DisplacementType = typename DisplacementFieldType::PixelType;
 
   /** Point type */
-  using CoordRepType = double;
-  using PointType = itk::Point<CoordRepType, Self::ImageDimension>;
+  using CoordinateType = double;
+  using PointType = itk::Point<CoordinateType, Self::ImageDimension>;
 
   /** Method for creation through the object factory. */
   itkNewMacro(Self);
diff --git a/include/rtkJosephBackAttenuatedProjectionImageFilter.h b/include/rtkJosephBackAttenuatedProjectionImageFilter.h
index b683eae86..ed55956f6 100644
--- a/include/rtkJosephBackAttenuatedProjectionImageFilter.h
+++ b/include/rtkJosephBackAttenuatedProjectionImageFilter.h
@@ -35,7 +35,7 @@ namespace Functor
  *
  * \ingroup RTK Functions
  */
-template <class TInput, class TCoordRepType, class TOutput = TInput>
+template <class TInput, class TCoordinateType, class TOutput = TInput>
 class ITK_TEMPLATE_EXPORT InterpolationWeightMultiplicationAttenuatedBackProjection
 {
 public:
@@ -55,7 +55,7 @@ class ITK_TEMPLATE_EXPORT InterpolationWeightMultiplicationAttenuatedBackProject
   }
 
   inline TOutput
-  operator()(const double stepLengthInVoxel, const TCoordRepType weight, const TInput * p, const int i)
+  operator()(const double stepLengthInVoxel, const TCoordinateType weight, const TInput * p, const int i)
   {
     const double w = weight * stepLengthInVoxel;
 
@@ -150,7 +150,7 @@ class ITK_TEMPLATE_EXPORT ComputeAttenuationCorrectionBackProjection
  *
  * \ingroup RTK Functions
  */
-template <class TInput, class TCoordRepType, class TOutput = TCoordRepType>
+template <class TInput, class TCoordinateType, class TOutput = TCoordinateType>
 class ITK_TEMPLATE_EXPORT SplatWeightMultiplicationAttenuated
 {
 public:
@@ -173,7 +173,7 @@ class ITK_TEMPLATE_EXPORT SplatWeightMultiplicationAttenuated
              TOutput &           output,
              const double        stepLengthInVoxel,
              const double        itkNotUsed(voxelSize),
-             const TCoordRepType weight) const
+             const TCoordinateType weight) const
   {
     output += rayValue * weight * stepLengthInVoxel;
   }
@@ -226,8 +226,8 @@ class ITK_TEMPLATE_EXPORT JosephBackAttenuatedProjectionImageFilter
   using InputPixelType = typename TInputImage::PixelType;
   using OutputPixelType = typename TOutputImage::PixelType;
   using OutputImageRegionType = typename TOutputImage::RegionType;
-  using CoordRepType = double;
-  using VectorType = itk::Vector<CoordRepType, TInputImage::ImageDimension>;
+  using CoordinateType = double;
+  using VectorType = itk::Vector<CoordinateType, TInputImage::ImageDimension>;
   using GeometryType = rtk::ThreeDCircularProjectionGeometry;
   using GeometryPointer = typename GeometryType::Pointer;
 
diff --git a/include/rtkJosephBackProjectionImageFilter.h b/include/rtkJosephBackProjectionImageFilter.h
index de2b86976..3be8603ee 100644
--- a/include/rtkJosephBackProjectionImageFilter.h
+++ b/include/rtkJosephBackProjectionImageFilter.h
@@ -37,7 +37,7 @@ namespace Functor
  *
  * \ingroup RTK Functions
  */
-template <class TInput, class TCoordRepType, class TOutput = TInput>
+template <class TInput, class TCoordinateType, class TOutput = TInput>
 class ITK_TEMPLATE_EXPORT InterpolationWeightMultiplicationBackProjection
 {
 public:
@@ -56,7 +56,7 @@ class ITK_TEMPLATE_EXPORT InterpolationWeightMultiplicationBackProjection
 
   inline TOutput
   operator()(const double        itkNotUsed(stepLengthInVoxel),
-             const TCoordRepType itkNotUsed(weight),
+             const TCoordinateType itkNotUsed(weight),
              const TInput *      itkNotUsed(p),
              const int           itkNotUsed(i)) const
   {
@@ -107,7 +107,7 @@ class ITK_TEMPLATE_EXPORT ValueAlongRay
  *
  * \ingroup RTK Functions
  */
-template <class TInput, class TCoordRepType, class TOutput = TCoordRepType>
+template <class TInput, class TCoordinateType, class TOutput = TCoordinateType>
 class ITK_TEMPLATE_EXPORT SplatWeightMultiplication
 {
 public:
@@ -129,7 +129,7 @@ class ITK_TEMPLATE_EXPORT SplatWeightMultiplication
              TOutput &           output,
              const double        stepLengthInVoxel,
              const double        voxelSize,
-             const TCoordRepType weight) const
+             const TCoordinateType weight) const
   {
     output += rayValue * weight * voxelSize * stepLengthInVoxel;
   }
@@ -174,8 +174,8 @@ class ITK_TEMPLATE_EXPORT JosephBackProjectionImageFilter : public BackProjectio
   using InputPixelType = typename TInputImage::PixelType;
   using OutputPixelType = typename TOutputImage::PixelType;
   using OutputImageRegionType = typename TOutputImage::RegionType;
-  using CoordRepType = double;
-  using VectorType = itk::Vector<CoordRepType, TInputImage::ImageDimension>;
+  using CoordinateType = double;
+  using VectorType = itk::Vector<CoordinateType, TInputImage::ImageDimension>;
   using GeometryType = rtk::ThreeDCircularProjectionGeometry;
   using GeometryPointer = typename GeometryType::Pointer;
 
@@ -298,10 +298,10 @@ class ITK_TEMPLATE_EXPORT JosephBackProjectionImageFilter : public BackProjectio
                          const double           y,
                          const int              ox,
                          const int              oy,
-                         const CoordRepType     minx,
-                         const CoordRepType     miny,
-                         const CoordRepType     maxx,
-                         const CoordRepType     maxy);
+                         const CoordinateType     minx,
+                         const CoordinateType     miny,
+                         const CoordinateType     maxx,
+                         const CoordinateType     maxy);
 
   inline OutputPixelType
   BilinearInterpolation(const double           stepLengthInVoxel,
diff --git a/include/rtkJosephBackProjectionImageFilter.hxx b/include/rtkJosephBackProjectionImageFilter.hxx
index 6389aceb8..61fadfb36 100644
--- a/include/rtkJosephBackProjectionImageFilter.hxx
+++ b/include/rtkJosephBackProjectionImageFilter.hxx
@@ -168,10 +168,10 @@ JosephBackProjectionImageFilter<TInputImage,
       if (notMainDirInf > notMainDirSup)
         std::swap(notMainDirInf, notMainDirSup);
 
-      const CoordRepType minx = box->GetBoxMin()[notMainDirInf];
-      const CoordRepType miny = box->GetBoxMin()[notMainDirSup];
-      const CoordRepType maxx = box->GetBoxMax()[notMainDirInf];
-      const CoordRepType maxy = box->GetBoxMax()[notMainDirSup];
+      const CoordinateType minx = box->GetBoxMin()[notMainDirInf];
+      const CoordinateType miny = box->GetBoxMin()[notMainDirSup];
+      const CoordinateType maxx = box->GetBoxMax()[notMainDirInf];
+      const CoordinateType maxy = box->GetBoxMax()[notMainDirSup];
 
       // Init data pointers to first pixel of slice ns (i)nferior and (s)uperior (x|y) corner
       const int offsetx = offsets[notMainDirInf];
@@ -184,11 +184,11 @@ JosephBackProjectionImageFilter<TInputImage,
       OutputPixelType * pxsys = pxsyi + offsety;
 
       // Compute step size and go to first voxel
-      CoordRepType       residualB = ns - np[mainDir];
-      CoordRepType       residualE = fp[mainDir] - fs;
-      const CoordRepType norm = itk::NumericTraits<CoordRepType>::One / dirVox[mainDir];
-      CoordRepType       stepx = dirVox[notMainDirInf] * norm;
-      CoordRepType       stepy = dirVox[notMainDirSup] * norm;
+      CoordinateType       residualB = ns - np[mainDir];
+      CoordinateType       residualE = fp[mainDir] - fs;
+      const CoordinateType norm = itk::NumericTraits<CoordinateType>::One / dirVox[mainDir];
+      CoordinateType       stepx = dirVox[notMainDirInf] * norm;
+      CoordinateType       stepy = dirVox[notMainDirSup] * norm;
       if (np[mainDir] > fp[mainDir])
       {
         residualB *= -1;
@@ -197,8 +197,8 @@ JosephBackProjectionImageFilter<TInputImage,
         stepx *= -1;
         stepy *= -1;
       }
-      CoordRepType currentx = np[notMainDirInf] + residualB * stepx;
-      CoordRepType currenty = np[notMainDirSup] + residualB * stepy;
+      CoordinateType currentx = np[notMainDirInf] + residualB * stepx;
+      CoordinateType currenty = np[notMainDirSup] + residualB * stepy;
 
       // Compute voxel to millimeters conversion
       stepMM[notMainDirInf] = this->GetInput(0)->GetSpacing()[notMainDirInf] * stepx;
@@ -347,10 +347,10 @@ JosephBackProjectionImageFilter<TInputImage,
   int          ix = itk::Math::floor(x);
   int          iy = itk::Math::floor(y);
   int          idx = ix * ox + iy * oy;
-  CoordRepType lx = x - ix;
-  CoordRepType ly = y - iy;
-  CoordRepType lxc = 1. - lx;
-  CoordRepType lyc = 1. - ly;
+  CoordinateType lx = x - ix;
+  CoordinateType ly = y - iy;
+  CoordinateType lxc = 1. - lx;
+  CoordinateType lyc = 1. - ly;
 
   m_SplatWeightMultiplication(rayValue, pxiyi[idx], stepLengthInVoxel, voxelSize, lxc * lyc);
   m_SplatWeightMultiplication(rayValue, pxsyi[idx], stepLengthInVoxel, voxelSize, lx * lyc);
@@ -379,18 +379,18 @@ JosephBackProjectionImageFilter<TInputImage,
                                                                       const double           y,
                                                                       const int              ox,
                                                                       const int              oy,
-                                                                      const CoordRepType     minx,
-                                                                      const CoordRepType     miny,
-                                                                      const CoordRepType     maxx,
-                                                                      const CoordRepType     maxy)
+                                                                      const CoordinateType     minx,
+                                                                      const CoordinateType     miny,
+                                                                      const CoordinateType     maxx,
+                                                                      const CoordinateType     maxy)
 {
   int          ix = itk::Math::floor(x);
   int          iy = itk::Math::floor(y);
   int          idx = ix * ox + iy * oy;
-  CoordRepType lx = x - ix;
-  CoordRepType ly = y - iy;
-  CoordRepType lxc = 1. - lx;
-  CoordRepType lyc = 1. - ly;
+  CoordinateType lx = x - ix;
+  CoordinateType ly = y - iy;
+  CoordinateType lxc = 1. - lx;
+  CoordinateType lyc = 1. - ly;
 
   int offset_xi = 0;
   int offset_yi = 0;
@@ -431,18 +431,18 @@ JosephBackProjectionImageFilter<TInputImage,
                                                                      const InputPixelType * pxsyi,
                                                                      const InputPixelType * pxiys,
                                                                      const InputPixelType * pxsys,
-                                                                     const CoordRepType     x,
-                                                                     const CoordRepType     y,
+                                                                     const CoordinateType     x,
+                                                                     const CoordinateType     y,
                                                                      const int              ox,
                                                                      const int              oy)
 {
   int          ix = itk::Math::floor(x);
   int          iy = itk::Math::floor(y);
   int          idx = ix * ox + iy * oy;
-  CoordRepType lx = x - ix;
-  CoordRepType ly = y - iy;
-  CoordRepType lxc = 1. - lx;
-  CoordRepType lyc = 1. - ly;
+  CoordinateType lx = x - ix;
+  CoordinateType ly = y - iy;
+  CoordinateType lxc = 1. - lx;
+  CoordinateType lyc = 1. - ly;
   return (m_InterpolationWeightMultiplication(stepLengthInVoxel, lxc * lyc, pxiyi, idx) +
           m_InterpolationWeightMultiplication(stepLengthInVoxel, lx * lyc, pxsyi, idx) +
           m_InterpolationWeightMultiplication(stepLengthInVoxel, lxc * ly, pxiys, idx) +
@@ -468,22 +468,22 @@ JosephBackProjectionImageFilter<TInputImage,
                                                                               const InputPixelType * pxsyi,
                                                                               const InputPixelType * pxiys,
                                                                               const InputPixelType * pxsys,
-                                                                              const CoordRepType     x,
-                                                                              const CoordRepType     y,
+                                                                              const CoordinateType     x,
+                                                                              const CoordinateType     y,
                                                                               const int              ox,
                                                                               const int              oy,
-                                                                              const CoordRepType     minx,
-                                                                              const CoordRepType     miny,
-                                                                              const CoordRepType     maxx,
-                                                                              const CoordRepType     maxy)
+                                                                              const CoordinateType     minx,
+                                                                              const CoordinateType     miny,
+                                                                              const CoordinateType     maxx,
+                                                                              const CoordinateType     maxy)
 {
   int          ix = itk::Math::floor(x);
   int          iy = itk::Math::floor(y);
   int          idx = ix * ox + iy * oy;
-  CoordRepType lx = x - ix;
-  CoordRepType ly = y - iy;
-  CoordRepType lxc = 1. - lx;
-  CoordRepType lyc = 1. - ly;
+  CoordinateType lx = x - ix;
+  CoordinateType ly = y - iy;
+  CoordinateType lxc = 1. - lx;
+  CoordinateType lyc = 1. - ly;
 
   int offset_xi = 0;
   int offset_yi = 0;
diff --git a/include/rtkJosephForwardAttenuatedProjectionImageFilter.h b/include/rtkJosephForwardAttenuatedProjectionImageFilter.h
index 0e6fd4c78..9ab639cc1 100644
--- a/include/rtkJosephForwardAttenuatedProjectionImageFilter.h
+++ b/include/rtkJosephForwardAttenuatedProjectionImageFilter.h
@@ -39,7 +39,7 @@ namespace Functor
  *
  * \ingroup RTK Functions
  */
-template <class TInput, class TCoordRepType, class TOutput = TInput>
+template <class TInput, class TCoordinateType, class TOutput = TInput>
 class ITK_TEMPLATE_EXPORT InterpolationWeightMultiplicationAttenuated
 {
 public:
@@ -69,7 +69,7 @@ class ITK_TEMPLATE_EXPORT InterpolationWeightMultiplicationAttenuated
   inline TOutput
   operator()(const ThreadIdType  threadId,
              const double        stepLengthInVoxel,
-             const TCoordRepType weight,
+             const TCoordinateType weight,
              const TInput *      p,
              const int           i)
   {
@@ -284,8 +284,8 @@ class ITK_TEMPLATE_EXPORT JosephForwardAttenuatedProjectionImageFilter
   using InputPixelType = typename TInputImage::PixelType;
   using OutputPixelType = typename TOutputImage::PixelType;
   using OutputImageRegionType = typename TOutputImage::RegionType;
-  using CoordRepType = double;
-  using VectorType = itk::Vector<CoordRepType, TInputImage::ImageDimension>;
+  using CoordinateType = double;
+  using VectorType = itk::Vector<CoordinateType, TInputImage::ImageDimension>;
 
   /** ImageDimension constants */
   static constexpr unsigned int InputImageDimension = TInputImage::ImageDimension;
diff --git a/include/rtkJosephForwardProjectionImageFilter.h b/include/rtkJosephForwardProjectionImageFilter.h
index 7b8257158..1f351f47a 100644
--- a/include/rtkJosephForwardProjectionImageFilter.h
+++ b/include/rtkJosephForwardProjectionImageFilter.h
@@ -39,7 +39,7 @@ namespace Functor
  *
  * \ingroup RTK Functions
  */
-template <class TInput, class TCoordRepType, class TOutput = TInput>
+template <class TInput, class TCoordinateType, class TOutput = TInput>
 class ITK_TEMPLATE_EXPORT InterpolationWeightMultiplication
 {
 public:
@@ -59,7 +59,7 @@ class ITK_TEMPLATE_EXPORT InterpolationWeightMultiplication
   inline TOutput
   operator()(const ThreadIdType  itkNotUsed(threadId),
              const double        itkNotUsed(stepLengthInVoxel),
-             const TCoordRepType weight,
+             const TCoordinateType weight,
              const TInput *      p,
              const int           i) const
   {
@@ -184,8 +184,8 @@ class ITK_TEMPLATE_EXPORT JosephForwardProjectionImageFilter
   using InputPixelType = typename TInputImage::PixelType;
   using OutputPixelType = typename TOutputImage::PixelType;
   using OutputImageRegionType = typename TOutputImage::RegionType;
-  using CoordRepType = double;
-  using VectorType = itk::Vector<CoordRepType, TInputImage::ImageDimension>;
+  using CoordinateType = double;
+  using VectorType = itk::Vector<CoordinateType, TInputImage::ImageDimension>;
   using TClipImageType = itk::Image<double, TOutputImage::ImageDimension>;
   using TClipImagePointer = typename TClipImageType::Pointer;
 
diff --git a/include/rtkJosephForwardProjectionImageFilter.hxx b/include/rtkJosephForwardProjectionImageFilter.hxx
index 9d0f7485b..54d90f763 100644
--- a/include/rtkJosephForwardProjectionImageFilter.hxx
+++ b/include/rtkJosephForwardProjectionImageFilter.hxx
@@ -294,10 +294,10 @@ JosephForwardProjectionImageFilter<TInputImage,
       if (notMainDirInf > notMainDirSup)
         std::swap(notMainDirInf, notMainDirSup);
 
-      const CoordRepType minx = box->GetBoxMin()[notMainDirInf];
-      const CoordRepType miny = box->GetBoxMin()[notMainDirSup];
-      const CoordRepType maxx = box->GetBoxMax()[notMainDirInf];
-      const CoordRepType maxy = box->GetBoxMax()[notMainDirSup];
+      const CoordinateType minx = box->GetBoxMin()[notMainDirInf];
+      const CoordinateType miny = box->GetBoxMin()[notMainDirSup];
+      const CoordinateType maxx = box->GetBoxMax()[notMainDirInf];
+      const CoordinateType maxy = box->GetBoxMax()[notMainDirSup];
 
       // Init data pointers to first pixel of slice ns (i)nferior and (s)uperior (x|y) corner
       const int offsetx = offsets[notMainDirInf];
@@ -310,11 +310,11 @@ JosephForwardProjectionImageFilter<TInputImage,
       const typename TInputImage::PixelType * pxsys = pxsyi + offsety;
 
       // Compute step size and go to first voxel
-      CoordRepType       residualB = ns - np[mainDir];
-      CoordRepType       residualE = fp[mainDir] - fs;
-      const CoordRepType norm = itk::NumericTraits<CoordRepType>::One / dirVox[mainDir];
-      CoordRepType       stepx = dirVox[notMainDirInf] * norm;
-      CoordRepType       stepy = dirVox[notMainDirSup] * norm;
+      CoordinateType       residualB = ns - np[mainDir];
+      CoordinateType       residualE = fp[mainDir] - fs;
+      const CoordinateType norm = itk::NumericTraits<CoordinateType>::One / dirVox[mainDir];
+      CoordinateType       stepx = dirVox[notMainDirInf] * norm;
+      CoordinateType       stepy = dirVox[notMainDirSup] * norm;
       if (np[mainDir] > fp[mainDir])
       {
         residualB *= -1;
@@ -323,8 +323,8 @@ JosephForwardProjectionImageFilter<TInputImage,
         stepx *= -1;
         stepy *= -1;
       }
-      CoordRepType currentx = np[notMainDirInf] + residualB * stepx;
-      CoordRepType currenty = np[notMainDirSup] + residualB * stepy;
+      CoordinateType currentx = np[notMainDirInf] + residualB * stepx;
+      CoordinateType currenty = np[notMainDirSup] + residualB * stepy;
 
       // Compute voxel to millimeters conversion
       stepMM[notMainDirInf] = this->GetInput(1)->GetSpacing()[notMainDirInf] * stepx;
@@ -443,18 +443,18 @@ JosephForwardProjectionImageFilter<TInputImage,
                                                                         const InputPixelType * pxsyi,
                                                                         const InputPixelType * pxiys,
                                                                         const InputPixelType * pxsys,
-                                                                        const CoordRepType     x,
-                                                                        const CoordRepType     y,
+                                                                        const CoordinateType     x,
+                                                                        const CoordinateType     y,
                                                                         const int              ox,
                                                                         const int              oy)
 {
   int          ix = itk::Math::floor(x);
   int          iy = itk::Math::floor(y);
   int          idx = ix * ox + iy * oy;
-  CoordRepType lx = x - ix;
-  CoordRepType ly = y - iy;
-  CoordRepType lxc = 1. - lx;
-  CoordRepType lyc = 1. - ly;
+  CoordinateType lx = x - ix;
+  CoordinateType ly = y - iy;
+  CoordinateType lxc = 1. - lx;
+  CoordinateType lyc = 1. - ly;
   return (m_InterpolationWeightMultiplication(threadId, stepLengthInVoxel, lxc * lyc, pxiyi, idx) +
           m_InterpolationWeightMultiplication(threadId, stepLengthInVoxel, lx * lyc, pxsyi, idx) +
           m_InterpolationWeightMultiplication(threadId, stepLengthInVoxel, lxc * ly, pxiys, idx) +
@@ -463,12 +463,12 @@ JosephForwardProjectionImageFilter<TInputImage,
   const unsigned int ix = itk::Math::Floor(x);
   const unsigned int iy = itk::Math::Floor(y);
   const unsigned int idx = ix*ox + iy*oy;
-  const CoordRepType a = p1[idx];
-  const CoordRepType b = p2[idx] - a;
-  const CoordRepType c = p3[idx] - a;
-  const CoordRepType lx = x-ix;
-  const CoordRepType ly = y-iy;
-  const CoordRepType d = p4[idx] - a - b - c;
+  const CoordinateType a = p1[idx];
+  const CoordinateType b = p2[idx] - a;
+  const CoordinateType c = p3[idx] - a;
+  const CoordinateType lx = x-ix;
+  const CoordinateType ly = y-iy;
+  const CoordinateType d = p4[idx] - a - b - c;
   return a + b*lx + c*ly + d*lx*ly;
 */
 }
@@ -493,22 +493,22 @@ JosephForwardProjectionImageFilter<TInputImage,
                                                                                  const InputPixelType * pxsyi,
                                                                                  const InputPixelType * pxiys,
                                                                                  const InputPixelType * pxsys,
-                                                                                 const CoordRepType     x,
-                                                                                 const CoordRepType     y,
+                                                                                 const CoordinateType     x,
+                                                                                 const CoordinateType     y,
                                                                                  const int              ox,
                                                                                  const int              oy,
-                                                                                 const CoordRepType     minx,
-                                                                                 const CoordRepType     miny,
-                                                                                 const CoordRepType     maxx,
-                                                                                 const CoordRepType     maxy)
+                                                                                 const CoordinateType     minx,
+                                                                                 const CoordinateType     miny,
+                                                                                 const CoordinateType     maxx,
+                                                                                 const CoordinateType     maxy)
 {
   int          ix = itk::Math::floor(x);
   int          iy = itk::Math::floor(y);
   int          idx = ix * ox + iy * oy;
-  CoordRepType lx = x - ix;
-  CoordRepType ly = y - iy;
-  CoordRepType lxc = 1. - lx;
-  CoordRepType lyc = 1. - ly;
+  CoordinateType lx = x - ix;
+  CoordinateType ly = y - iy;
+  CoordinateType lxc = 1. - lx;
+  CoordinateType lyc = 1. - ly;
 
   int offset_xi = 0;
   int offset_yi = 0;
diff --git a/include/rtkZengBackProjectionImageFilter.hxx b/include/rtkZengBackProjectionImageFilter.hxx
index 1b38ec2c1..28ce11ca1 100644
--- a/include/rtkZengBackProjectionImageFilter.hxx
+++ b/include/rtkZengBackProjectionImageFilter.hxx
@@ -180,8 +180,8 @@ ZengBackProjectionImageFilter<TInputImage, TOutputImage>::GenerateOutputInformat
   const typename OuputCPUImageType::PointType originProjection = this->GetInput(1)->GetOrigin();
 
   // Find the center of the volume
-  using CoordRepType = typename PointType ::ValueType;
-  using ContinuousIndexType = itk::ContinuousIndex<CoordRepType, InputImageDimension>;
+  using CoordinateType = typename PointType ::ValueType;
+  using ContinuousIndexType = itk::ContinuousIndex<CoordinateType, InputImageDimension>;
   using ContinuousIndexValueType = typename ContinuousIndexType::ValueType;
   ContinuousIndexType centerIndex;
 
@@ -193,7 +193,7 @@ ZengBackProjectionImageFilter<TInputImage, TOutputImage>::GenerateOutputInformat
 
   using ValueType = typename PointType::ValueType;
   m_centerVolume =
-    this->GetInput(0)->template TransformContinuousIndexToPhysicalPoint<CoordRepType, ValueType>(centerIndex);
+    this->GetInput(0)->template TransformContinuousIndexToPhysicalPoint<CoordinateType, ValueType>(centerIndex);
 
   PointType centerRotation;
   centerRotation.Fill(0);
diff --git a/include/rtkZengForwardProjectionImageFilter.hxx b/include/rtkZengForwardProjectionImageFilter.hxx
index 91fed1a16..43bebc675 100644
--- a/include/rtkZengForwardProjectionImageFilter.hxx
+++ b/include/rtkZengForwardProjectionImageFilter.hxx
@@ -181,8 +181,8 @@ ZengForwardProjectionImageFilter<TInputImage, TOutputImage>::GenerateOutputInfor
 
   // Find the center of the volume
 
-  using CoordRepType = typename PointType ::ValueType;
-  using ContinuousIndexType = itk::ContinuousIndex<CoordRepType, InputImageDimension>;
+  using CoordinateType = typename PointType ::ValueType;
+  using ContinuousIndexType = itk::ContinuousIndex<CoordinateType, InputImageDimension>;
   using ContinuousIndexValueType = typename ContinuousIndexType::ValueType;
   ContinuousIndexType centerIndex;
 
@@ -194,7 +194,7 @@ ZengForwardProjectionImageFilter<TInputImage, TOutputImage>::GenerateOutputInfor
 
   using ValueType = typename PointType::ValueType;
   m_centerVolume =
-    this->GetInput(1)->template TransformContinuousIndexToPhysicalPoint<CoordRepType, ValueType>(centerIndex);
+    this->GetInput(1)->template TransformContinuousIndexToPhysicalPoint<CoordinateType, ValueType>(centerIndex);
 
   PointType centerRotation;
   centerRotation.Fill(0);