diff --git a/Milling.cpp b/Milling.cpp
index f04d845..2fe2a8d 100644
--- a/Milling.cpp
+++ b/Milling.cpp
@@ -2080,69 +2080,30 @@ bool
 Milling::CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad,
                             double& dElev) const
 {
+  // default
    dElev = 0 ;
-   int nMaxInd = pCompo->GetCurveCount() - 1 ;
-   for ( int i = 0 ; i <= nMaxInd ; ++ i) {
-     // curva corrente
-      const ICurve* pCrvC = pCompo->GetCurve( i) ;
-     // calcolo elevazione
-      double dCurrElev ;
-      Point3d ptStart, ptMid, ptEnd ;
-      pCrvC->GetStartPoint( ptStart) ;
-      pCrvC->GetMidPoint( ptMid) ;
-      pCrvC->GetEndPoint( ptEnd) ;
-      Vector3d vtStartPerp, vtMidPerp, vtEndPerp, vtTg ;
-      pCrvC->GetStartDir( vtTg) ;
-      vtStartPerp = vtTg ^ vtTool ;
-      vtStartPerp.Normalize() ;
-      vtStartPerp *= dRad ;
-      pCrvC->GetMidDir( vtTg) ;
-      vtMidPerp = vtTg ^ vtTool ;
-      vtMidPerp.Normalize() ;
-      vtMidPerp *= dRad ;
-      pCrvC->GetEndDir( vtTg) ;
-      vtEndPerp = vtTg ^ vtTool ;
-      vtEndPerp.Normalize() ;
-      vtEndPerp *= dRad ;
-      Vector3d vtDepth = vtTool * dDepth ;
-     // linea centro utensile
-      if ( GetElevation( m_nPhase, ptStart - vtDepth, ptMid - vtDepth, ptEnd - vtDepth, vtTool, dCurrElev)) {
-         if ( dCurrElev > dElev)
-            dElev = dCurrElev ;
-      }
-      else {
-         m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ;
+  // controllo il raggio utensile
+   double const MIN_RAD = 5 ; 
+   dRad = max( dRad, MIN_RAD) ;
+  // approssimo la curva con una polilinea
+   PolyLine PL ;
+   if ( ! pCompo->ApproxWithLines( LIN_TOL_STD, ANG_TOL_MAX_DEG, ICurve::APL_SPECIAL, PL))
+      return false ;
+   double const MIN_STEP = 5 ;
+   double const MAX_STEP = 500 ;
+   double dStep = Clamp( dRad, MIN_STEP, MAX_STEP) ;
+   PL.AdjustForMaxSegmentLen( dStep) ;
+  // calcolo l'elevazione
+   Point3d ptP ;
+   bool bFound = PL.GetFirstPoint( ptP) ;
+   while ( bFound) {
+      double dPtElev ;
+      if ( ! GetElevation( m_nPhase, ptP - vtTool * dDepth, vtTool, dRad, vtTool, dPtElev))
          return false ;
-      }
-     // step laterali
-      int nStep = Clamp( int( dRad / ELEV_MAX_OFFS + 0.1), 0, 4) + 1 ;
-     // da una parte
-      for ( int j = 1 ; j <= nStep ; ++ j) {
-         double dCoeff = j / double( nStep) ;
-         if ( GetElevation( m_nPhase, ptStart + dCoeff * vtStartPerp - vtDepth, ptMid + dCoeff * vtMidPerp - vtDepth,
-                                       ptEnd + dCoeff * vtEndPerp - vtDepth, vtTool, dCurrElev)) {
-            if ( dCurrElev > dElev)
-               dElev = dCurrElev ;
-         }
-         else {
-            m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ;
-            return false ;
-         }
-      }
-     // dall'altra parte
-      for ( int j = 1 ; j <= nStep ; ++ j) {
-         double dCoeff = j / double( nStep) ;
-         if ( GetElevation( m_nPhase, ptStart - dCoeff * vtStartPerp - vtDepth, ptMid - dCoeff * vtMidPerp - vtDepth,
-                                       ptEnd - dCoeff * vtEndPerp - vtDepth, vtTool, dCurrElev)) {
-            if ( dCurrElev > dElev)
-               dElev = dCurrElev ;
-         }
-         else {
-            m_pMchMgr->SetLastError( 2306, "Error in Milling : Entity GetElevation") ;
-            return false ;
-         }
-      }
+      dElev = max( dElev, dPtElev) ;
+      bFound = PL.GetNextPoint( ptP) ;
    }
+
    return true ;
 }
 
@@ -2394,28 +2355,24 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
                   Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
                   Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ;
                   Vector3d vtAppr2 = ptP1 - ptStart ;
-                  if ( ! vtAppr2.Normalize()) {
-                     if ( ( m_TParams.m_nType & TF_MILL) != 0)
-                        vtAppr2 = -vtStart ;
-                     else
-                        vtAppr2 = CalcCorrDir( pCompo, i) ;
-                  }
+                  if ( ! vtAppr2.Normalize())
+                     vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i)) ;
                   double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
