diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp
index 15769f9..cec7fae 100644
--- a/VolZmapVolume.cpp
+++ b/VolZmapVolume.cpp
@@ -5389,8 +5389,11 @@ VolZmap::CompCyl_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, co
    double dMin, dMax ;
    Vector3d vtMin, vtMax ;
 
-   for ( int i = nStartI ; i <= nEndI ; ++ i) {
-      for ( int j = nStartJ ; j <= nEndJ ; ++ j) {
+   // calcolo il box del volume spazzato
+   BBox3d bbVol = GetCylMoveBBox(ptS, ptE, vtToolDir, dRad, dHei) ;
+   INTDBLVECTOR vIntersDash ;
+   for ( int i = nStartI ; i <= nEndI ; ++i) {
+      for ( int j = nStartJ ; j <= nEndJ ; ++j) {
 
          double dX = ( i + 0.5) * m_dStep ;
          double dY = ( j + 0.5) * m_dStep ;
@@ -5398,56 +5401,70 @@ VolZmap::CompCyl_ZMilling( int nGrid, const Point3d& ptS, const Point3d& ptE, co
          Point3d ptC( dX, dY, 0) ;
          Vector3d vtC = ptC - ptIxy ;
 
-         double dX1 = vtC * vtV1 ;
-         double dX2 = vtC * vtV2 ;
+         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 ) ;
 
-         //Point3d ptInt ;
-
-        // Se il punto appartiene alla proiezione del volume spazzato valuto massimo e minimo
-         if ( ( dX1 > 0 && dX1 < dLenXY && abs( dX2) < dSafeRad)    ||
-              ( dX1 - dLenXY) * ( dX1 - dLenXY) + dX2 * dX2 < dSqRad || 
-                dX1 * dX1 + dX2 * dX2 < dSqRad) {
-
-            double dX1_0 = sqrt( dSqRad - dX2 * dX2) ;
-           // Massimo
-            if ( ( dX1 - dLenXY) * ( dX1 - dLenXY) + dX2 * dX2 < dSqRad) {
-               dMax = dZMaxF ;
-               vtMax = - Z_AX ;
+         bool bIntersVol = false ;
+         if (vDexel.size () != 0  ||  true) {  // debug
+            for (int k = 0; k < int ( vInterv.size () ) && !bIntersVol; ++k) {
+               IntersLineBox ( ptC + Z_AX * vInterv[k].first, ptC + Z_AX * vInterv[k].second, bbVol, vIntersDash, true ) ;
+               bIntersVol = vIntersDash.size () > 0 ;
             }
+            if (bIntersVol  ||  true) { // debug
+               double dX1 = vtC * vtV1 ;
+               double dX2 = vtC * vtV2 ;
 
-            else {
-               dMax = dZMaxI + dDeltaZ * ( dX1 + dX1_0) / dLenXY ;
-               if ( abs( vtMove * vtToolDir) < EPS_SMALL) {
-                  vtMax = - Z_AX ;
-               }
-               else {
-                  Vector3d vtCirc = dX1_0 * vtV1 - dX2 * vtV2 ;
-                  Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
-                  Vector3d vtCross = vtTan ^ vtMove ;
-                  vtMax = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ;
-                  vtMax.Normalize() ;
+               //Point3d ptInt ;
+
+              // Se il punto appartiene alla proiezione del volume spazzato valuto massimo e minimo
+               if ( ( dX1 > 0 && dX1 < dLenXY && abs( dX2) < dSafeRad)    ||
+                    ( dX1 - dLenXY) * ( dX1 - dLenXY) + dX2 * dX2 < dSqRad || 
+                        dX1 * dX1 + dX2 * dX2 < dSqRad) {
+
+                  double dX1_0 = sqrt( dSqRad - dX2 * dX2) ;
+                  // Massimo
+                  if ( ( dX1 - dLenXY) * ( dX1 - dLenXY) + dX2 * dX2 < dSqRad) {
+                     dMax = dZMaxF ;
+                     vtMax = - Z_AX ;
+                  }
+
+                  else {
+                     dMax = dZMaxI + dDeltaZ * ( dX1 + dX1_0) / dLenXY ;
+                     if ( abs( vtMove * vtToolDir) < EPS_SMALL) {
+                        vtMax = - Z_AX ;
+                     }
+                     else {
+                        Vector3d vtCirc = dX1_0 * vtV1 - dX2 * vtV2 ;
+                        Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
+                        Vector3d vtCross = vtTan ^ vtMove ;
+                        vtMax = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ;
+                        vtMax.Normalize() ;
+                     }
+                  }
+                  // Minimo
+                  if ( dX1 * dX1 + dX2 * dX2 < dSqRad) {
+                     dMin = dZMinI ;
+                     vtMin = Z_AX ;
+                  }
+                  else {
+                        dMin = dZMinI + dDeltaZ * ( dX1 - dX1_0) / dLenXY ;
+                        if ( abs( vtMove * vtToolDir) < EPS_SMALL) {
+                        vtMin = Z_AX ;
+                     }
+                     else {
+                        Vector3d vtCirc = - dX1_0 * vtV1 - dX2 * vtV2 ;
+                        Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
+                        Vector3d vtCross = vtTan ^ vtMove ;
+                        vtMin = (vtCross * vtCirc > 0 ? vtCross : -vtCross) ;
+                        vtMin.Normalize () ;
+                     }
+                  }
                }
             }
-           // Minimo
-            if ( dX1 * dX1 + dX2 * dX2 < dSqRad) {
-               dMin = dZMinI ;
-               vtMin = Z_AX ;
-            }
-            else {
-               dMin = dZMinI + dDeltaZ * ( dX1 - dX1_0) / dLenXY ;
-               if ( abs( vtMove * vtToolDir) < EPS_SMALL) {
-                  vtMin = Z_AX ;
-               }
-               else {
-                  Vector3d vtCirc = - dX1_0 * vtV1 - dX2 * vtV2 ;
-                  Vector3d vtTan( - vtCirc.y, vtCirc.x, 0) ;
-                  Vector3d vtCross = vtTan ^ vtMove ;
-                  vtMin = ( vtCross * vtCirc > 0 ? vtCross : - vtCross) ;
-                  vtMin.Normalize() ;
-               }
-            }
-            SubtractIntervals( nGrid, i, j, dMin, dMax, vtMin, vtMax, nToolNum) ;
-         }    
+         }
       }
    }
    return true ;