diff --git a/Milling.cpp b/Milling.cpp
index cbf2a30..ee86ae2 100644
--- a/Milling.cpp
+++ b/Milling.cpp
@@ -2244,18 +2244,6 @@ Milling::GenerateMillingPv( int nPathId, const ICurveComposite* pCompo, double d
    return true ;
 }
 
-//----------------------------------------------------------------------------
-static bool
-VerifyEscapeDir( const Vector3d& vtCorr, const Vector3d& vtTool, bool bAboveHead)
-{
-   if ( bAboveHead  &&  AreSameVectorApprox( vtCorr, -Z_AX))
-      return false ;
-   if ( ! bAboveHead  &&  AreSameVectorApprox( vtCorr, Z_AX))
-      return false ;
-   Vector3d vtEsc( vtCorr.x, vtCorr.y, 0) ;
-   return ( vtEsc.Normalize()  &&  vtEsc * vtTool > -0.5) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
@@ -2264,11 +2252,13 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
   // recupero distanze di sicurezza
    double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
    double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
+  // extra lunghezza utensile
+   double dExtraLen = max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
-   double dExtrAppr = dAppr + max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;
+   double dExtrAppr = dAppr + dExtraLen ;
   // delta da punto lavoro a punto tip
-   Vector3d vtWkTip = vtTool * ( m_TParams.m_dLen - m_TParams.m_dTLen) ; 
+   Vector3d vtWkTip = -vtTool * dExtraLen ; 
 
   // in caso di tabs ne aggiusto i parametri secondo il percorso
    TabData tdTabs ;
@@ -2282,7 +2272,6 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
 
   // ciclo sulle curve elementari
    bool bOk = true ;
-   bool bClosed = pCompo->IsClosed() ;
    m_dCurrTabsLen = 0 ;
    m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
    int nMaxInd = pCompo->GetCurveCount() - 1 ;
@@ -2303,7 +2292,9 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
          Vector3d vtStart = m_vtStartDir ;
         // determino elevazione su inizio percorso di lavoro
          double dStElev ;
-         if ( ! GetElevation( m_nPhase, ptStart + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
+         if ( GetElevation( m_nPhase, ptStart + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
+            dStElev = max( dStElev - dExtraLen, 0.) ;
+         else
             dStElev = dElev ;
         // determino inizio attacco
          Point3d ptP1 ;
@@ -2315,7 +2306,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
          Vector3d vtAppr( vtTool.x, vtTool.y, 0) ;
          if ( ! vtAppr.Normalize())
             vtAppr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
-         bool bOutStart = GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtAppr, dStElev, dSafeZ) ;
+         bool bOutStart = GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtAppr, dSafeZ) ;
         // determino se l'inizio dell'attacco è sopra il grezzo
          bool bGeomAboveStart = GetPointAboveRaw( ptP1 + vtWkTip, vtTool) ;
          bool bAboveStart = false ;
@@ -2341,13 +2332,17 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
             }
             double dNewStElev ;
             if ( GetElevation( m_nPhase, ptP1 + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewStElev))
-               dStElev = min( dStElev, dNewStElev) ;
+               dStElev = min( dStElev, max( dNewStElev - dExtraLen, 0.)) ;
            // 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 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                      m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
+            if ( bAhUnderStart)
+               dStElev = max( dStElev - dExtraLen, 0.) ;
            // se testa sotto, determino se l'inizio dell'attacco è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
             bool bUhAboveStart = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                        m_TParams.m_dLen, false, dSafeZ, vtEscape, dStElev) ;
+            if ( bUhAboveStart)
+               dStElev = max( dStElev - dExtraLen, 0.) ;
            // se attacco a zigzag o a spirale, l'elevazione va nell'attacco
             if ( IsLeadInHelixOrZigzag()) {
                ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ;
@@ -2480,7 +2475,9 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
          Vector3d vtEnd = m_vtEndDir ;
         // elevazione sul punto finale
          double dEndElev ;
-         if ( ! GetElevation( m_nPhase, ptEnd + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
+         if ( GetElevation( m_nPhase, ptEnd + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
+            dEndElev = max( dEndElev - dExtraLen, 0.) ;
+         else
             dEndElev = dElev ;
         // aggiungo uscita
          Point3d ptP1 ;
@@ -2494,7 +2491,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
          Vector3d vtRetr( vtTool.x, vtTool.y, 0) ;
          if ( ! vtRetr.Normalize())
             vtRetr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
-         bool bOutEnd = GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtRetr, dEndElev, dSafeZ) ;
+         bool bOutEnd = GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtRetr, dSafeZ) ;
         // aggiungo retrazione per frese normali e frese che non lavorano di testa già fuori
          if ( ( m_TParams.m_nType & TF_MILL) != 0  &&
               ( m_TParams.m_nType != TT_MILL_NOTIP  ||  m_bEndOutRaw)) {
@@ -2505,7 +2502,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
                   bAboveEnd = GetPointAboveRaw( ptP1 + vtWkTip, vtTool) ;
                else {
                   Vector3d vtCorr = CalcCorrDir( pCompo, nMaxInd + 1, false, true) ;
-                  if ( GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtCorr, dEndElev, dSafeZ))
+                  if ( GetPointOutOfRaw( ptP1 + vtWkTip, vtTool, vtCorr, dSafeZ))
                      dEndElev = min( dEndElev, dElev) ;
                }
             }
@@ -2518,13 +2515,17 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
             }
             double dNewEndElev ;
             if ( GetElevation( m_nPhase, ptP1 + vtWkTip, vtTool, GetRadiusForStartEndElevation(), vtEscape, dNewEndElev))
-               dEndElev = min( dEndElev, dNewEndElev) ;
+               dEndElev = min( dEndElev, max( dNewEndElev - dExtraLen, 0.)) ;
            // 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 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                    m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
+            if ( bAhUnderEnd)
+               dEndElev = max( dEndElev - dExtraLen, 0.) ;
            // se testa sotto, determino se l'inizio dell'uscita è esattamente sopra il grezzo, nel qual caso ricalcolo l'elevazione
             bool bUhAboveEnd = ! m_bAboveHead && GetUhPointAboveRaw( ptP1 + vtWkTip, vtTool, 0, GetRadiusForStartEndElevation(),
                                                                      m_TParams.m_dLen, false, dSafeZ, vtEscape, dEndElev) ;
+            if ( bUhAboveEnd)
+               dEndElev = max( dEndElev - dExtraLen, 0.) ;
            // aggiungo retrazione
             if ( ! AddRetract( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dEndElev, dExtrAppr, bAboveEnd, bSplitArcs)) {
                m_pMchMgr->SetLastError( 2312, "Error in Milling : Retract not computable") ;
@@ -2632,7 +2633,6 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
    AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
 
   // altri dati del percorso
-   bool bClosed = pCompo->IsClosed() ;
    int nMaxInd = pCompo->GetCurveCount() - 1 ;
 
   // ciclo sugli step
@@ -2675,7 +2675,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
             Vector3d vtAppr( vtTool.x, vtTool.y, 0) ;
             if ( ! vtAppr.Normalize())
                vtAppr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
-            bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dStElev, dSafeZ) ;
+            bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dSafeZ) ;
            // determino se l'inizio dell'attacco è sopra il grezzo
             bool bGeomAboveStart = GetPointAboveRaw( ptP1, vtTool) ;
             bool bAboveStart = false ;
@@ -2887,7 +2887,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
             Vector3d vtRetr( vtTool.x, vtTool.y, 0) ;
             if ( ! vtRetr.Normalize())
                vtRetr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
-            bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dEndElev, dSafeZ) ;
+            bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dSafeZ) ;
            // per lame e frese che non lavorano di testa quando ancora dentro aggiungo retrazione se necessaria
             if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0  ||
                  ( m_TParams.m_nType == TT_MILL_NOTIP  &&  ! m_bEndOutRaw  &&  ! bOutEnd)) {
@@ -2951,7 +2951,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                      bAboveEnd = GetPointAboveRaw( ptP1, vtTool) ;
                   else {
                      Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? 0 : nMaxInd + 1), false, true) ;