-                  double dSawStartElev1 = -1, dSawStartElev2 = -1 ;
-                  GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtAppr1, dSawStartElev1) ;
-                  GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtAppr2, dSawStartElev2) ;
-                  if ( dSawStartElev1 > -EPS_SMALL  &&  dSawStartElev2 > -EPS_SMALL) {
+                  double dSawStartElev1, dSawStartElev2 ;
+                  bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr1, dSawStartElev1) ;
+                  bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr2, dSawStartElev2) ;
+                  if ( bOk1  &&  bOk2) {
                      bool bFirst = ( dSawStartElev1 < dSawStartElev2) ;
                      vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
                      dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
                      bSideStart = true ;
                   }
-                  else if ( dSawStartElev1 > -EPS_SMALL) {
+                  else if ( bOk1) {
                      vtAppr = vtAppr1 ;
                      dSawStartElev = dSawStartElev1 ;
                      bSideStart = true ;
                   }
-                  else if ( dSawStartElev2 > -EPS_SMALL) {
+                  else if ( bOk2) {
                      vtAppr = vtAppr2 ;
                      dSawStartElev = dSawStartElev2 ;
                      bSideStart = true ;
@@ -2562,28 +2519,24 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
                   Point3d ptTest = ptP1 - MIN_SAFEDIST * ( m_bAboveHead ? Z_AX : -Z_AX) ;
                   Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ;
                   Vector3d vtRetr2 = ptP1 - ptEnd ;
-                  if ( ! vtRetr2.Normalize()) {
-                     if ( ( m_TParams.m_nType & TF_MILL) != 0)
-                        vtRetr2 = vtEnd ;
-                     else
-                        vtRetr2 = CalcCorrDir( pCompo, i + 1) ;                  
-                  }
+                  if ( ! vtRetr2.Normalize())
+                     vtRetr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? vtEnd : CalcCorrDir( pCompo, i + 1)) ;
                   double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
                   double dSawEndElev1, dSawEndElev2 ;
-                  GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr1, dSawEndElev1) ;
-                  GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr2, dSawEndElev2) ;
-                  if ( dSawEndElev1 > -EPS_SMALL  &&  dSawEndElev2 > -EPS_SMALL) {
+                  bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr1, dSawEndElev1) ;
+                  bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr2, dSawEndElev2) ;
+                  if ( bOk1  &&  bOk2) {
                      bool bFirst = ( dSawEndElev1 < dSawEndElev2) ;
                      vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
                      dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
                      bSideEnd = true ;
                   }
-                  else if ( dSawEndElev1 > -EPS_SMALL) {
+                  else if ( bOk1) {
                      vtRetr = vtRetr1 ;
                      dSawEndElev = dSawEndElev1 ;
                      bSideEnd = true ;
                   }
-                  else if ( dSawEndElev2 > -EPS_SMALL) {
+                  else if ( bOk2) {
                      vtRetr = vtRetr2 ;
                      dSawEndElev = dSawEndElev2 ;
                      bSideEnd = true ;
@@ -2672,7 +2625,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
             pCurve->GetStartDir( vtStart) ;
            // determino elevazione su inizio attacco
             double dStElev ;
-            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
+            if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                dStElev = dStep ;
            // determino inizio attacco
             Point3d ptP1 ;
@@ -2709,10 +2662,8 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                      vtEscape.Normalize() ;
                   }
                   double dNewStElev ;
-                  if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
-                     if ( bAboveStart  ||  dNewStElev > EPS_SMALL)
-                        dStElev = min( dStElev, dNewStElev) ;
-                  }
+                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
+                     dStElev = min( dStElev, dNewStElev) ;
                  // se testa sopra determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                   bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                            m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
@@ -2750,23 +2701,23 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                         Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ;
                         Vector3d vtAppr2 = ptP1 - ptStart ;
                         if ( ! vtAppr2.Normalize())
-                           vtAppr2 = CalcCorrDir( pCompo, i) ;
+                           vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i)) ;
                         double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
