diff --git a/VolZmapGraphics.cpp b/VolZmapGraphics.cpp
index 9ae7cff..89a63d9 100644
--- a/VolZmapGraphics.cpp
+++ b/VolZmapGraphics.cpp
@@ -521,12 +521,15 @@ VolZmap::GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const
          vTria.reserve( 10000) ;
         // triangoli smooth
          for ( int nVx = 0 ; nVx < int( m_BlockSmoothTria[nBlock].size()) ; ++ nVx) {
-            for ( int nTr = 0 ; nTr < int( m_BlockSmoothTria[nBlock][nVx].vTria.size()) ; ++ nTr)
-               vTria.emplace_back( m_BlockSmoothTria[nBlock][nVx].vTria[nTr]) ;  
+            for ( int nTr = 0 ; nTr < int( m_BlockSmoothTria[nBlock][nVx].vTria.size()) ; ++ nTr) {
+               vTria.emplace_back( m_BlockSmoothTria[nBlock][nVx].vTria[nTr]) ;
+               vTria.back().ResetEdgeFlags() ;
+            }
          }
         // triangoli grandi piatti
          for ( int tBl = 0 ; tBl < int( m_BlockBigTria[nBlock].size()) ; ++ tBl) {
             vTria.emplace_back( m_BlockBigTria[nBlock][tBl]) ;  
+            vTria.back().ResetEdgeFlags() ;
          }
         // triangoli di feature nel blocco (ciclo sui voxel del blocco)
          for ( int t1 = 0 ;  t1 < int( m_BlockSharpTria[nBlock].size()) ; ++ t1) {
@@ -536,6 +539,7 @@ VolZmap::GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const
                for ( int t3 = 0 ; t3 < int( m_BlockSharpTria[nBlock][t1].vCompoTria[t2].size()) ; ++ t3) {
                  // aggiungo triangolo alla lista
                   vTria.emplace_back( m_BlockSharpTria[nBlock][t1].vCompoTria[t2][t3]) ;
+                  vTria.back().ResetEdgeFlags() ;
                }
             }
          }
@@ -551,6 +555,7 @@ VolZmap::GetBlockTriangles( int nBlock, TRIA3DEXVECTOR& vTria) const
                      if ( m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3].GetArea() > SQ_EPS_SMALL) {
                        // aggiungo triangolo alla lista
                         vTria.emplace_back( m_InterBlockSharpTria[t][t1].vCompoTria[t2][t3]) ;
+                        vTria.back().ResetEdgeFlags() ;
                      }
                   }
                }
@@ -3314,41 +3319,77 @@ VolZmap::IsThereMat( int nI, int nJ, int nK) const
 
   // ciclo sulle griglie 
    int nCount = 0 ;
-   for ( int nGrid = 0 ; nGrid < int ( m_nMapNum) ; ++ nGrid) {
+   int nMinPos[3] = { -1, -1, -1} ;
+   int nMinIndex[3] ;
+   double dZ[3] ;
+   int nDexSize[3] ;
+   bool bInterOnNode[3] = { false, false, false} ;
+   for ( int nGrid = 0 ; nGrid < int( m_nMapNum) ; ++ nGrid) {
      // assegnazione dati vertice dipendenti dalla griglia
       int nGrI, nGrJ ;
-      double dZ ;
       switch ( nGrid) {
       case 0 :
          nGrI = nI ;
          nGrJ = nJ ; 
-         dZ = ( nK + 0.5) * m_dStep ;
+         dZ[nGrid] = ( nK + 0.5) * m_dStep ;
          break ;
       case 1 :
          nGrI = nJ ;
          nGrJ = nK ;
-         dZ = ( nI + 0.5) * m_dStep ;
+         dZ[nGrid] = ( nI + 0.5) * m_dStep ;
          break ;
       case 2 :
          nGrI = nK ;
          nGrJ = nI ;
-         dZ = ( nJ + 0.5) * m_dStep ;
+         dZ[nGrid] = ( nJ + 0.5) * m_dStep ;
          break ;
       }
      // verifica spillone su vertice
+      double dMinDist = INFINITO ;
       int nIndex = 0 ;   
       int nPos = nGrJ * m_nNx[nGrid] + nGrI ;
-      int nDexSize = int( m_Values[nGrid][nPos].size()) ;
-      while ( nIndex < nDexSize) {
-         if ( dZ > m_Values[nGrid][nPos][nIndex].dMin - 2 * EPS_SMALL  &&
-              dZ < m_Values[nGrid][nPos][nIndex].dMax + 2 * EPS_SMALL) {
+      nDexSize[nGrid] = int( m_Values[nGrid][nPos].size()) ;
+      while ( nIndex < nDexSize[nGrid]) {
+         double dDistInf = dZ[nGrid] - m_Values[nGrid][nPos][nIndex].dMin + 2 * EPS_SMALL ;
+         double dDistSup = dZ[nGrid] - m_Values[nGrid][nPos][nIndex].dMax - 2 * EPS_SMALL ;
+         if ( dDistInf > 0.  &&  dDistSup < 0.) {
+            nMinIndex[nGrid] = nIndex ;
             ++ nCount ;
+            bInterOnNode[nGrid] = true ;
             break ;
+         }
+         else {
+            double dDist = min( abs( dDistInf), abs( dDistSup)) ;
+            if ( dDist < dMinDist) {
+               nMinPos[nGrid] = nPos ;
+               nMinIndex[nGrid] = nIndex ;
+               dMinDist = dDist ;
+            }
          } 
          nIndex += 1 ;
       }
    }
-   return ( nCount == 3) ;
+   if ( nCount == 3)
+      return true ;
+   else if ( nCount == 2) {
+      int nGrid = ( bInterOnNode[0] ? ( bInterOnNode[1] ? 2 : 1) : 0) ;
+      if ( nDexSize[nGrid] == 0)
+         return false ;
+      if ( dZ[nGrid] > m_Values[nGrid][nMinPos[nGrid]][nMinIndex[nGrid]].dMin - 0.1 * m_dStep  &&
+           dZ[nGrid] < m_Values[nGrid][nMinPos[nGrid]][nMinIndex[nGrid]].dMax + 0.1 * m_dStep) {
+         double dDistInf = abs( dZ[nGrid] - m_Values[nGrid][nMinPos[nGrid]][nMinIndex[nGrid]].dMin) ;
+         double dDistSup = abs( dZ[nGrid] - m_Values[nGrid][nMinPos[nGrid]][nMinIndex[nGrid]].dMax) ;
+         if ( dDistInf < dDistSup)
+            const_cast<double&>( m_Values[nGrid][nMinPos[nGrid]][nMinIndex[nGrid]].dMin) = dZ[nGrid] ;
+         else
+            const_cast<double&>( m_Values[nGrid][nMinPos[nGrid]][nMinIndex[nGrid]].dMax) = dZ[nGrid] ;
+         return true ;
+      }
+      else
+         return false ;        
+   }
+   else
+      return false ;
 }
 
 //----------------------------------------------------------------------------