Remove vcl_math calls

[clitk.git] / itk / itkRayCastInterpolateImageFunctionWithOrigin.txx

diff --git a/itk/itkRayCastInterpolateImageFunctionWithOrigin.txx b/itk/itkRayCastInterpolateImageFunctionWithOrigin.txx
index ebf73cfc2d363c215b302be2c6cdd66c45bd6802..d173a4850ae58890e4ba21621c9a6f9982f804a6 100644 (file)
--- a/itk/itkRayCastInterpolateImageFunctionWithOrigin.txx
+++ b/itk/itkRayCastInterpolateImageFunctionWithOrigin.txx
@@ -129,7 +129,7 @@ public:
     typename InputImageType::SpacingType spacing=this->m_Image->GetSpacing();
 
     if (m_ValidRay)
-      return vcl_sqrt(m_VoxelIncrement[0]*spacing[0]*m_VoxelIncrement[0]*spacing[0]
+      return std::sqrt(m_VoxelIncrement[0]*spacing[0]*m_VoxelIncrement[0]*spacing[0]
                       + m_VoxelIncrement[1]*spacing[1]*m_VoxelIncrement[1]*spacing[1]
                       + m_VoxelIncrement[2]*spacing[2]*m_VoxelIncrement[2]*spacing[2] );
     else
@@ -470,10 +470,10 @@ RayCastHelper<TInputImage, TCoordRep>
              + C*m_BoundingCorner[c1][2] );
 
     // initialise plane value and normalise
-    m_BoundingPlane[j][0] = A/vcl_sqrt(A*A + B*B + C*C);
-    m_BoundingPlane[j][1] = B/vcl_sqrt(A*A + B*B + C*C);
-    m_BoundingPlane[j][2] = C/vcl_sqrt(A*A + B*B + C*C);
-    m_BoundingPlane[j][3] = D/vcl_sqrt(A*A + B*B + C*C);
+    m_BoundingPlane[j][0] = A/std::sqrt(A*A + B*B + C*C);
+    m_BoundingPlane[j][1] = B/std::sqrt(A*A + B*B + C*C);
+    m_BoundingPlane[j][2] = C/std::sqrt(A*A + B*B + C*C);
+    m_BoundingPlane[j][3] = D/std::sqrt(A*A + B*B + C*C);
 
     if ( (A*A + B*B + C*C) == 0 ) {
       itk::ExceptionObject err(__FILE__, __LINE__);
@@ -799,9 +799,9 @@ RayCastHelper<TInputImage, TCoordRep>
 
   // Calculate the number of voxels in each direction
 
-  xNum = vcl_fabs(m_RayVoxelStartPosition[0] - m_RayVoxelEndPosition[0]);
-  yNum = vcl_fabs(m_RayVoxelStartPosition[1] - m_RayVoxelEndPosition[1]);
-  zNum = vcl_fabs(m_RayVoxelStartPosition[2] - m_RayVoxelEndPosition[2]);
+  xNum = std::fabs(m_RayVoxelStartPosition[0] - m_RayVoxelEndPosition[0]);
+  yNum = std::fabs(m_RayVoxelStartPosition[1] - m_RayVoxelEndPosition[1]);
+  zNum = std::fabs(m_RayVoxelStartPosition[2] - m_RayVoxelEndPosition[2]);
 
   // The direction iterated in is that with the greatest number of voxels
   // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -991,9 +991,9 @@ RayCastHelper<TInputImage, TCoordRep>
     startOK = false;
     endOK = false;
 
-    Istart[0] = (int) vcl_floor(m_RayVoxelStartPosition[0]);
-    Istart[1] = (int) vcl_floor(m_RayVoxelStartPosition[1]);
-    Istart[2] = (int) vcl_floor(m_RayVoxelStartPosition[2]);
+    Istart[0] = (int) std::floor(m_RayVoxelStartPosition[0]);
+    Istart[1] = (int) std::floor(m_RayVoxelStartPosition[1]);
+    Istart[2] = (int) std::floor(m_RayVoxelStartPosition[2]);
 
     if( (Istart[0] >= 0) && (Istart[0] + Idirn[0] < m_NumberOfVoxelsInX) &&
         (Istart[1] >= 0) && (Istart[1] + Idirn[1] < m_NumberOfVoxelsInY) &&
@@ -1008,13 +1008,13 @@ RayCastHelper<TInputImage, TCoordRep>
       m_TotalRayVoxelPlanes--;
     }
 
-    Istart[0] = (int) vcl_floor(m_RayVoxelStartPosition[0]
+    Istart[0] = (int) std::floor(m_RayVoxelStartPosition[0]
                                 + m_TotalRayVoxelPlanes*m_VoxelIncrement[0]);
 
-    Istart[1] = (int) vcl_floor(m_RayVoxelStartPosition[1]
+    Istart[1] = (int) std::floor(m_RayVoxelStartPosition[1]
                                 + m_TotalRayVoxelPlanes*m_VoxelIncrement[1]);
 
-    Istart[2] = (int) vcl_floor(m_RayVoxelStartPosition[2]
+    Istart[2] = (int) std::floor(m_RayVoxelStartPosition[2]
                                 + m_TotalRayVoxelPlanes*m_VoxelIncrement[2]);
 
     if( (Istart[0] >= 0) && (Istart[0] + Idirn[0] < m_NumberOfVoxelsInX) &&
@@ -1286,18 +1286,18 @@ RayCastHelper<TInputImage, TCoordRep>
 
   switch( m_TraversalDirection ) {
   case TRANSVERSE_IN_X: {
-    y = m_Position3Dvox[1] - vcl_floor(m_Position3Dvox[1]);
-    z = m_Position3Dvox[2] - vcl_floor(m_Position3Dvox[2]);
+    y = m_Position3Dvox[1] - std::floor(m_Position3Dvox[1]);
+    z = m_Position3Dvox[2] - std::floor(m_Position3Dvox[2]);
     break;
   }
   case TRANSVERSE_IN_Y: {
-    y = m_Position3Dvox[0] - vcl_floor(m_Position3Dvox[0]);
-    z = m_Position3Dvox[2] - vcl_floor(m_Position3Dvox[2]);
+    y = m_Position3Dvox[0] - std::floor(m_Position3Dvox[0]);
+    z = m_Position3Dvox[2] - std::floor(m_Position3Dvox[2]);
     break;
   }
   case TRANSVERSE_IN_Z: {
-    y = m_Position3Dvox[0] - vcl_floor(m_Position3Dvox[0]);
-    z = m_Position3Dvox[1] - vcl_floor(m_Position3Dvox[1]);
+    y = m_Position3Dvox[0] - std::floor(m_Position3Dvox[0]);
+    z = m_Position3Dvox[1] - std::floor(m_Position3Dvox[1]);
     break;
   }
   default: {
@@ -1322,7 +1322,7 @@ void
 RayCastHelper<TInputImage, TCoordRep>
 ::IncrementIntensities(double increment)
 {
-  short inc = (short) vcl_floor(increment + 0.5);
+  short inc = (short) std::floor(increment + 0.5);
 
   if (! m_ValidRay) {
     return;