-                        double dSawStartElev1 = -1, dSawStartElev2 = -1 ;
-                        GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtAppr1, dSawStartElev1) ;
-                        GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtAppr2, dSawStartElev2) ;
-                        if ( dSawStartElev1 > -EPS_SMALL  &&  dSawStartElev2 > -EPS_SMALL) {
+                        double dSawStartElev1, dSawStartElev2 ;
+                        bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr1, dSawStartElev1) ;
+                        bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr2, dSawStartElev2) ;
+                        if ( bOk1  &&  bOk2) {
                            bool bFirst = ( dSawStartElev1 < dSawStartElev2) ;
                            vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
                            dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
                            bSideStart = true ;
                         }
-                        else if ( dSawStartElev1 > -EPS_SMALL) {
+                        else if ( bOk1) {
                            vtAppr = vtAppr1 ;
                            dSawStartElev = dSawStartElev1 ;
                            bSideStart = true ;
                         }
-                        else if ( dSawStartElev2 > -EPS_SMALL) {
+                        else if ( bOk2) {
                            vtAppr = vtAppr2 ;
                            dSawStartElev = dSawStartElev2 ;
                            bSideStart = true ;
@@ -2879,7 +2830,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
             pCurve->GetEndDir( vtEnd) ;
            // elevazione sul punto finale
             double dEndElev ;
-            if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
+            if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                dEndElev = dElev ;
            // se non c'è attacco a zigzag o a spirale oppure ultimo step, aggiungo uscita
             Point3d ptP1 = ptEnd ;
@@ -2917,23 +2868,23 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                      Vector3d vtRetr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptEnd) ;
                      Vector3d vtRetr2 = ptP1 - ptEnd ;
                      if ( ! vtRetr2.Normalize())
-                        vtRetr2 = CalcCorrDir( pCompo, i + 1) ;
+                        vtRetr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? vtEnd : CalcCorrDir( pCompo, i + 1)) ;
                      double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
                      double dSawEndElev1, dSawEndElev2 ;
-                     GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr1, dSawEndElev1) ;
-                     GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr2, dSawEndElev2) ;
-                     if ( dSawEndElev1 > -EPS_SMALL  &&  dSawEndElev2 > -EPS_SMALL) {
+                     bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr1, dSawEndElev1) ;
+                     bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr2, dSawEndElev2) ;
+                     if ( bOk1  &&  bOk2) {
                         bool bFirst = ( dSawEndElev1 < dSawEndElev2) ;
                         vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
                         dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
                         bSideEnd = true ;
                      }
