diff --git a/VolZmap.cpp b/VolZmap.cpp
index 9629982..3b86ac0 100644
--- a/VolZmap.cpp
+++ b/VolZmap.cpp
@@ -399,47 +399,37 @@ VolZmap::CreateMap( const Point3d& ptO, double dLengthX, double dLengthY, double
 bool
 VolZmap::SubtractIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMax)    
 {
-   unsigned int nPos ;
-
-   
-   // Controllo che dMin e dMax non siano quasi coincidenti
+  // Controllo che dMin e dMax non siano quasi coincidenti
    if ( abs( dMax - dMin) < EPS_SMALL)
-   
       return true ;
-   // Controllo che dMin < dMax
 
-   if ( dMax < dMin ) {
+  // Controllo che dMin < dMax
+   if ( dMax < dMin )
+      swap( dMax, dMin) ;
    
-         double dTemp = dMax ;
-   
-         dMax = dMin ;
-         dMin = dTemp ; // cambiato il 3/2
-   }
-   
-   // Calcolo nPos
-   nPos = nJ*m_nNx + nI ;  // O nJ*m_Nx + nI + 1 ?
+  // Calcolo nPos dello spillone
+   unsigned int nPos = nJ * m_nNx + nI ;
 
+  // Ciclo sugli intervalli dello spillone
+   bool bModified = false ;
    unsigned int i = 0 ;
+   while ( i + 1 < m_ZValues[nPos].size()) {
 
-   while ( i < m_ZValues[nPos].size() - 1) {
-
-      if ( m_ZValues[nPos].size() == 0)
-         return true ;
-      // Casi:
-      // Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione 
+     // Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione 
       if ( m_ZValues[nPos][i] > dMax - EPS_SMALL) {
-      
+         ;
       }
-      // Intersezione
+
+     // Intersezione
       else if ( m_ZValues[nPos][i + 1] > dMax + EPS_SMALL) {
          // L'intervallo corrente corrente viene limitato a sinistra
          if ( m_ZValues[nPos][i] > dMin - EPS_SMALL) {
-         
+            bModified = true ;
             m_ZValues[nPos][i] = dMax ;
          }
          // L'intervallo si divide in due intervalli
          else {
-
+            bModified = true ;
             m_ZValues[nPos].resize( m_ZValues[nPos].size() + 2) ;
 
             for ( size_t j = m_ZValues[nPos].size() - 1 ; j >= i + 3 ; -- j)
@@ -452,10 +442,11 @@ VolZmap::SubtractIntervals( unsigned int nI, unsigned int nJ, double dMin, doubl
             i = i + 2 ;
          }
       }
+
       else {
-         // L'intervallo corrente viene eliminato
+        // L'intervallo corrente viene eliminato
          if ( m_ZValues[nPos][i] > dMin - EPS_SMALL) {
-         
+            bModified = true ;
             for ( unsigned int j = i ; j < m_ZValues[nPos].size() - 2 ; ++ j)
 
                m_ZValues[nPos][j] = m_ZValues[nPos][j + 2] ;
@@ -464,192 +455,23 @@ VolZmap::SubtractIntervals( unsigned int nI, unsigned int nJ, double dMin, doubl
 
             i = i - 2 ;
          }
-         // L'intervallo corrente viene limitato a destra
+        // L'intervallo corrente viene limitato a destra
          else if ( m_ZValues[nPos][i + 1] > dMin + EPS_SMALL) {
-         
+            bModified = true ;
             m_ZValues[nPos][i + 1] = dMin ;
          }
-         // L'intervallo da sottrarre è tutto a destra di quello corrente, non vi è intersezione
+        // L'intervallo da sottrarre è tutto a destra di quello corrente, non vi è intersezione
          else {
-         
+            ;
          }
       }
       
       i = i + 2 ;
    }
 
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-VolZmap::SubtractIntervals2( unsigned int nI, unsigned int nJ, double dMin, double dMax) 
-{
-
-   unsigned int nPos ;
-
-   
-   // Controllo che dMin e dMax non siano quasi coincidenti
-   if ( abs( dMax - dMin) < EPS_SMALL)
-   
-      return true ;
-   // Controllo che dMin < dMax
-
-   if ( dMax < dMin ) {
-   
-      double dTemp = dMax ;
-   
-      dMax = dMin ;
-      dMin = dTemp ; 
-   }
-   
-   // Calcolo nPos
-   nPos = nJ * m_nNx2 + nI ;  
-
-   unsigned int i = 0 ;
-
-   while ( i < m_ZValues2[nPos].size() - 1) {
-
-      if ( m_ZValues2[nPos].size() == 0)
-         return true ;
-      // Casi:
-      // Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione 
-      if ( m_ZValues2[nPos][i] > dMax - EPS_SMALL) {
-      
-      }
-      // Intersezione
-      else if ( m_ZValues2[nPos][i + 1] > dMax + EPS_SMALL) {
-         // L'intervallo corrente corrente viene limitato a sinistra
-         if ( m_ZValues2[nPos][i] > dMin - EPS_SMALL) {
-         
-            m_ZValues2[nPos][i] = dMax ;
-         }
-         // L'intervallo si divide in due intervalli
-         else {
-
-            m_ZValues2[nPos].resize( m_ZValues2[nPos].size() + 2) ;
-
-            for ( size_t j = m_ZValues2[nPos].size() - 1 ; j >= i + 3 ; -- j)
-
-               m_ZValues2[nPos][j] = m_ZValues2[nPos][j - 2] ;
-
-            m_ZValues2[nPos][i + 1] = dMin ;
-            m_ZValues2[nPos][i + 2] = dMax ;
-
-            i = i + 2 ;
-         }
-      }
-      else {
-         // L'intervallo corrente viene eliminato
-         if ( m_ZValues2[nPos][i] > dMin - EPS_SMALL) {
-         
-            for ( unsigned int j = i ; j < m_ZValues2[nPos].size() - 2 ; ++ j)
-
-               m_ZValues2[nPos][j] = m_ZValues2[nPos][j + 2] ;
-
-            m_ZValues2[nPos].resize( m_ZValues2[nPos].size() - 2) ;
-
-            i = i - 2 ;
-         }
-         // L'intervallo corrente viene limitato a destra
-         else if ( m_ZValues2[nPos][i + 1] > dMin + EPS_SMALL) {
-         
-            m_ZValues2[nPos][i + 1] = dMin ;
-         }
-         // L'intervallo da sottrarre è tutto a destra di quello corrente, non vi è intersezione
-         else {
-         
-         }
-      }
-      
-      i = i + 2 ;
-   }
-
-   return true ;
-} 
-
-//----------------------------------------------------------------------------
-bool
-VolZmap::SubtractIntervals3( unsigned int nI, unsigned int nJ, double dMin, double dMax) 
-{
-   unsigned int nPos ;
-
-   
-   // Controllo che dMin e dMax non siano quasi coincidenti
-   if ( abs( dMax - dMin) < EPS_SMALL)
-   
-      return true ;
-   // Controllo che dMin < dMax
-
-   if ( dMax < dMin ) {
-   
-      double dTemp = dMax ;
-   
-      dMax = dMin ;
-      dMin = dTemp ; 
-   }
-   
-   // Calcolo nPos
-   nPos = nJ * m_nNx3 + nI ;  
-
-   unsigned int i = 0 ;
-
-   while ( i < m_ZValues3[nPos].size() - 1) {
-
-      if ( m_ZValues3[nPos].size() == 0)
-         return true ;
-      // Casi:
-      // Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione 
-      if ( m_ZValues3[nPos][i] > dMax - EPS_SMALL) {
-      
-      }
-      // Intersezione
-      else if ( m_ZValues3[nPos][i + 1] > dMax + EPS_SMALL) {
-         // L'intervallo corrente corrente viene limitato a sinistra
-         if ( m_ZValues3[nPos][i] > dMin - EPS_SMALL) {
-         
-            m_ZValues3[nPos][i] = dMax ;
-         }
-         // L'intervallo si divide in due intervalli
-         else {
-
-            m_ZValues3[nPos].resize( m_ZValues3[nPos].size() + 2) ;
-
-            for ( size_t j = m_ZValues3[nPos].size() - 1 ; j >= i + 3 ; -- j)
-
-               m_ZValues3[nPos][j] = m_ZValues3[nPos][j - 2] ;
-
-            m_ZValues3[nPos][i + 1] = dMin ;
-            m_ZValues3[nPos][i + 2] = dMax ;
-
-            i = i + 2 ;
-         }
-      }
-      else {
-         // L'intervallo corrente viene eliminato
-         if ( m_ZValues3[nPos][i] > dMin - EPS_SMALL) {
-         
-            for ( unsigned int j = i ; j < m_ZValues3[nPos].size() - 2 ; ++ j)
-
-               m_ZValues3[nPos][j] = m_ZValues3[nPos][j + 2] ;
-
-            m_ZValues3[nPos].resize( m_ZValues3[nPos].size() - 2) ;
-
-            i = i - 2 ;
-         }
-         // L'intervallo corrente viene limitato a destra
-         else if ( m_ZValues3[nPos][i + 1] > dMin + EPS_SMALL) {
-         
-            m_ZValues3[nPos][i + 1] = dMin ;
-         }
-         // L'intervallo da sottrarre è tutto a destra di quello corrente, non vi è intersezione
-         else {
-         
-         }
-      }
-      
-      i = i + 2 ;
-   }
+  // Se eseguita modifica, imposto ricalcolo della grafica
+   if ( bModified)
+      m_OGrMgr.Reset() ;
 
    return true ;
 }
@@ -668,8 +490,7 @@ VolZmap::SubtractIntervals( const Point3d& ptP, double dMin, double dMax)
    dX = ptPL.x ; dY = ptPL.y ; dZ = ptPL.z ;
    dhMin = dZ + dMin ; dhMax = dZ + dMax ;
 
-   // Cerco il punto della griglia più vicino
-
+   // Cerco il punto della griglia più vicino (indice è l'intero appena più basso)
    double integerPartX = floor( dX / m_dStep) ;
    double integerPartY = floor( dY / m_dStep) ;
    
@@ -699,12 +520,13 @@ VolZmap::AddIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMa
       return true ;
    
    // Controllo che dMin < dMax
-   if ( dMax < dMin )
-      swap( dMin, dMax) ;
+   if ( dMax < dMin)
+      swap( dMax, dMin) ;
    
-   // Calcolo nPos
-   unsigned int nPos = nJ * m_nNx + nI ;  // O nJ*m_Nx + nI + 1 ?
+  // Calcolo nPos
+   unsigned int nPos = nJ * m_nNx + nI ;
 
+  // Se spillone vuoto
    if ( m_ZValues[nPos].size() == 0) {
    
       m_ZValues[nPos].resize( 2) ;
@@ -712,23 +534,25 @@ VolZmap::AddIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMa
       m_ZValues[nPos][0] = dMin ;
       m_ZValues[nPos][1] = dMax ;
 
+      m_OGrMgr.Reset() ;
+
       return true ;
    }
 
+  // Ciclo sugli intervalli dello spillone
+   bool bModified = false ;
    unsigned int i = 0 ;
+   while ( i + 1 < m_ZValues[nPos].size()) {
 
-   while ( i < m_ZValues[nPos].size() - 1) {
-
+     // Eventuale aggiustamento di intervalli sovrapposti
       if ( i > 0) {
-         // Caso in cui un intervallo precedente sconfini in quello corrente
          if ( m_ZValues[nPos][i] < m_ZValues[nPos][i - 1] + EPS_SMALL) {
-            // Se l'intervallo corrente non è contenuto totalmente si esegue l'istruzione successiva
+           // Se l'intervallo corrente non è contenuto totalmente si esegue l'istruzione successiva
             if ( m_ZValues[nPos][i - 1] < m_ZValues[nPos][i + 1] + EPS_SMALL)
          
                m_ZValues[nPos][i - 1] = m_ZValues[nPos][i + 1] ;
          
             for ( unsigned int j = i ; j < m_ZValues[nPos].size() - 2 ; ++ j) 
-            
                m_ZValues[nPos][j] = m_ZValues[nPos][j + 2] ;
          
             m_ZValues[nPos].resize( m_ZValues[nPos].size() - 2) ; 
@@ -737,44 +561,46 @@ VolZmap::AddIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMa
          }
       }
 
-      // Caso in cui devo aggiungere un intervallo a sinistra dell'intervallo corrente
+     // Caso in cui devo aggiungere un intervallo a sinistra dell'intervallo corrente
       if ( m_ZValues[nPos][i] > dMax + EPS_SMALL) {
+         bModified = true ;   
+                  
+         m_ZValues[nPos].resize( m_ZValues[nPos].size() + 2) ;
          
-            m_ZValues[nPos].resize( m_ZValues[nPos].size() + 2) ;
+         for ( size_t j = m_ZValues[nPos].size() - 1 ; j >= i + 2 ; -- j) 
+            m_ZValues[nPos][j] = m_ZValues[nPos][j - 2] ;
          
-            for ( size_t j = m_ZValues[nPos].size() - 1 ; j >= i + 2 ; -- j) 
-               
-               m_ZValues[nPos][j] = m_ZValues[nPos][j - 2] ;
-         
-            m_ZValues[nPos][i] = dMin ;
-            m_ZValues[nPos][i + 1] = dMax ;
+         m_ZValues[nPos][i] = dMin ;
+         m_ZValues[nPos][i + 1] = dMax ;
 
-            i = i + 2 ;
+         i = i + 2 ;
       } 
-      // Casi d'intersezione:
+
+     // Casi d'intersezione:
       else if ( m_ZValues[nPos][i + 1] > dMax - EPS_SMALL) {
          // Se l'intervallo da aggiungere sconfina a sinistra modifico il minimo dell'intervalo corrente
-         if (m_ZValues[nPos][i] > dMin - EPS_SMALL) { 
-
+         if ( m_ZValues[nPos][i] > dMin - EPS_SMALL) { 
+            bModified = true ;         
             m_ZValues[nPos][i] = dMin ;
          }
       }
+
       else {
          // Se l'intervallo corrente è tutto contenuto nell'intervallo da aggungere modifico gli estremi    
          if ( m_ZValues[nPos][i] > dMin + EPS_SMALL) {
-      
+               bModified = true ;         
                m_ZValues[nPos][i] = dMin ;
                m_ZValues[nPos][i + 1] = dMax ;
          }
          // Se l'intervallo da aggiungere sconfina a destra modifico il massimo dell'intervallo corrente 
          else if ( m_ZValues[nPos][i + 1] > dMin - EPS_SMALL) {
-      
+            bModified = true ;         
             m_ZValues[nPos][i + 1] = dMax ;
          }
          else {
             // Aggiungo intervallo a destra dell'ultimo intervallo
             if ( i == m_ZValues[nPos].size() - 2) {
-            
+               bModified = true ;         
                m_ZValues[nPos].resize( m_ZValues[nPos].size() + 2) ;
                
                m_ZValues[nPos][i + 2] = dMin ;
@@ -788,6 +614,10 @@ VolZmap::AddIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMa
       i = i + 2 ;
    }
 
+  // se eseguita modifica, imposto ricalcolo della grafica
+   if ( bModified)
+      m_OGrMgr.Reset() ;
+
    return true ;    
 }
 
@@ -857,12 +687,12 @@ VolZmap::GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) con
 bool
 VolZmap::GetAllTriangles( TRIA3DLIST& lstTria) const
 {
-   const int DIM_CHUNK = 4 ;
-   for ( int i = 0 ; i < int( m_nNx) ; i += DIM_CHUNK) {
-      int nDimChunkX = min( DIM_CHUNK, int( m_nNx) - i) ;
-      for ( int j = 0 ; j < int( m_nNy) ; j += DIM_CHUNK) {
-         int nDimChunkY = min( DIM_CHUNK, int( m_nNy) - j) ;
-         GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, lstTria) ;
+   const int MAX_DIM_CHUNK = 128 ;
+   for ( int i = 0 ; i < int( m_nNx) ; i += MAX_DIM_CHUNK) {
+      int nDimChunkX = min( MAX_DIM_CHUNK, int( m_nNx) - i) ;
+      for ( int j = 0 ; j < int( m_nNy) ; j += MAX_DIM_CHUNK) {
+         int nDimChunkY = min( MAX_DIM_CHUNK, int( m_nNy) - j) ;
+         GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, MAX_DIM_CHUNK, lstTria) ;
       } 
    }
    return true ;
@@ -870,7 +700,7 @@ VolZmap::GetAllTriangles( TRIA3DLIST& lstTria) const
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST& lstTria) const
+VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk, TRIA3DLIST& lstTria) const
 {
   // determino se è un semplice parallelepipedo
    bool bIsSimple = true ;
@@ -896,6 +726,17 @@ VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST&
    if ( bIsSimple) {
       CalcChunkPrisms( nPos1, nPos2, nDim1, nDim2, lstTria) ;
    }
+  // se chunk di dimensioni accettabili
+   else if ( nDimChk >= 4) {
+      int nNewDimChk = nDimChk / 2 ;
+      for ( int i = nPos1 ; i < int( nPos1 + nDim1) ; i += nNewDimChk) {
+         int nDimChunkX = min( nNewDimChk, int( nPos1 + nDim1) - i) ;
+         for ( int j = nPos2 ; j < int( nPos2 + nDim2) ; j += nNewDimChk) {
+            int nDimChunkY = min( nNewDimChk, int( nPos2 + nDim2) - j) ;
+            GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, nNewDimChk, lstTria) ;
+         } 
+      }
+   }
   // altrimenti
    else {
      // elaboro ogni singolo dexel
@@ -1081,8 +922,8 @@ VolZmap::SetStdTool( const string& sToolName, double dH, double dR, double dCorn
       m_dHeight = dH ;
       m_dRadius = dR ;
       m_dTipHeight = dCornR ;
-      m_dTipRadius = m_dRadius ;
-      m_dRCorner = dR - dCornR ;
+      m_dTipRadius = dR - dCornR  ;
+      m_dRCorner = dCornR ;
      // come profilo
       m_nToolType = GenericTool ;
       Point3d pt0( 0, 0, 0) ;
@@ -1097,6 +938,7 @@ VolZmap::SetStdTool( const string& sToolName, double dH, double dR, double dCorn
       m_ToolOutline.AddLine( pt2);
       m_ToolOutline.AddArcTg( pt3) ;
       m_ToolOutline.AddLine( pt4) ;
+      return SetGenTool( sToolName, &m_ToolOutline) ;
    }
   // utensile sferico
    else if ( dCornR < dR + EPS_SMALL) {
@@ -9159,7 +9001,7 @@ VolZmap::MillConusAux( const Point3d& ptI, const Point3d& ptF, const Vector3d& v
 // Traslazioni
 //----------------------------------------------------------------------------
 bool
-VolZmap::Ball( const Point3d& ptLs, const Point3d& ptLe, const double& dRad)
+VolZmap::Ball( const Point3d& ptLs, const Point3d& ptLe, double dRad)
 {
    double dMin, dMax ;
    unsigned int nStartI, nStartJ, nEndI, nEndJ ;
diff --git a/VolZmap.h b/VolZmap.h
index 6115a9e..8f5c720 100644
--- a/VolZmap.h
+++ b/VolZmap.h
@@ -73,15 +73,10 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool Deepness( const Point3d& ptP, const Vector3d& vtDir, double& dInLength, double& dOutLength) override ;
       bool BBoxZmapIntersection( const Frame3d& frBBox, const Point3d& ptMax) override ;
 
-      bool CreateTriMap( const Point3d& ptO, double dPrec, double dLengthX, double dLengthY, double dLengthZ) ;
       bool SubtractIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMax) ;
-      bool SubtractIntervals2( unsigned int nI, unsigned int nJ, double dMin, double dMax) ;
-      bool SubtractIntervals3( unsigned int nI, unsigned int nJ, double dMin, double dMax) ;
       bool SubtractIntervals( const Point3d& ptP, double dMin, double dMax) ;
       bool AddIntervals( unsigned int nI, unsigned int nJ, double dMin, double dMax) ;
       bool AddIntervals( const Point3d& ptP, double dMin, double dMax) ;
-      bool TriMillingStep( const Point3d& ptPs, const Point3d& ptPe, Vector3d& vtDs, Vector3d& vtDe) ;
-      bool Deepness( const Point3d& ptPGlob, const Vector3d& vtDir, const double& dRadius, double& dInLength, double& dOutLength) ;
 
    public :                      // IGeoObjRW
       virtual int GetNgeId( void) const ;
@@ -107,7 +102,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       
    private :
       bool CopyFrom( const VolZmap& clSrc) ;
-      bool GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST& lstTria) const ;
+      bool GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk, TRIA3DLIST& lstTria) const ;
       bool CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST& lstTria) const ;
       bool CalcDexelPrisms( int nPos1, int nPos2, TRIA3DLIST& lstTria) const ;
       bool AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Point3d& ptQ,
@@ -222,7 +217,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
                          double dHei, double dMaxRad, double dMinRad, double dCoef) ;
 
      // Traslazioni
-      bool Ball( const Point3d& ptLs, const Point3d& ptLe, const double& dRad) ;
+      bool Ball( const Point3d& ptLs, const Point3d& ptLe, double dRad) ;
 
     // Sottrazione per tridexel
       bool ZDrillingCB( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;