diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp
index e8ab693..d3f83f6 100644
--- a/VolZmapVolume.cpp
+++ b/VolZmapVolume.cpp
@@ -1012,7 +1012,7 @@ VolZmap::MillingStep( int nCurrTool,
    return MillingStep( nCurrTool, ptPs, vtDs, Vector3d(), ptPe, vtDe, Vector3d()) ;
 }
 
-//static double dTotCount = 0. ;
+static double dTotCount = 0. ;
 
 //----------------------------------------------------------------------------       
 bool
@@ -1053,7 +1053,7 @@ VolZmap::MillingStep( int nCurrTool,
    Vector3d vtALe = GetToLoc( vtAe, m_MapFrame) ;
    vtALe.Normalize() ;
 
-   //static PerformanceCounter Counter ;
+   static PerformanceCounter Counter ;
    //{
    //string sOut = "Draw=" + ToString( Counter.Stop(), 3) ;
    //LOG_INFO( GetEGkLogger(), sOut.c_str())
@@ -1068,9 +1068,9 @@ VolZmap::MillingStep( int nCurrTool,
    else
       bOk = MillingGeneralMotionStep( ptPLs, vtDLs, vtALs, ptPLe, vtDLe, vtALe) ;
 
-   //{
+   {
    //// debug per 5 assi
-   //double dPartCount = Counter.Stop() ;
+   double dPartCount = Counter.Stop() ;
    //if ( ! AreSameVectorApprox( vtDLs, vtDLe)) {
    //   dTotCount += dPartCount ;
    //   string sOut = "Calc5Axis=" + ToString( dTotCount, 3) ;
@@ -1078,10 +1078,11 @@ VolZmap::MillingStep( int nCurrTool,
    //}
    ////debug per 5 assi
 
-   //string sOut = "Calc=" + ToString( Counter.Stop(), 3) ;
-   //LOG_INFO( GetEGkLogger(), sOut.c_str())
-   //Counter.Start() ;
-   //}
+   dTotCount += dPartCount ;
+   string sOut = "Calc=" + ToString( dTotCount, 3) ;
+   LOG_INFO( GetEGkLogger(), sOut.c_str())
+   Counter.Start() ;
+   }
 
    return bOk ;
 }
@@ -5401,6 +5402,7 @@ VolZmap::CompCyl_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, co
          Point3d ptC( dX, dY, 0) ;
          Vector3d vtC = ptC - ptIxy ;
 
+         // calcolo l'intersezione solo se ho un tratto sullo spillone che interseca il volume spazzato dal tool
          int nPos = j * m_nNx[nGrid] + i;
          vector<Data>& vDexel = m_Values[nGrid][nPos];
          DBLDBLVECTOR vInterv ;
@@ -6073,76 +6075,102 @@ VolZmap::CompCyl_Milling( int nGrid, const Point3d& ptS, const Point3d& ptE,
       vtPerp.Invert() ;
    int nSkip = 0 ;
 
+   // calcolo il box del volume spazzato
+   Frame3d frVol ; frVol.Set( ptI, vtToolDir, vtMove) ;
+   Point3d ptILoc = ptI ; ptILoc.ToLoc( frVol) ;
+   Point3d ptFLoc = ptF ; ptILoc.ToLoc( frVol) ;
+   Vector3d vtToolLoc = vtToolDir ; vtToolLoc.ToLoc( frVol) ;
+   BBox3d bbVol = GetCylMoveBBox(ptILoc, ptFLoc, vtToolLoc, dRad, dHei) ;
+   INTDBLVECTOR vIntersDash ;
+
    for ( int i = nStartI ; i <= nEndI ; ++ i) {
       for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
-      
+
          Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ;
 
-        // salto il controllo degli spilloni sotto il piano limite in basso o sopra il piano limite in alto
-         if ( ( ptC + Z_AX * m_dMinZ[nGrid] - ptITip) * vtToolDir < -EPS_SMALL  &&
-              ( ptC + Z_AX * m_dMaxZ[nGrid] - ptITip) * vtToolDir < -EPS_SMALL) {
-            ++ nSkip ;
-            continue ;
-         }
-         if ( ( ptC + Z_AX * m_dMinZ[nGrid] - ptI - vtMoveLong) * vtToolDir > EPS_SMALL &&
-              ( ptC + Z_AX * m_dMaxZ[nGrid] - ptI - vtMoveLong) * vtToolDir > EPS_SMALL) {
-            ++ nSkip ;
-            continue ;
-         }
+         // calcolo l'intersezione solo se ho un tratto sullo spillone che interseca il volume spazzato dal tool
+         int nPos = j * m_nNx[nGrid] + i;
+         vector<Data>& vDexel = m_Values[nGrid][nPos];
+         DBLDBLVECTOR vInterv ;
+         for (int k = 0; k < int ( vDexel.size () ); ++k)
+            vInterv.emplace_back ( vDexel[k].dMin, vDexel[k].dMax ) ;
 
-        // salto il controllo degli spilloni prima del piano di fianco verticale di inizio o dopo il piano di fianco verticale di fine
-         if ( bPerpOk  &&
-              ( ptC + Z_AX * m_dMinZ[nGrid] - ptI + vtPerp * dRad) * vtPerp < -EPS_SMALL  &&
-              ( ptC + Z_AX * m_dMaxZ[nGrid] - ptI + vtPerp * dRad) * vtPerp < -EPS_SMALL) {
-            ++ nSkip ;
-            continue ;
-         }
-         if ( bPerpOk  &&
-              ( ptC + Z_AX * m_dMinZ[nGrid] - ptF - vtPerp * dRad) * vtPerp > EPS_SMALL  &&
-              ( ptC + Z_AX * m_dMaxZ[nGrid] - ptF - vtPerp * dRad) * vtPerp > EPS_SMALL) {
-            ++ nSkip ;
-            continue ;
-         }
-
-         Point3d ptInt1, ptInt2 ;
-         Vector3d vtN1, vtN2 ;
-
-        // Cilindro iniziale
-         CylFrame.ChangeOrig( ptITip) ;
-         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, bTapB, bTapT, ptInt1, vtN1, ptInt2, vtN2)) {
-            SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
-         }
-
-        // Cilindro finale:L'unica differenza rispetto a prima è l'origine 
-        // del sistema di riferimento, quindi usiamo lo stesso sistema sommando a ptC
-        // il vettore che congiunge le due origini.
-         CylFrame.ChangeOrig( ptITip + vtMove) ;
-         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, bTapB, bTapT, ptInt1, vtN1, ptInt2, vtN2)) {
-            SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
-         }
-
-        // Poliedro interno
-         CylFrame.ChangeOrig( ptITip) ;
-         if ( IntersLineMyPolyhedron( ptC, Z_AX, CylFrame, dOrtLen, 2 * dRad, dHei,
-                                      dLongLen, ptInt1, vtN1, ptInt2, vtN2)) {
-            SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
-         }
-        
-        // Se movimento non ortogonale all'asse cilindro ellittico di punta
-         if ( dLongLen > EPS_SMALL) {
-            CylFrame.ChangeOrig( ptITip) ;
-            if ( IntersLineEllipticalCylinder( ptC, Z_AX, CylFrame, dRad, dLongLen, dOrtLen, 
-                                               bTapB, true, ptInt1, vtN1, ptInt2, vtN2)) {
-               SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
+         Point3d ptCLoc = ptC ; ptCLoc.ToLoc( frVol) ;
+         Vector3d vtZLoc = Z_AX ; vtZLoc.ToLoc( frVol) ;
+         bool bIntersVol = false ;
+         if ( vDexel.size () != 0) {
+            for (int k = 0; k < int ( vInterv.size () ) && !bIntersVol; ++k) {
+               IntersLineBox ( ptCLoc + vtZLoc * vInterv[k].first, ptCLoc + vtZLoc * vInterv[k].second, bbVol, vIntersDash, true ) ;
+               bIntersVol = vIntersDash.size () > 0 ;
             }
+            if ( bIntersVol) {
+              // salto il controllo degli spilloni sotto il piano limite in basso o sopra il piano limite in alto
+               if ( ( ptC + Z_AX * m_dMinZ[nGrid] - ptITip) * vtToolDir < -EPS_SMALL  &&
+                    ( ptC + Z_AX * m_dMaxZ[nGrid] - ptITip) * vtToolDir < -EPS_SMALL) {
+                  ++ nSkip ;
+                  continue ;
+               }
+               if ( ( ptC + Z_AX * m_dMinZ[nGrid] - ptI - vtMoveLong) * vtToolDir > EPS_SMALL &&
+                    ( ptC + Z_AX * m_dMaxZ[nGrid] - ptI - vtMoveLong) * vtToolDir > EPS_SMALL) {
+                  ++ nSkip ;
+                  continue ;
+               }
+
+              // salto il controllo degli spilloni prima del piano di fianco verticale di inizio o dopo il piano di fianco verticale di fine
+               if ( bPerpOk  &&
+                    ( ptC + Z_AX * m_dMinZ[nGrid] - ptI + vtPerp * dRad) * vtPerp < -EPS_SMALL  &&
+                    ( ptC + Z_AX * m_dMaxZ[nGrid] - ptI + vtPerp * dRad) * vtPerp < -EPS_SMALL) {
+                  ++ nSkip ;
+                  continue ;
+               }
+               if ( bPerpOk  &&
+                    ( ptC + Z_AX * m_dMinZ[nGrid] - ptF - vtPerp * dRad) * vtPerp > EPS_SMALL  &&
+                    ( ptC + Z_AX * m_dMaxZ[nGrid] - ptF - vtPerp * dRad) * vtPerp > EPS_SMALL) {
+                  ++ nSkip ;
+                  continue ;
+               }
+
+               Point3d ptInt1, ptInt2 ;
+               Vector3d vtN1, vtN2 ;
+
+              // Cilindro iniziale
+               CylFrame.ChangeOrig( ptITip) ;
+               if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, bTapB, bTapT, ptInt1, vtN1, ptInt2, vtN2)) {
+                  SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
+               }
+
+              // Cilindro finale:L'unica differenza rispetto a prima è l'origine 
+              // del sistema di riferimento, quindi usiamo lo stesso sistema sommando a ptC
+              // il vettore che congiunge le due origini.
+               CylFrame.ChangeOrig( ptITip + vtMove) ;
+               if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, bTapB, bTapT, ptInt1, vtN1, ptInt2, vtN2)) {
+                  SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
+               }
+
+              // Poliedro interno
+               CylFrame.ChangeOrig( ptITip) ;
+               if ( IntersLineMyPolyhedron( ptC, Z_AX, CylFrame, dOrtLen, 2 * dRad, dHei,
+                                            dLongLen, ptInt1, vtN1, ptInt2, vtN2)) {
+                  SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
+               }
+        
+              // Se movimento non ortogonale all'asse cilindro ellittico di punta
+               if ( dLongLen > EPS_SMALL) {
+                  CylFrame.ChangeOrig( ptITip) ;
+                  if ( IntersLineEllipticalCylinder( ptC, Z_AX, CylFrame, dRad, dLongLen, dOrtLen, 
+                                                     bTapB, true, ptInt1, vtN1, ptInt2, vtN2)) {
+                     SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
+                  }
            
-           // Cilindro ellittico di base: L'unica differenza rispetto a prima è l'origine
-           // del sistema di riferimento, quindi usiamo lo stesso sistema sommando a ptC
-           // il vettore che congiunge le due origini.
-            CylFrame.ChangeOrig( ptITip + dHei * vtV1) ;
-            if ( IntersLineEllipticalCylinder( ptC, Z_AX, CylFrame, dRad, dLongLen, dOrtLen,
-                                               true, bTapT, ptInt1, vtN1, ptInt2, vtN2)) {
-               SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
+                 // Cilindro ellittico di base: L'unica differenza rispetto a prima è l'origine
+                 // del sistema di riferimento, quindi usiamo lo stesso sistema sommando a ptC
+                 // il vettore che congiunge le due origini.
+                  CylFrame.ChangeOrig( ptITip + dHei * vtV1) ;
+                  if ( IntersLineEllipticalCylinder( ptC, Z_AX, CylFrame, dRad, dLongLen, dOrtLen,
+                                                     true, bTapT, ptInt1, vtN1, ptInt2, vtN2)) {
+                     SubtractIntervals( nGrid, i, j, ptInt1.z, ptInt2.z, vtN1, vtN2, nToolNum) ;
+                  }
+               }
             }
          }
       }