-                     else if ( dSawEndElev1 > -EPS_SMALL) {
+                     else if ( bOk1) {
                         vtRetr = vtRetr1 ;
                         dSawEndElev = dSawEndElev1 ;
                         bSideEnd = true ;
                      }
-                     else if ( dSawEndElev2 > -EPS_SMALL) {
+                     else if ( bOk2) {
                         vtRetr = vtRetr2 ;
                         dSawEndElev = dSawEndElev2 ;
                         bSideEnd = true ;
@@ -2971,10 +2922,8 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                   vtEscape.Normalize() ;
                }
                double dNewEndElev ;
-               if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
-                  if ( bAboveEnd  ||  dNewEndElev > EPS_SMALL)
-                     dEndElev = min( dEndElev, dNewEndElev) ;
-               }
+               if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
+                  dEndElev = min( dEndElev, dNewEndElev) ;
               // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                       m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
@@ -3079,12 +3028,12 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
    else if ( m_bAboveHead) {
      // inizio con sua elevazione e sicurezza
       double dStElev ;
-      if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
+      if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
          dStElev = dElev ;
       Point3d ptPsr = ptPs + ( dStElev + dSafeZ) * vtTool ;
      // fine con sua elevazione e sicurezza
       double dEndElev ;
-      if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
+      if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
          dEndElev = dElev ;
       Point3d ptPer = ptPe + ( dEndElev + dSafeZ) * vtTool ;
      // verifica dei punti intermedi
@@ -3150,7 +3099,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
             else {
               // determino elevazione su inizio attacco
                double dStElev ;
-               if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
+               if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                   dStElev = dElev ;
                if ( ! bSafeDirLinkStartEnd)
                   dStElev = max( dStElev, j * dStep) ;
@@ -3166,7 +3115,6 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                if ( ( m_TParams.m_nType & TF_MILL) != 0  &&
                     ( m_TParams.m_nType != TT_MILL_NOTIP  ||  LeadInRawIsOk()  ||  m_bStartOutRaw  ||  bOutStart)) {
                  // correggo elevazione iniziale per punto inizio attacco (se testa da sopra senza aggregato approccio mai Z-)
-                  Point3d ptP1m = ptP1 - 10 * EPS_SMALL * vtTool ;
                   Vector3d vtEscape = vtTool ;
                   if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                        ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
@@ -3174,10 +3122,10 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                      vtEscape.Normalize() ;
                   }
                   double dNewStElev ;
-                  if ( GetElevation( m_nPhase, ptP1m, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
+                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
                      if ( bAboveStartEnd)
                         dStElev = min( dStElev, dNewStElev) ;
-                     else if ( dNewStElev > EPS_SMALL)
+                     else
                         dStElev = max( dStElev, dNewStElev) ;
                   }
                   if ( bOutStartEnd  &&  m_bTiltingTab)
@@ -3229,23 +3177,23 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                         Vector3d vtAppr1 = FromNearestHorizontalOrtho( vtTool, ptP1 - ptStart) ;
                         Vector3d vtAppr2 = ptP1 - ptStart ;
                         if ( ! vtAppr2.Normalize())
-                           vtAppr2 = CalcCorrDir( pCompo, i) ;
+                           vtAppr2 = ( m_TParams.m_nType == TT_MILL_NOTIP ? -vtStart : CalcCorrDir( pCompo, i)) ;
                         double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
-                        double dSawStartElev1 = -1, dSawStartElev2 = -1 ;
-                        GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick + 2 * MIN_SAFEDIST, vtAppr1, dSawStartElev1) ;
-                        GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick + 2 * MIN_SAFEDIST, vtAppr2, dSawStartElev2) ;
-                        if ( dSawStartElev1 > -EPS_SMALL  &&  dSawStartElev2 > -EPS_SMALL) {
+                        double dSawStartElev1 = 0, dSawStartElev2 = 0 ;
+                        bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr1, dSawStartElev1) ;
+                        bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtAppr2, dSawStartElev2) ;
+                        if ( bOk1  &&  bOk2) {
                            bool bFirst = ( dSawStartElev1 < dSawStartElev2) ;
                            vtAppr = ( bFirst ? vtAppr1 : vtAppr2) ;
                            dSawStartElev = ( bFirst ? dSawStartElev1 : dSawStartElev2) ;
                            bSideStart = true ;
                         }
-                        else if ( dSawStartElev1 > -EPS_SMALL) {
+                        else if ( bOk1) {
                            vtAppr = vtAppr1 ;
                            dSawStartElev = dSawStartElev1 ;
                            bSideStart = true ;
                         }
-                        else if ( dSawStartElev2 > -EPS_SMALL) {
+                        else if ( bOk2) {
                            vtAppr = vtAppr2 ;
                            dSawStartElev = dSawStartElev2 ;
                            bSideStart = true ;
@@ -3328,7 +3276,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
             pCurve->GetEndDir( vtEnd) ;
            // elevazione sul punto finale
             double dEndElev ;
-            if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
+            if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                dEndElev = dElev ;
             if ( ! bSafeDirLinkStartEnd)
                dEndElev = max( dEndElev, j * dStep) ;
@@ -3350,7 +3298,6 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                if ( ( m_TParams.m_nType & TF_MILL) != 0  && 
                     ( m_TParams.m_nType != TT_MILL_NOTIP  ||  m_bEndOutRaw  ||  bOutEnd)) {
                  // correggo elevazione finale per punto fine uscita (se testa da sopra senza aggregato approccio mai Z-)
-                  Point3d ptP1m = ptP1 - 10 * EPS_SMALL * vtTool ;
                   Vector3d vtEscape = vtTool ;
                   if ( ( m_bAboveHead  &&  ! m_bAggrBottom  &&  ! m_bTiltingTab  &&  vtTool.z < -EPS_SMALL)  ||
                        ( ! m_bAboveHead  &&  vtTool.z > EPS_SMALL)) {
@@ -3358,7 +3305,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                      vtEscape.Normalize() ;
                   }
                   double dNewEndElev ;
-                  if ( GetElevation( m_nPhase, ptP1m, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
+                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
                      if ( bAboveStartEnd)
                         dEndElev = min( dEndElev, dNewEndElev) ;
                      else if ( dNewEndElev > EPS_SMALL)
@@ -3400,20 +3347,20 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                            vtRetr2 = CalcCorrDir( pCompo, i + 1) ;
                         double dThick = ( m_TParams.m_nType == TT_MILL_NOTIP ? m_TParams.m_dMaxMat : m_TParams.m_dThick) ;
                         double dSawEndElev1, dSawEndElev2 ;
-                        GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr1, dSawEndElev1) ;
-                        GetElevation( m_nPhase, ptTest, vtTool, 0.5 * m_TParams.m_dDiam, dThick, vtRetr2, dSawEndElev2) ;
-                        if ( dSawEndElev1 > -EPS_SMALL  &&  dSawEndElev2 > -EPS_SMALL) {
+                        bool bOk1 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr1, dSawEndElev1) ;
+                        bool bOk2 = GetElevation( m_nPhase, ptTest, vtTool, m_TParams.m_dDiam / 2, dThick, vtRetr2, dSawEndElev2) ;
+                        if ( bOk1  &&  bOk2) {
                            bool bFirst = ( dSawEndElev1 < dSawEndElev2) ;
                            vtRetr = ( bFirst ? vtRetr1 : vtRetr2) ;
                            dSawEndElev = ( bFirst ? dSawEndElev1 : dSawEndElev2) ;
                            bSideEnd = true ;
                         }
-                        else if ( dSawEndElev1 > -EPS_SMALL) {
+                        else if ( bOk1) {
                            vtRetr = vtRetr1 ;
                            dSawEndElev = dSawEndElev1 ;
                            bSideEnd = true ;
                         }
-                        else if ( dSawEndElev2 > -EPS_SMALL) {
+                        else if ( bOk2) {
                            vtRetr = vtRetr2 ;
                            dSawEndElev = dSawEndElev2 ;
                            bSideEnd = true ;
@@ -3495,7 +3442,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                pCrvC->GetStartDir( vtStart) ;
               // determino elevazione su inizio attacco
                double dStElev ;
-               if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
+               if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                   dStElev = 0 ;
                dStElev -= dStart ;
               // determino inizio attacco
@@ -3519,10 +3466,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                      vtEscape.Normalize() ;
                   }
                   double dNewStElev ;
-                  if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
-                     if ( bAboveStart  ||  dNewStElev > EPS_SMALL)
-                        dStElev = min( dStElev, dNewStElev) ;
-                  }
+                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
+                     dStElev = min( dStElev, dNewStElev) ;
                  // se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                   bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                            m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
@@ -3607,7 +3552,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                pCrvC->GetEndDir( vtEnd) ;
               // elevazione sul punto finale
                double dEndElev ;
-               if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
+               if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                   dEndElev = dElev ;
               // aggiungo uscita
                Point3d ptP1 ;
@@ -3628,10 +3573,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                      vtEscape.Normalize() ;
                   }
                   double dNewEndElev ;
-                  if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
-                     if ( bAboveEnd  ||  dNewEndElev > EPS_SMALL)
-                        dEndElev = min( dEndElev, dNewEndElev) ;
-                  }
+                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
+                     dEndElev = min( dEndElev, dNewEndElev) ;
                  // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                   bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                          m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
@@ -3684,7 +3627,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                pCurve->GetStartDir( vtStart) ;
               // determino elevazione su inizio attacco
                double dStElev ;
-               if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
+               if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                   dStElev = dElev ;
                dStElev -= dStart ;
               // determino inizio attacco
@@ -3708,10 +3651,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                      vtEscape.Normalize() ;
                   }
                   double dNewStElev ;
-                  if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev)) {
-                     if ( bAboveStart  ||  dNewStElev > EPS_SMALL)
-                        dStElev = min( dStElev, dNewStElev) ;
-                  }
+                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
+                     dStElev = min( dStElev, dNewStElev) ;
                  // se testa sopra, determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                   bool bAhUnderStart = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                            m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
@@ -3791,7 +3732,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                pCurve->GetEndDir( vtEnd) ;
               // elevazione sul punto finale
                double dEndElev ;
-               if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
+               if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                   dEndElev = dElev ;
               // aggiungo uscita
                Point3d ptP1 ;
@@ -3812,10 +3753,8 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                      vtEscape.Normalize() ;
                   }
                   double dNewEndElev ;
-                  if ( GetElevation( m_nPhase, ptP1 - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev)) {
-                     if ( bAboveEnd  ||  dNewEndElev > EPS_SMALL)
-                        dEndElev = min( dEndElev, dNewEndElev) ;
-                  }
+                  if ( GetElevation( m_nPhase, ptP1, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
+                     dEndElev = min( dEndElev, dNewEndElev) ;
                  // se testa sopra, determino se l'inizio dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
                   bool bAhUnderEnd = m_bAboveHead && GetAhPointUnderRaw( ptP1, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                          m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
@@ -3920,7 +3859,7 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT
            // determino elevazione su inizio attacco
             double dStElev ;
             if ( j == 1) {
-               if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
+               if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
                   dStElev = dElev ;
             }
             else
@@ -3997,7 +3936,7 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT
            // elevazione sul punto finale
             double dEndElev ;
             if ( j == nStep) {
-               if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
+               if ( ! GetElevation( m_nPhase, ptEnd, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                   dEndElev = dElev ;
             }
             else
@@ -5810,7 +5749,7 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vec
    if ( ( m_TParams.m_nType & TF_SAWBLADE) == 0) {
      // determino se l'inizio dell'attacco è fuori dal grezzo (considero movimento fresa lungo il suo asse)
       double dTemp ;
-      if ( ! GetElevation( m_nPhase, ptP, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dTemp))
+      if ( ! GetElevation( m_nPhase, ptP, vtTool, m_TParams.m_dDiam / 2, vtTool, dTemp))
          return false ;
       return ( dTemp < 10 * EPS_SMALL  ||  dTemp > dElev + 10 * EPS_SMALL) ;
    }
@@ -5822,13 +5761,13 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vec
       Vector3d vtSafe = vtCorr ; vtSafe.z = 0 ; vtSafe.Normalize() ;
       Point3d ptQ = ptP - ( vtSafe + vtMove) * max( 0.2 * dSafeZ, MIN_SAFEDIST) ;
       bool bOut = true ;
-      if ( ! GetElevation( m_nPhase, ptQ, vtTool, 0.5 * m_TParams.m_dDiam, m_TParams.m_dThick, vtMove, dTemp)  ||  dTemp > 10 * EPS_SMALL) {
+      if ( ! GetElevation( m_nPhase, ptQ, vtTool, m_TParams.m_dDiam / 2, m_TParams.m_dThick, vtMove, dTemp)  ||  dTemp > 10 * EPS_SMALL) {
          bOut = false ;
          if ( ! m_bTiltingTab)
             return false ;
       }
       Point3d ptR = ptP + vtTool * m_TParams.m_dThick ;
-      if ( ! GetElevation( m_nPhase, ptR, vtTool, 0.5 * m_TParams.m_dDiam, m_TParams.m_dThick, vtMove, dTemp)  ||  dTemp > 10 * EPS_SMALL) {
+      if ( ! GetElevation( m_nPhase, ptR, vtTool, m_TParams.m_dDiam / 2, m_TParams.m_dThick, vtMove, dTemp)  ||  dTemp > 10 * EPS_SMALL) {
          bOut = false ;
          if ( ! m_bTiltingTab)
             return false ;
@@ -5836,9 +5775,9 @@ Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vec
      // se tavola basculante (o asse ralla) e non esterno, provo in direzione utensile
       if ( m_bTiltingTab  &&  ! bOut) {
          vtMove = vtTool ;
-         if ( ! GetElevation( m_nPhase, ptQ, vtTool, 0.5 * m_TParams.m_dDiam, m_TParams.m_dThick, vtMove, dTemp)  ||  dTemp > 10 * EPS_SMALL)
+         if ( ! GetElevation( m_nPhase, ptQ, vtTool, m_TParams.m_dDiam / 2, m_TParams.m_dThick, vtMove, dTemp)  ||  dTemp > 10 * EPS_SMALL)
             return false ;
-         if ( ! GetElevation( m_nPhase, ptR, vtTool, 0.5 * m_TParams.m_dDiam, m_TParams.m_dThick, vtMove, dTemp)  ||  dTemp > 10 * EPS_SMALL)
+         if ( ! GetElevation( m_nPhase, ptR, vtTool, m_TParams.m_dDiam / 2, m_TParams.m_dThick, vtMove, dTemp)  ||  dTemp > 10 * EPS_SMALL)
             return false ;
       }
       return true ;
diff --git a/Operation.cpp b/Operation.cpp
index f6b0b11..2a90d52 100644
--- a/Operation.cpp
+++ b/Operation.cpp
@@ -378,90 +378,6 @@ Operation::GetElevation( int nPhase, const Point3d& ptP1, const Point3d& ptP2, c
    return true ;
 }
 
-#if 0
-
-//----------------------------------------------------------------------------
-bool
-Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad,
-                         const Vector3d& vtDir, double& dElev) const
-{
-   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
-      return false ;
-  // vettore grezzi interessati
-   INTVECTOR vRawStmId ;
-  // considero il punto centrale
-   if ( ! GetElevation( nPhase, ptP, vtDir, dElev, vRawStmId))
-      return false ;
-  // considero più posizioni sulla circonferenza
-   const int MIN_STEP = 9 ;
-   const int MAX_STEP = 127 ;
-   const double LEN_STEP = 12.5 ;
-   int nStep = Clamp( 2 * int( ( PIGRECO * dRad) / LEN_STEP) + 1, MIN_STEP, MAX_STEP) ;
-   Vector3d vtRad = FromUprightOrtho( vtTool) * dRad ;
-   for ( int i = 0 ; i < nStep ; ++ i) {
-      double dElevT = 0 ;
-      if ( ! GetElevation( nPhase, ptP + vtRad, vtDir, dElevT, vRawStmId))
-         return false ;
-      dElev = max( dElev, dElevT) ;
-     // passo alla direzione successiva
-      vtRad.Rotate( vtTool, ANG_FULL / nStep) ;
-   }
-  // considero i vertici che cadono entro il cilindro positivo spazzato dal fondo utensile
-   for ( auto nRawStmId : vRawStmId) {
-     // recupero la superficie
-      const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nRawStmId)) ;
-      if ( pStm != nullptr) {
-        // recupero il riferimento della trimesh
-         Frame3d frStm ;
-         m_pGeomDB->GetGlobFrame( nRawStmId, frStm) ;
-        // ciclo sui vertici
-         Point3d ptV ;
-         int nV = pStm->GetFirstVertex( ptV) ;
-         while ( nV != SVT_NULL) {
-            ptV.ToGlob( frStm) ;
-            double dDist = ( ptV - ptP) * vtDir ;
-            if ( dDist > EPS_ZERO) {
-               if ( AreSameOrOppositeVectorApprox( vtTool, vtDir)) {
-                  Vector3d vtOrtho = OrthoCompo( ptV - ptP, vtDir) ;
-                  if ( vtOrtho.SqLen() < dRad * dRad + EPS_ZERO)
-                     dElev = max( dElev, dDist) ;
-               }
-               else {
-                  Vector3d vtOrtho = OrthoCompo( ptV - ptP, vtDir) ;
-                  Vector3d vtMajAx = vtTool ^ vtDir ; vtMajAx.Normalize( EPS_ZERO) ;
-                  Vector3d vtMajOrt = ParallCompo( vtOrtho, vtMajAx) ;
-                  Vector3d vtMinOrt = ( vtOrtho - vtMajOrt) / abs( vtTool * vtDir) ;
-                  if ( vtMajOrt.SqLen() + vtMinOrt.SqLen() < dRad * dRad + EPS_ZERO)
-                     dElev = max( dElev, dDist) ;
-               }
-            }
-            nV = pStm->GetNextVertex( nV, ptV) ;
-         }
-      }
-   }
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad, double dLen,
-                         const Vector3d& vtDir, double& dElev) const
-{
-   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
-      return false ;
-  // sopra e sotto
-   double dElev1, dElev2 ;
-   if ( ! GetElevation( nPhase, ptP, vtTool, dRad, vtDir, dElev1))
-      return false ;
-   if ( ! GetElevation( nPhase, ptP + dLen * vtTool, vtTool, dRad, vtDir, dElev2))
-      return false ;
-   dElev = max( dElev1, dElev2) ;
-   return true ;
-}
-
-#else
-
 //----------------------------------------------------------------------------
 bool
 Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad,
@@ -562,8 +478,6 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool,
    return true ;
 }
 
-#endif
-
 //----------------------------------------------------------------------------
 bool
 Operation::GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
@@ -603,17 +517,17 @@ Operation::GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, doubl
            // determino elevazione del punto rispetto al grezzo a metà altezza
             Point3d ptTest( ptP.x, ptP.y, dRawCentZ) ; 
             double dNewElev ;
-            if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
+            if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
                dElev = max( dElev, dNewElev) ;
            // se direzione di fuga quasi orizzontale (max 30 deg) e ingombro utensile rilevante rispetto ad altezza grezzo
             if ( vtMyDir.z < 0.5  &&  dToolDimZ > dRawDimZ / 2) {
               // determino elevazione del punto rispetto al grezzo a metà altezza più metà ingombro utensile
                ptTest = Point3d( ptP.x, ptP.y, dRawCentZ + dToolDimZ / 2) ; 
-               if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
+               if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
                   dElev = max( dElev, dNewElev) ;
               // determino elevazione del punto rispetto al grezzo a metà altezza meno metà ingombro utensile
                ptTest = Point3d( ptP.x, ptP.y, dRawCentZ - dToolDimZ / 2) ; 
-               if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
+               if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
                   dElev = max( dElev, dNewElev) ;
             }
             return true ;
@@ -663,17 +577,17 @@ Operation::GetUhPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool, doubl
            // determino elevazione del punto rispetto al grezzo a metà altezza
             Point3d ptTest( ptP.x, ptP.y, dRawCentZ) ; 
             double dNewElev ;
-            if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
+            if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
                dElev = max( dElev, dNewElev) ;
            // se direzione di fuga quasi orizzontale (max 30 deg) e ingombro utensile rilevante rispetto ad altezza grezzo
             if ( vtMyDir.z > -0.5  &&  dToolDimZ > dRawDimZ / 2) {
               // determino elevazione del punto rispetto al grezzo a metà altezza più metà ingombro utensile
                ptTest = Point3d( ptP.x, ptP.y, dRawCentZ + dToolDimZ / 2) ; 
-               if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
+               if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
                   dElev = max( dElev, dNewElev) ;
               // determino elevazione del punto rispetto al grezzo a metà altezza meno metà ingombro utensile
                ptTest = Point3d( ptP.x, ptP.y, dRawCentZ - dToolDimZ / 2) ; 
-               if ( GetElevation( m_nPhase, ptTest - 10 * EPS_SMALL * vtTool, vtTool, dToolRadForElev, vtMyDir, dNewElev))
+               if ( GetElevation( m_nPhase, ptTest, vtTool, dToolRadForElev, vtMyDir, dNewElev))
                   dElev = max( dElev, dNewElev) ;
             }
             return true ;