-                     if ( GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ))
+                     if ( GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ))
                         dEndElev = min( dEndElev, dElev) ;
                   }
                }
@@ -3137,7 +3137,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                Vector3d vtAppr( vtTool.x, vtTool.y, 0) ;
                if ( ! vtAppr.Normalize())
                   vtAppr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
-               bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dStElev, dSafeZ) ;
+               bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtAppr, dSafeZ) ;
               // aggiungo approccio per frese normali e frese che non lavorano di testa con attacco opportuno oppure fuori
                if ( ( m_TParams.m_nType & TF_MILL) != 0  &&
                     ( m_TParams.m_nType != TT_MILL_NOTIP  ||  LeadInRawIsOk()  ||  m_bStartOutRaw)) {
@@ -3343,7 +3343,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                Vector3d vtRetr( vtTool.x, vtTool.y, 0) ;
                if ( ! vtRetr.Normalize())
                   vtRetr = FromNearestHorizontalOrtho( vtTool, vtDir1) ;
-               bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dEndElev, dSafeZ) ;
+               bool bOutEnd = GetPointOutOfRaw( ptP1, vtTool, vtRetr, dSafeZ) ;
               // aggiungo retrazione per frese normali e frese che non lavorano di testa già fuori
                if ( ( m_TParams.m_nType & TF_MILL) != 0  && 
                     ( m_TParams.m_nType != TT_MILL_NOTIP  ||  m_bEndOutRaw)) {
@@ -3520,7 +3520,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                   return false ;
               // determino se l'inizio dell'attacco è fuori dal grezzo
                Vector3d vtCorr = CalcCorrDir( pCompo, i) ;
-               bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ;
+               bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
               // determino se l'inizio dell'attacco è sopra il grezzo
                bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
               // imposto versore correzione e ausiliario sul punto di partenza
@@ -3708,7 +3708,7 @@ Milling::AddSpiralMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                   return false ;
               // determino se l'inizio dell'attacco è fuori dal grezzo
                Vector3d vtCorr = CalcCorrDir( pCompo, ( bInvert ? nMaxInd - i + 1 : i)) ;
-               bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ;
+               bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
               // determino se l'inizio dell'attacco è sopra il grezzo
                bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
               // imposto versore correzione e ausiliario sul punto di partenza
@@ -3884,11 +3884,6 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT
 {
   // recupero distanze di sicurezza
    double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
-   double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
-  // lunghezza di approccio/retrazione
-   double dAppr = m_Params.m_dStartPos ;
-  // flag di percorso chiuso
-   bool bClosed = pCompo->IsClosed() ;
 
   // recupero eventuale superficie trimesh chiusa per trim/extend
    int nTriExtCstm = GDB_ID_NULL ;
@@ -3970,7 +3965,7 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT
                return false ;
            // determino se l'inizio dell'attacco è fuori dal grezzo
             Vector3d vtCorr = CalcCorrDir( pMyCompo, i, bInvert, true) ;
-            bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ;
+            bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
            // determino se l'inizio dell'attacco è sopra il grezzo
             bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
            // imposto versore correzione e ausiliario sul punto di partenza
@@ -4065,11 +4060,6 @@ Milling::AddSawOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtT
 {
   // recupero distanze di sicurezza
    double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
-   double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
-  // lunghezza di approccio/retrazione
-   double dAppr = m_Params.m_dStartPos ;
-  // flag di percorso chiuso
-   bool bClosed = pCompo->IsClosed() ;
 
   // recupero eventuale superficie trimesh chiusa per trim/extend
    int nTriExtCstm = GDB_ID_NULL ;
@@ -4154,7 +4144,7 @@ Milling::AddSawOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtT
                return false ;
            // determino se l'inizio dell'attacco è fuori dal grezzo
             Vector3d vtCorr = CalcCorrDir( pMyCompo, i, bReturn, true) ;
-            bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dElev, dSafeZ) ;
+            bool bOutStart = GetPointOutOfRaw( ptP1, vtTool, vtCorr, dSafeZ) ;
            // determino se l'inizio dell'attacco è sopra il grezzo
             bool bAboveStart = m_bAboveHead && GetPointAboveRaw( ptP1, vtTool) ;
            // imposto versore correzione e ausiliario sul punto di partenza
@@ -6221,7 +6211,7 @@ Milling::GetSimplePointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, con
 
 //----------------------------------------------------------------------------
 bool
-Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtRetr, double dElev, double dSafeZ) const
+Milling::GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtRetr, double dSafeZ) const
 {
   // per frese normali
    if ( m_TParams.m_nType == TT_MILL_STD) {
diff --git a/Milling.h b/Milling.h
index 4383b48..71d7955 100644
--- a/Milling.h
+++ b/Milling.h
@@ -125,7 +125,7 @@ class Milling : public Machining
       bool AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs) ;
       double GetRadiusForStartEndElevation( bool bExtra = true) const ;
       bool GetSimplePointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtRetr) const ;
-      bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtRetr, double dElev, double dSafeZ) const ;
+      bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtRetr, double dSafeZ) const ;
       bool GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const ;
       bool GetPointBelowRaw( const Point3d& ptP, const Vector3d& vtTool) const ;
       bool CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU, bool bInvertSide = false, bool bSawSpecial = false) ;
diff --git a/SurfRoughing.cpp b/SurfRoughing.cpp
index 51e38d5..25a818b 100644
--- a/SurfRoughing.cpp
+++ b/SurfRoughing.cpp
@@ -1332,7 +1332,7 @@ SurfRoughing::AddPocket( const INTVECTOR& vPocket, const Vector3d& vtTool, const
       const ISurfFlatRegion* pSfr = GetSurfFlatRegion( m_pGeomDB->GetGeoObj( nPockId)) ;
       ICRVCOMPOPOVECTOR vpCrvs ;
       if ( ! CalcPocketing( pSfr, m_TParams.m_dDiam / 2, GetOffsR(), m_Params.m_dSideStep, m_Params.m_dSideAngle,
-                            m_Params.m_nSubType, false, vpCrvs))
+                            m_Params.m_nSubType, true, vpCrvs))
          return false ;
      // ciclo sui percorsi
       for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) {