diff --git a/EgtGeomKernel.rc b/EgtGeomKernel.rc
index a40bb85..00a56a0 100644
Binary files a/EgtGeomKernel.rc and b/EgtGeomKernel.rc differ
diff --git a/GdbExecutor.cpp b/GdbExecutor.cpp
index 2c496aa..9778de7 100644
--- a/GdbExecutor.cpp
+++ b/GdbExecutor.cpp
@@ -95,7 +95,7 @@ GdbExecutor::GdbExecutor( void)
    m_ExecMgr.Insert( "CURVECOMPO", &GdbExecutor::ExecuteCurveCompo) ;
    m_ExecMgr.Insert( "STM", &GdbExecutor::ExecuteSurfTriMesh) ;
    m_ExecMgr.Insert( "SURFTRIMESH", &GdbExecutor::ExecuteSurfTriMesh) ;
-   m_ExecMgr.Insert( "VOLZMAP", &GdbExecutor::ExecuteVolZmap) ;
+  // m_ExecMgr.Insert( "VOLZMAP", &GdbExecutor::ExecuteVolZmap) ;
    m_ExecMgr.Insert( "TEXT", &GdbExecutor::ExecuteText) ;
    m_ExecMgr.Insert( "LEV", &GdbExecutor::ExecuteLevel) ;
    m_ExecMgr.Insert( "LEVEL", &GdbExecutor::ExecuteLevel) ;
@@ -2566,7 +2566,7 @@ GdbExecutor::SurfTriMeshDoSewing( const STRVECTOR& vsParams)
    }
    return true ;
 }
-
+ /*
 //----------------------------------------------------------------------------
 bool
 GdbExecutor::ExecuteVolZmap(const string& sCmd2, const STRVECTOR& vsParams)
@@ -2649,7 +2649,7 @@ GdbExecutor::VolZmapCreate( const STRVECTOR& vsParams)
   // inserisco  nel DB
    return AddGeoObj(vsParams[0], vsParams[1], Release( pZprova)) ;
 }
-
+ 
 //----------------------------------------------------------------------------
 bool 
 GdbExecutor::VolZmapCreateFromFlatRegion( const STRVECTOR& vsParams)
@@ -2770,7 +2770,7 @@ GdbExecutor::VolZmapMilling( const STRVECTOR& vsParams)
       return pZmap->MillingStep( ptPs, vtDs, ptPe, vtDe) ;
    //else
     //  return pZmap->MillingStep( ptPs, vtDs, ptPe, vtDe) ;
-}
+} 
 
 //----------------------------------------------------------------------------
 bool 
@@ -2910,7 +2910,7 @@ GdbExecutor::VolZmapBBoxZmapIntersection( const STRVECTOR& vsParams)
    bInt = ! pZmap->AvoidBox( frBBoxFrame, ptEnd - ORIG) ; 
 
    return true ;
-}
+}*/
 
 //----------------------------------------------------------------------------
 bool
diff --git a/MC_Tables.h b/MC_Tables.h
index 0869577..9b63a80 100644
--- a/MC_Tables.h
+++ b/MC_Tables.h
@@ -36,7 +36,810 @@ static int EdgeTable[256] = {
     0x70c, 0x605, 0x50f, 0x406, 0x30a, 0x203, 0x109, 0x0
 } ;
 
-// Tabella triangoli
+//----------------------------------------------------------------------------
+// Tabella triangoli Enhanced MC
+static int TriangleTableEn[256][2][17] = {
+
+   {{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 3, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 3, 0,  1, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 8, 3, 9, 8, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 1, 9, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 8, 3, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 0, 8,  3,  1,  2, 10, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 2, 10, 0, 2, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 2, 10, 9, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 8, 3, 2, 10, 8, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 10,  9, 8,  3, 2 , -1,-1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1,  3, 3, 11,  2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 11, 2, 8, 11, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1,  4, 0, 8, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 10 -----------------------------------------------------------
+   {{1, 9, 0, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 1, 9, 0, 2, 3,11, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 11, 2, 1, 9, 11, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 9, 8, 11, 2, 1,-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 10, 1, 11, 10, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 3, 11,10, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 10, 1, 0, 8, 10, 8, 11, 10, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 8, 11, 10, 1, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 9, 0, 3, 11, 9, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 11, 10, 9, 0, 3, -1,-1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 8, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 3, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{4, 3, 0, 7, 3, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 4, 7, 3, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 1, 9, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 0, 1, 9,  8,  4, 7, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{4, 1, 9, 4, 7, 1, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 7, 3, 1, 9, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 20 -----------------------------------------------------------
+   {{1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 1, 2, 10, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 4, 7, 3, 0, 4, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 3, 0, 4, 7, 1, 2, 10, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 2, 10, 9, 0, 2, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 2, 10, 9, 0, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 10, 9, 2, 9, 7, 2, 7, 3, 7, 9, 4, -1, -1, -1, -1, -1},
+    {1, 6, 7, 3, 2, 10, 9, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 8, 4, 7, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{11, 4, 7, 11, 2, 4, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 2, 0, 4, 7, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 3, 3, 3, 9, 0, 1, 8, 4, 7, 2, 3, 11, -1, -1, -1, -1}},
+
+   {{4, 7, 11, 9, 4, 11, 9, 11, 2, 9, 2, 1, -1, -1, -1, -1, -1},
+    {2, 4, 4, 2, 1, 9, 11, 11,9,4,7, -1, -1, -1, -1, -1 ,-1}},
+
+   {{3, 10, 1, 3, 11, 10, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 3, 11, 10, 1, 7, 8, 4, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 11, 10, 1, 4, 11, 1, 0, 4, 7, 11, 4, -1, -1, -1, -1, -1},
+    {1, 6, 1, 0, 4, 7, 11, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 30 ----------------------------------------------------------
+   {{4, 7, 8, 9, 0, 11, 9, 11, 10, 11, 0, 3, -1, -1, -1, -1, -1},
+    {2, 3, 5, 4, 7,  8, 0,  3, 11, 10, 9, -1, -1, -1, -1, -1, -1}},
+
+   {{4, 7, 11, 4, 11, 9, 9, 11, 10, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 4, 7, 11, 10, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 3, 9,  5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 5, 4, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 9, 5, 4,  0,  8,  3, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 5, 4, 1, 5, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 0, 1, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 5, 4, 8, 3, 5, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 3, 1, 5, 4, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 1, 2, 10, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 3, 3, 3, 3, 0, 8, 1, 2, 10, 4, 9, 5, -1, -1, -1, -1}},
+
+   {{5, 2, 10, 5, 4, 2, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 4, 0, 2, 10, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 10, 5, 3, 2, 5, 3, 5, 4, 3, 4, 8, -1, -1, -1, -1, -1},
+    {2, 4, 4, 2, 10, 5, 3, 4, 8, 3, 5, -1, -1, -1, -1, -1, -1}},
+
+   // 40 ------------------------------------------------------------
+   {{9, 5, 4, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 9, 5,  4,  2,  3, 11, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 11, 2, 0, 8, 11, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 0, 8, 11, 2, 4, 9, 5, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 5, 4, 0, 1, 5, 2, 3, 11, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 0, 1, 5, 4, 2,  3, 11, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 1, 5, 2, 5, 8, 2, 8, 11, 4, 8, 5, -1, -1, -1, -1, -1},
+    {1, 6, 2, 1, 5, 4, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 3, 11, 10, 1, 3, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 3, 11, 10, 1, 9, 5, 4, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1, -1},
+    {2, 3, 5, 4, 9, 5, 1, 0, 8, 11, 10, -1, -1, -1, -1, -1, -1}},
+
+   {{5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1, -1},
+    {1, 6, 5, 4, 0, 3, 11, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 5, 4, 8, 11, 10,-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 7, 8, 9, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 5, 7, 3, 0, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 50 ----------------------------------------------------------
+   {{0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 1, 5, 7, 8, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 3, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 7, 8, 9, 5, 7, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 7, 8, 9, 5, 10, 1, 2, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 1, 2, 9, 5, 0, 5, 3, 0, 5, 7, 3, -1, -1, -1, -1, -1},
+    {2, 3, 5, 10, 1, 2, 0, 9, 5, 7, 3, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 0, 2, 8, 2, 5, 8, 5, 7, 10, 5, 2, -1, -1, -1, -1, -1},
+    {1, 6, 2, 10, 5, 7, 8, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 10, 5, 2, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 2, 10, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 9, 5, 7, 8, 9, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 7, 8, 9, 5, 3, 11, 2, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 5, 7, 9, 7, 2, 9, 2, 0, 2, 7, 11, -1, -1, -1, -1, -1},
+    {1, 6, 2, 0, 9, 5, 7, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 3, 11, 0, 1, 8, 1, 7, 8, 1, 5, 7, -1, -1, -1, -1, -1},
+    {2, 3, 5, 2, 3, 11, 8, 0, 1, 5, 7, -1, -1, -1, -1, -1, -1}},
+
+   {{11, 2, 1, 11, 1, 7, 7, 1, 5, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 11, 2, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 60 --------------------------------------------------------
+   {{9, 5, 8, 8, 5, 7, 10, 1, 3, 10, 3, 11, -1, -1, -1, -1, -1},
+    {2, 4, 4, 3, 11, 10, 1, 5, 7, 8, 9, -1, -1, -1, -1, -1, -1}},
+
+   {{5, 7, 0, 5, 0, 9, 7, 11, 0, 1, 0, 10, 11, 10, 0, -1, -1},
+    {1, 7, 5, 7, 11, 10, 1, 0, 9, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{11, 10, 0, 11, 0, 3, 10, 5, 0, 8, 0, 7, 5, 7, 0, -1, -1},
+    {1, 7, 11, 10, 5, 7, 8, 0, 3, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{11, 10, 5, 7, 11, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 5, 7, 11, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+   
+   {{10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 3, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 0,  8, 3,  5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 0, 1, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 9,  0, 1,  5, 10,  6, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 8, 3, 1, 9, 8, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 1, 9, 8, 3, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 6, 5, 2, 6, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 1, 2, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 6, 5, 1, 2, 6, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 1, 2, 6, 5, 3, 0, 8, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 70 ----------------------------------------------------------
+   {{9, 6, 5, 9, 0, 6, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 0, 2, 6, 5, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{5, 9, 8, 5, 8, 2, 5, 2, 6, 3, 2, 8, -1, -1, -1, -1, -1},
+    {1, 6, 2, 6, 5, 9, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 2, 3, 11, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{11, 0, 8, 11, 2, 0, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 0, 8, 11, 2, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 3, 3, 3, 0, 1, 9, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1}},
+ 
+   {{5, 10, 6, 1, 9, 2, 9, 11, 2, 9, 8, 11, -1, -1, -1, -1, -1},
+    {2, 3, 5, 5, 10, 6, 2, 1, 9, 8, 11, -1, -1, -1, -1, -1, -1}},
+
+   {{6, 3, 11, 6, 5, 3, 5, 1, 3, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 5, 1, 3, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 8, 11, 0, 11, 5, 0, 5, 1, 5, 11, 6, -1, -1, -1, -1, -1},
+    {1, 6,  5, 1,  0, 8,11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 11, 6, 0, 3, 6, 0, 6, 5, 0, 5, 9, -1, -1, -1, -1, -1},
+    {2, 4, 4, 3, 11, 6, 0, 5, 9, 0, 6, -1, -1, -1, -1}},
+
+   {{6, 5, 9, 6, 9, 11, 11, 9, 8, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 6, 5, 9, 8, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+ 
+   // 80 -----------------------------------------------------------
+   {{5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 5, 10, 6, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{4, 3, 0, 4, 7, 3, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 4, 7, 3, 0, 6, 5, 10, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 3, 3, 3, 1, 9, 0, 5, 10, 6, 8, 4, 7, -1, -1, -1, -1}},
+
+   {{10, 6, 5, 1, 9, 7, 1, 7, 3, 7, 9, 4, -1, -1, -1, -1, -1},
+    { 2, 3, 5,10, 6, 5, 9, 4, 7, 3, 1,-1, -1, -1, -1, -1, -1}},
+
+   {{6, 1, 2, 6, 5, 1, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 1, 2, 6, 5, 4, 7, 8, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 2, 5, 5, 2, 6, 3, 0, 4, 3, 4, 7, -1, -1, -1, -1, -1},
+    {2, 4, 4, 2, 6, 5, 1, 3, 0, 4, 7, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 4, 7, 9, 0, 5, 0, 6, 5, 0, 2, 6, -1, -1, -1, -1, -1},
+    {2, 3, 5, 8, 4, 7, 5, 9, 0, 2, 6, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 3, 9, 7, 9, 4, 3, 2, 9, 5, 9, 6, 2, 6, 9, -1, -1},
+    {1, 7, 7, 3, 2, 6, 5, 9, 4,-1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 3, 3, 3, 3, 11, 2, 7, 8, 4, 10, 6, 5, -1, -1, -1, -1}},
+
+   {{5, 10, 6, 4, 7, 2, 4, 2, 0, 2, 7, 11, -1, -1, -1, -1, -1},
+    {2, 3, 5, 5, 10, 6, 7, 11, 2, 0, 4, -1, -1, -1, -1, -1, -1}},
+
+   // 90 ------------------------------------------------------
+   {{0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6, -1, -1, -1, -1, -1},
+    {4, 3, 3, 3, 3, 0, 1, 9, 4, 7, 8, 2, 3, 11, 5, 10, 6}},
+
+   {{9, 2, 1, 9, 11, 2, 9, 4, 11, 7, 11, 4, 5, 10, 6, -1, -1},
+    {3, 4, 4, 3, 2, 1, 9, 11, 4, 7, 11, 9, 5, 10, 6, -1, -1}},
+
+   {{8, 4, 7, 3, 11, 5, 3, 5, 1, 5, 11, 6, -1, -1, -1, -1, -1},
+    {2, 3, 5, 8, 4, 7, 11, 6, 5, 1, 3, -1, -1, -1, -1, -1, -1}},
+
+   {{5, 1, 11, 5, 11, 6, 1, 0, 11, 7, 11, 4, 0, 4, 11, -1, -1},
+    {1, 7, 5, 1, 0, 4, 7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 5, 9, 0, 6, 5, 0, 3, 6, 11, 6, 3, 8, 4, 7, -1, -1},
+    {3, 4, 4, 3, 0, 6, 5, 9, 3, 11, 6, 0, 8, 4, 7, -1, -1}},
+
+   {{6, 5, 9, 6, 9, 11, 4, 7, 9, 7, 11, 9, -1, -1, -1, -1, -1},
+    {2, 4, 4, 9, 4, 7, 11, 6, 5, 9, 11,-1, -1, -1, -1, -1, -1}},
+
+   {{10, 4, 9, 6, 4, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 4, 9, 10, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{4, 10, 6, 4, 9, 10, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 4, 9, 10, 6, 0, 8, 3, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 0,  1, 10, 6, 0, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 6, 4, 0, 1, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 3, 1, 8, 1, 6, 8, 6, 4, 6, 1, 10, -1, -1, -1, -1, -1},
+    {1, 6, 1, 10, 6, 4, 8, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 100 ---------------------------------------------------------
+   {{1, 4, 9, 1, 2, 4, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 2, 6, 4, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 0, 8, 1, 2, 9, 2, 4, 9, 2, 6, 4, -1, -1, -1, -1, -1},
+    {2, 3, 5, 3, 0, 8, 9, 1, 2, 6, 4, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 2, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 3, 2, 8, 2, 4, 4, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 8, 3, 2, 6, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 4, 9, 10, 6, 4, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 10, 6, 4, 9, 11, 2, 3, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 8, 2, 2, 8, 11, 4, 9, 10, 4, 10, 6, -1, -1, -1, -1, -1},
+    {2, 4, 4, 2, 11, 8, 0, 10, 6, 4, 9, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 11, 2, 0, 1, 6, 0, 6, 4, 6, 1, 10, -1, -1, -1, -1, -1},
+    {2, 3, 5, 3, 11, 2, 1, 10, 6, 4, 0, -1, -1, -1, -1, -1, -1}},
+
+   {{6, 4, 1, 6, 1, 10, 4, 8, 1, 2, 1, 11, 8, 11, 1, -1, -1},
+    {1, 7, 6, 4, 8, 11, 2, 1, 10, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 6, 4, 9, 3, 6, 9, 1, 3, 11, 6, 3, -1, -1, -1, -1, -1},
+    {1, 6, 3, 11, 6, 4, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 11, 1, 8, 1, 0, 11, 6, 1, 9, 1, 4, 6, 4, 1, -1, -1},
+    {1, 7, 8, 11, 6, 4, 9, 1, 0, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 110 ----------------------------------------------------------
+   {{3, 11, 6, 3, 6, 0, 0, 6, 4, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 3, 11, 6, 4, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{6, 4, 8, 11, 6, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 8, 11, 6, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 10, 6, 7, 8, 10, 8, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 8, 9, 10, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 7, 3, 0, 10, 7, 0, 9, 10, 6, 7, 10, -1, -1, -1, -1, -1},
+    {1, 6, 0, 9, 10, 6, 7, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 6, 7, 1, 10, 7, 1, 7, 8, 1, 8, 0, -1, -1, -1, -1, -1},
+    {2, 4, 4, 8, 0, 1, 7, 10, 6, 7, 1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 6, 7, 10, 7, 1, 1, 7, 3, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 10, 6, 7, 3, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 2, 6, 1, 6, 8, 1, 8, 9, 8, 6, 7, -1, -1, -1, -1, -1},
+    {1, 6, 1, 2, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 6, 9, 2, 9, 1, 6, 7, 9, 0, 9, 3, 7, 3, 9, -1, -1},
+    {1, 7, 2, 6, 7, 3, 0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 8, 0, 7, 0, 6, 6, 0, 2, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 7, 8, 0, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 3, 2, 6, 7, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 7, 3, 2, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 120 -------------------------------------------------------
+   {{2, 3, 11, 10, 6, 8, 10, 8, 9, 8, 6, 7, -1, -1, -1, -1, -1},
+    {2, 3, 5, 2, 3, 11, 6, 7, 8, 9, 10, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 0, 7, 2, 7, 11, 0, 9, 7, 6, 7, 10, 9, 10, 7, -1, -1},
+    {1, 7, 2, 0, 9, 10, 6, 7, 11, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 8, 0, 1, 7, 8, 1, 10, 7, 6, 7, 10, 2, 3, 11, -1, -1},
+    {3, 4, 4, 3, 8, 0, 1, 7, 10, 6, 7, 1, 11, 2, 3, -1, -1}},
+
+   {{11, 2, 1, 11, 1, 7, 10, 6, 1, 6, 7, 1, -1, -1, -1, -1, -1},
+    {2, 4, 4, 11, 2, 1, 7, 1, 10, 6, 7, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 9, 6, 8, 6, 7, 9, 1, 6, 11, 6, 3, 1, 3, 6, -1, -1},
+    {1, 7, 8, 9, 1, 3, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 0, 9, 1, 11, 6, 7, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 8, 0, 7, 0, 6, 3, 11, 0, 11, 6, 0, -1, -1, -1, -1, -1},
+    {2, 4, 4, 0, 3, 11, 6, 7,  8, 0, 6, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 3, 7, 11, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 3, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 3, 0, 8, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 130 ----------------------------------------------------------
+   {{0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 0, 1, 9, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 1, 9, 8, 3, 1, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 1, 9, 8, 3, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 10, 1, 2, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 3, 3, 3, 1, 2, 10, 3, 0, 8, 6, 11, 7, -1, -1, -1, -1}},
+
+   {{2, 9, 0, 2, 10, 9, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 2, 10, 9, 0, 6, 11, 7, -1, -1, -1, -1, -1, -1, -1}},
+ 
+   {{6, 11, 7, 2, 10, 3, 10, 8, 3, 10, 9, 8, -1, -1, -1, -1, -1},
+    {2, 3, 5, 6, 11, 7, 3, 2, 10, 9, 8, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 2, 3, 6, 2, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 2, 3, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 0, 8, 7, 6, 0, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 6, 2, 0, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 7, 6, 2, 3, 7, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 2, 3, 7, 6, 0, 1, 9, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 6, 2, 1, 8, 6, 1, 9, 8, 8, 7, 6, -1, -1, -1, -1, -1},
+    {1, 6, 6, 2, 1, 9, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 140 ----------------------------------------------------------
+   {{10, 7, 6, 10, 1, 7, 1, 3, 7, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 1, 3, 7, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 7, 6, 1, 7, 10, 1, 8, 7, 1, 0, 8, -1, -1, -1, -1, -1},
+    {2, 4, 4, 10, 1, 7, 6,  8, 7, 1, 0, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 3, 7, 0, 7, 10, 0, 10, 9, 6, 10, 7, -1, -1, -1, -1, -1},
+    {1, 6, 10, 9, 0, 3, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 6, 10, 7, 10, 8, 8, 10, 9, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 7, 6, 10, 9, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{6, 8, 4, 11, 8, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 6, 11, 8, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 6, 11, 3, 0, 6, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 0, 4, 6, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 6, 11, 8, 4, 6, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 6, 11, 8, 4, 9, 0, 1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 4, 6, 9, 6, 3, 9, 3, 1, 11, 3, 6, -1, -1, -1, -1, -1},
+    {1, 6, 6, 11, 3, 1, 9, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{6, 8, 4, 6, 11, 8, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 6, 11, 8, 4, 2, 10, 1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 2, 10, 3, 0, 11, 0, 6, 11, 0, 4, 6, -1, -1, -1, -1, -1},
+    {2, 3, 5, 1, 2, 10, 11, 3, 0, 4, 6, -1, -1, -1, -1, -1, -1}},
+    
+   // 150 -------------------------------------------------------
+   {{4, 11, 8, 4, 6, 11, 0, 2, 9, 2, 10, 9, -1, -1, -1, -1, -1},
+    {2, 4, 4, 4, 6, 11, 8, 2, 10, 9, 0, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 9, 3, 10, 3, 2, 9, 4, 3, 11, 3, 6, 4, 6, 3, -1, -1},
+    {1, 7, 10, 9, 4, 6, 11, 3, 2, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 2, 3, 8, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 4, 6, 2, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 4, 2, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 4, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 9, 0, 2, 3, 4, 2, 4, 6, 4, 3, 8, -1, -1, -1, -1, -1},
+    {2, 3, 5, 1, 9, 0, 3, 8, 4, 6, 2, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 9, 4, 1, 4, 2, 2, 4, 6, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 1, 9, 4, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 1, 3, 8, 6, 1, 8, 4, 6, 6, 10, 1, -1, -1, -1, -1, -1},
+    {1, 6, 1, 3, 8, 4, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 1, 0, 10, 0, 6, 6, 0, 4, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 10, 1, 0, 4, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{4, 6, 3, 4, 3, 8, 6, 10, 3, 0, 3, 9, 10, 9, 3, -1, -1},
+    {1, 7, 4, 6, 10, 9, 0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 9, 4, 6, 10, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 4, 6, 10, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 160 ----------------------------------------------------------
+   {{4, 9, 5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 4, 9,  5, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 3, 3, 3, 0, 8, 3, 4, 9, 5, 11, 7, 6, -1, -1, -1, -1}},
+
+   {{5, 0, 1, 5, 4, 0, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 0, 1, 5, 4, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{11, 7, 6, 8, 3, 4, 3, 5, 4, 3, 1, 5, -1, -1, -1, -1, -1},
+    {2, 3, 5, 11, 7, 6, 4, 8, 3, 1, 5, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1, -1, -1, -1, -1},
+    {3, 3, 3, 3, 9, 5, 4, 10, 1, 2, 7, 6, 11, -1, -1, -1, -1}},
+
+   {{6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5, -1, -1, -1, -1, -1},
+    {4, 3, 3, 3, 3, 6, 11, 7, 1, 2, 10, 0, 8, 3, 4, 9, 5}},
+
+   {{7, 6, 11, 5, 4, 10, 4, 2, 10, 4, 0, 2, -1, -1, -1, -1, -1},
+    {2, 3, 5, 7, 6, 11, 10, 5, 4, 0, 2,-1, -1, -1, -1, -1, -1}},
+
+   {{3, 4, 8, 3, 5, 4, 3, 2, 5, 10, 5, 2, 11, 7, 6, -1, -1},
+    {3, 4, 4, 3, 5, 3, 2, 10, 4, 8, 3, 5, 6, 11, 7, 6, -1}},
+
+   {{7, 2, 3, 7, 6, 2, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 2, 3, 7, 6, 5, 4, 9, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 5, 4, 0, 8, 6, 0, 6, 2, 6, 8, 7, -1, -1, -1, -1, -1},
+    {2, 3, 5, 9, 5, 4, 8, 7, 6, 2, 0, -1, -1, -1, -1, -1, -1}},
+  
+   // 170 -----------------------------------------------------
+   {{3, 6, 2, 3, 7, 6, 1, 5, 0, 5, 4, 0, -1, -1, -1, -1, -1},
+    {2, 4, 4, 3, 7, 6, 2, 0, 1, 5, 4, -1, -1, -1, -1, -1, -1}},
+
+   {{6, 2, 8, 6, 8, 7, 2, 1, 8, 4, 8, 5, 1, 5, 8, -1, -1},
+    {1, 7, 6, 2, 1, 5, 4, 8, 7,-1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 5, 4, 10, 1, 6, 1, 7, 6, 1, 3, 7, -1, -1, -1, -1, -1},
+    {2, 3, 5,  9, 5, 4, 6, 10, 1, 3, 7,-1, -1, -1, -1, -1, -1}},
+
+   {{1, 6, 10, 1, 7, 6, 1, 0, 7, 8, 7, 0, 9, 5, 4, -1, -1},
+    {3, 4, 4, 3, 0, 8, 7, 1, 6, 10, 1, 7, 9, 5, 4, -1, -1}},
+
+   {{4, 0, 10, 4, 10, 5, 0, 3, 10, 6, 10, 7, 3, 7, 10, -1, -1},
+    {1, 7, 4, 0, 3, 7, 6, 10, 5, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 6, 10, 7, 10, 8, 5, 4, 10, 4, 8, 10, -1, -1, -1, -1, -1},
+    {2, 4, 4, 4, 8, 10, 5, 7, 6, 10, 8, -1, -1, -1, -1, -1, -1}},
+
+   {{6, 9, 5, 6, 11, 9, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5,11, 8, 9, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 6, 11, 0, 6, 3, 0, 5, 6, 0, 9, 5, -1, -1, -1, -1, -1},
+    {2, 4, 4, 0, 9, 5, 6, 6, 11, 3, 0, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 11, 8, 0, 5, 11, 0, 1, 5, 5, 6, 11, -1, -1, -1, -1, -1},
+    {1, 6, 0, 1, 5, 6, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{6, 11, 3, 6, 3, 5, 5, 3, 1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 6, 11, 3, 1, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 180 -------------------------------------------------------
+   {{1, 2, 10, 9, 5, 11, 9, 11, 8, 11, 5, 6, -1, -1, -1, -1, -1},
+    {2, 3, 5, 1, 2, 10, 5, 6, 11, 8, 9, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 11, 3, 0, 6, 11, 0, 9, 6, 5, 6, 9, 1, 2, 10, -1, -1},
+    {3, 4, 4, 3, 11, 3, 0, 6, 9, 5, 6, 0, 2, 10, 1, 2, 10}},
+
+   {{11, 8, 5, 11, 5, 6, 8, 0, 5, 10, 5, 2, 0, 2, 5, -1, -1},
+    {1, 7,11, 8, 0, 2, 10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{6, 11, 3, 6, 3, 5, 2, 10, 3, 10, 5, 3, -1, -1, -1, -1, -1},
+    {2, 4, 4, 6, 11, 3, 5, 10, 5, 3, 2, -1, -1, -1, -1, -1, -1}},
+
+   {{5, 8, 9, 5, 2, 8, 5, 6, 2, 3, 8, 2, -1, -1, -1, -1, -1},
+    {1, 6, 2, 3, 8, 9, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 5, 6, 9, 6, 0, 0, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 9, 5, 6, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 5, 8, 1, 8, 0, 5, 6, 8, 3, 8, 2, 6, 2, 8, -1, -1},
+    {1, 7, 1, 5, 6, 2, 3, 8, 0, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 5, 6, 2, 1, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 1, 5, 6, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 3, 6, 1, 6, 10, 3, 8, 6, 5, 6, 9, 8, 9, 6, -1, -1},
+    {1, 7, 1, 3, 8, 9, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 1, 0, 10, 0, 6, 9, 5, 0, 5, 6, 0, -1, -1, -1, -1, -1},
+    {2, 4, 4, 5, 6, 0, 9, 10, 1, 0, 6, -1, -1, -1, -1, -1, -1}},
+
+   // 190 ----------------------------------------------------------
+   {{0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 0, 3, 8, 5, 6, 10, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 3, 10, 5, 6, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{11, 5, 10, 7, 5, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 5, 10, 11, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{11, 5, 10, 11, 7, 5, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 5, 10, 11, 7, 8, 3, 0, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{5, 11, 7, 5, 10, 11, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 4, 3, 5, 10, 11, 7, 1, 9, 0, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 7, 5, 10, 11, 7, 9, 8, 1, 8, 3, 1, -1, -1, -1, -1, -1},
+    {2, 4, 4, 10, 11, 7, 5, 1, 9, 8, 3, -1, -1, -1, -1, -1, -1}},
+
+   {{11, 1, 2, 11, 7, 1, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 7, 5, 1, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 8, 3, 1, 2, 7, 1, 7, 5, 7, 2, 11, -1, -1, -1, -1, -1},
+    {2, 3, 5, 0, 8, 3, 2, 11, 7, 5, 1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 7, 5, 9, 2, 7, 9, 0, 2, 2, 11, 7, -1, -1, -1, -1, -1},
+    {1, 6, 2, 11, 7, 5, 9, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{7, 5, 2, 7, 2, 11, 5, 9, 2, 3, 2, 8, 9, 8, 2, -1, -1},
+    {1, 7, 7, 5, 9, 8, 3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 200 ----------------------------------------------------------
+   {{2, 5, 10, 2, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 3, 7, 5, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{8, 2, 0, 8, 5, 2, 8, 7, 5, 10, 2, 5, -1, -1, -1, -1, -1},
+    {1, 6, 5, 10, 2, 0, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 0, 1, 5, 10, 3, 5, 3, 7, 3, 10, 2, -1, -1, -1, -1, -1},
+    {2, 3, 5, 9, 0, 1, 10, 2, 3, 7, 5, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 8, 2, 9, 2, 1, 8, 7, 2, 10, 2, 5, 7, 5, 2, -1, -1},
+    {1, 7, 9, 8, 7, 5, 10, 2, 1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{1, 3, 5, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 3, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 8, 7, 0, 7, 1, 1, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 0, 8, 7, 5, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 0, 3, 9, 3, 5, 5, 3, 7, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 9, 0, 3, 7, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 8, 7, 5, 9, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 4, 7, 5, 9, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+   
+   {{5, 8, 4, 5, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 10, 11, 8, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{5, 0, 4, 5, 11, 0, 5, 10, 11, 11, 3, 0, -1, -1, -1, -1, -1},
+    {1, 6, 0, 4, 5, 10, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   // 210 ------------------------------------------------------
+   {{0, 1, 9, 8, 4, 10, 8, 10, 11, 10, 4, 5, -1, -1, -1, -1, -1},
+    {2, 3, 5, 0, 1, 9, 4, 5, 10, 11, 8, -1, -1, -1, -1, -1, -1}},
+
+   {{10, 11, 4, 10, 4, 5, 11, 3, 4, 9, 4, 1, 3, 1, 4, -1, -1},
+    {1, 7, 10, 11, 3, 1, 9, 4, 5, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 5, 1, 2, 8, 5, 2, 11, 8, 4, 5, 8, -1, -1, -1, -1, -1},
+    {1, 6, 2, 11, 8, 4, 5, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 4, 11, 0, 11, 3, 4, 5, 11, 2, 11, 1, 5, 1, 11, -1, -1},
+    {1, 7, 0, 4, 5, 1, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{0, 2, 5, 0, 5, 9, 2, 11, 5, 4, 5, 8, 11, 8, 5, -1, -1},
+    {1, 7, 0, 2, 11, 8, 4, 5, 9, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {2, 3, 3, 9, 4, 5, 2, 11, 3, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{2, 5, 10, 3, 5, 2, 3, 4, 5, 3, 8, 4, -1, -1, -1, -1, -1},
+    {2, 4, 4, 2, 3, 5, 10, 4, 5, 3, 8, -1, -1, -1, -1, -1, -1}},
+
+   {{5, 10, 2, 5, 2, 4, 4, 2, 0, -1, -1, -1, -1, -1, -1, -1, -1},
+    {1, 5, 5, 10, 2, 0, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+   {{3, 10, 2, 3, 5, 10, 3, 8, 5, 4, 5, 8, 0, 1, 9, -1, -1},
+    {3, 4, 4, 3, 3, 5, 10, 2, 8, 4, 5, 3, 0, 1, 9, -1, -1}},
+
+   {{5, 10, 2, 5, 2, 4, 1, 9, 2, 9, 4, 2, -1, -1, -1, -1, -1},
+    {1, 6, 10, 2, 1, 9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ /* 220 */
+ {{8, 4, 5, 8, 5, 3, 3, 5, 1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 5, 8, 4, 5, 1, 3,-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{0, 4, 5, 1, 0, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 4, 0, 4, 5, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{8, 4, 5, 8, 5, 3, 9, 0, 5, 0, 3, 5, -1, -1, -1, -1, -1},
+  {2, 4, 4, 0, 3, 5, 9, 8, 4, 5, 3, -1, -1, -1, -1, -1, -1}},
+
+ {{9, 4, 5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 3, 9,  4,  5, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{4, 11, 7, 4, 9, 11, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1,  5, 9,10, 11, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ /* 225 */
+ {{0, 8, 3, 4, 9, 7, 9, 11, 7, 9, 10, 11, -1, -1, -1, -1, -1},
+  {2, 3, 5, 0, 8, 3, 7, 4, 9, 10, 11, -1, -1, -1, -1, -1, -1}},
+
+ {{1, 10, 11, 1, 11, 4, 1, 4, 0, 7, 4, 11, -1, -1, -1, -1, -1},
+  {1,  6,  1, 10,11, 7, 4, 0, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{3, 1, 4, 3, 4, 8, 1, 10, 4, 7, 4, 11, 10, 11, 4, -1, -1},
+  {1, 7, 3, 1,10,11, 7,  4, 8, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{4, 11, 7, 9, 11, 4, 9, 2, 11, 9, 1, 2, -1, -1, -1, -1, -1},
+  {2,  4, 4, 2, 11, 9, 1, 4, 9, 11, 7, -1, -1, -1, -1, -1, -1}},
+
+ {{9, 7, 4, 9, 11, 7, 9, 1, 11, 2, 11, 1, 0, 8, 3, -1, -1},
+  {3, 4, 4, 3, 1, 2, 11, 9, 7, 4,  9,11,  8, 3, 0, 8, 3}},
+
+ /* 230 */
+ {{11, 7, 4, 11, 4, 2, 2, 4, 0, -1, -1, -1, -1, -1, -1, -1, -1},
+  { 1, 5, 11, 7, 4, 0, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{11, 7, 4, 11, 4, 2, 8, 3, 4, 3, 2, 4, -1, -1, -1, -1, -1},
+  { 2, 4, 4, 11, 7, 4, 2, 3, 2, 4, 8,-1, -1, -1, -1, -1, -1}},
+
+ {{2, 9, 10, 2, 7, 9, 2, 3, 7, 7, 4, 9, -1, -1, -1, -1, -1},
+  {1, 6,  2, 3, 7, 4, 9,10, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{9, 10, 7, 9, 7, 4, 10, 2, 7, 8, 7, 0, 2, 0, 7, -1, -1},
+  {1,  7, 9,10, 2, 0, 8, 7, 4,-1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{3, 7, 10, 3, 10, 2, 7, 4, 10, 1, 10, 0, 4, 0, 10, -1, -1},
+  {1, 7,  3, 7, 4, 0, 1,10, 2, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ /* 235 */
+ {{1, 10, 2, 8, 7, 4, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {2,  3, 3, 1,10, 2,  8,  7,  4, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{4, 9, 1, 4, 1, 7, 7, 1, 3, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 5, 4, 9, 1, 3, 7,-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{4, 9, 1, 4, 1, 7, 0, 8, 1, 8, 7, 1, -1, -1, -1, -1, -1},
+  {2, 4, 4, 8, 7, 1, 0, 4, 9, 1, 7, -1, -1, -1, -1, -1, -1}},
+
+ {{4, 0, 3, 7, 4, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 4, 3, 7, 4, 0,-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{4, 8, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 3, 4,  8,  7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ /* 240 */
+ {{9, 10, 8, 10, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1,  4, 8,  9, 10,11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{3, 0, 9, 3, 9, 11, 11, 9, 10, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 5, 3, 0, 9, 10, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{0, 1, 10, 0, 10, 8, 8, 10, 11, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 5,  0, 1, 10,11, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{3, 1, 10, 11, 3, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 4,  3,  1,10, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{1, 2, 11, 1, 11, 9, 9, 11, 8, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 5,  1, 2, 11, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ /* 245 */
+ {{3, 0, 9, 3, 9, 11, 1, 2, 9, 2, 11, 9, -1, -1, -1, -1, -1},
+  {2, 4, 4, 2,11,  9, 1, 3, 0, 9, 11, -1, -1, -1, -1, -1,-1}},
+
+ {{0, 2, 11, 8, 0, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 4,  0, 2,11,  8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{3, 2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 3,  3,  2, 11, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{2, 3, 8, 2, 8, 10, 10, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 5, 2, 3, 8,  9, 10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{9, 10, 2, 0, 9, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1,  4, 2, 0, 9,10, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ /* 250 */
+ {{2, 3, 8, 2, 8, 10, 0, 1, 8, 1, 10, 8, -1, -1, -1, -1, -1},
+  {2, 4, 4, 2, 3, 8, 10, 1, 10, 8, 0, -1, -1, -1, -1, -1, -1}},
+
+ {{1, 10, 2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1,  3, 1, 10,  2, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{1, 3, 8, 9, 1, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 4, 1, 3, 8, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 3, 0,  9,  1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  {1, 3, 0,  3,  8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}},
+
+ {{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+  { 0, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}
+} ;
+
+#if 0
+//----------------------------------------------------------------------------
+// Tabella triangoli MC
 static int TriangleTable[256][16] = {
 
     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
@@ -87,7 +890,7 @@ static int TriangleTable[256][16] = {
     {4, 9, 5, 0, 8, 1, 8, 10, 1, 8, 11, 10, -1, -1, -1, -1},
     {5, 4, 0, 5, 0, 11, 5, 11, 10, 11, 0, 3, -1, -1, -1, -1},
     {5, 4, 8, 5, 8, 10, 10, 8, 11, -1, -1, -1, -1, -1, -1, -1},
-    {9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
+    {9, 7, 8, 5, 7, 9, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},  
     {9, 3, 0, 9, 5, 3, 5, 7, 3, -1, -1, -1, -1, -1, -1, -1},
     {0, 7, 8, 0, 1, 7, 1, 5, 7, -1, -1, -1, -1, -1, -1, -1},
     {1, 5, 3, 3, 5, 7, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
@@ -295,4 +1098,5 @@ static int TriangleTable[256][16] = {
     {0, 9, 1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
     {0, 3, 8, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1},
     {-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1}
-} ;
\ No newline at end of file
+} ;
+#endif
\ No newline at end of file
diff --git a/VolTriZmapCalculus.cpp b/VolTriZmapCalculus.cpp
index 36d58ce..2389193 100644
--- a/VolTriZmapCalculus.cpp
+++ b/VolTriZmapCalculus.cpp
@@ -78,7 +78,7 @@ VolZmap::IntersLineZMapBBox( unsigned int nGrid, const Point3d& ptP, const Vecto
 {
   // Punti estremi del box dello Zmap
    Point3d ptMin = ORIG ;
-   Point3d ptMax = ptMin + Vector3d( m_nVNx[nGrid] * m_dStep, m_nVNy[nGrid] * m_dStep, m_dVMaxZ[nGrid]) ;
+   Point3d ptMax = ptMin + Vector3d( m_nNx[nGrid] * m_dStep, m_nNy[nGrid] * m_dStep, m_dMaxZ[nGrid]) ;
 
    return ( IntersLineBox( ptP, vtV, ptMin, ptMax, dU1, dU2)  &&  ( dU1 > 0  ||  dU2 > 0)) ;
 }
@@ -89,8 +89,8 @@ VolZmap::IntersLineDexel( unsigned int nGrid, const Point3d& ptP, const Vector3d
                           unsigned int nJ, double& dU1, double& dU2) 
 { 
   // Determino l'indice del dexel e il doppio del numero di suo intervalli
-   unsigned int nDexelPos = nJ * m_nVNx[nGrid] + nI ;
-   unsigned int nDexelSize = unsigned int( m_TriZValues[nGrid][nDexelPos].size()) ;
+   unsigned int nDexelPos = nJ * m_nNx[nGrid] + nI ;
+   unsigned int nDexelSize = unsigned int( m_Values[nGrid][nDexelPos].size()) ;
 
  // Se non c'è materiale non devo fare alcunché
   if ( nDexelSize == 0) 
@@ -108,8 +108,8 @@ VolZmap::IntersLineDexel( unsigned int nGrid, const Point3d& ptP, const Vector3d
    bool bInters = false ;
    for ( unsigned int nIndex = 0 ; nIndex < nDexelSize ; nIndex += 2) {
      // estremi del box del singolo intervallo 
-      Point3d ptE1( dXmin, dYmin, m_TriZValues[nGrid][nDexelPos][nIndex]) ;
-      Point3d ptE2( dXmax, dYmax, m_TriZValues[nGrid][nDexelPos][nIndex+1]) ;
+      Point3d ptE1( dXmin, dYmin, m_Values[nGrid][nDexelPos][nIndex].dZVal) ;
+      Point3d ptE2( dXmax, dYmax, m_Values[nGrid][nDexelPos][nIndex+1].dZVal) ;
       double dt1, dt2 ;
       if ( IntersLineBox( ptP, vtV, ptE1, ptE2, dt1, dt2)) {
          bInters = true ;
@@ -156,10 +156,10 @@ VolZmap::GetDepth( const Point3d& ptPGlob, const Vector3d& vtDir, double& dInLen
    }
 
   // Determinazione degli indici i j dei punti ptI e ptF       
-   int nIi = Clamp( int( floor( ptI.x / m_dStep)), 0, m_nVNx[0] - 1) ;
-   int nIj = Clamp( int( floor( ptI.y / m_dStep)), 0, m_nVNy[0] - 1) ;
-   int nFi = Clamp( int( floor( ptF.x / m_dStep)), 0, m_nVNx[0] - 1) ;
-   int nFj = Clamp( int( floor( ptF.y / m_dStep)), 0, m_nVNy[0] - 1) ;
+   int nIi = Clamp( int( floor( ptI.x / m_dStep)), 0, m_nNx[0] - 1) ;
+   int nIj = Clamp( int( floor( ptI.y / m_dStep)), 0, m_nNy[0] - 1) ;
+   int nFi = Clamp( int( floor( ptF.x / m_dStep)), 0, m_nNx[0] - 1) ;
+   int nFj = Clamp( int( floor( ptF.y / m_dStep)), 0, m_nNy[0] - 1) ;
     
   // Inizializzo distanze
    dInLength = INFINITO ;
@@ -189,7 +189,7 @@ VolZmap::GetDepth( const Point3d& ptPGlob, const Vector3d& vtDir, double& dInLen
          double dMoveY = dMoveX * dDeltaY / dDeltaX ;
          double dY = ptI.y + dMoveY ;
          int OldJ = j ;
-         j = Clamp( int( floor( dY / m_dStep)), 0, m_nVNy[0] - 1) ;
+         j = Clamp( int( floor( dY / m_dStep)), 0, m_nNy[0] - 1) ;
 
         // Analisi del dexel
          if ( j != OldJ) {
@@ -222,7 +222,7 @@ VolZmap::GetDepth( const Point3d& ptPGlob, const Vector3d& vtDir, double& dInLen
          double dMoveX = dMoveY * dDeltaX / dDeltaY ;
          double dX = ptI.x + dMoveX ;
          int OldI = i ;
-         i = Clamp( int( floor( dX / m_dStep)), 0, m_nVNx[0] - 1) ;
+         i = Clamp( int( floor( dX / m_dStep)), 0, m_nNx[0] - 1) ;
 
        // Analisi del dexel
          if ( i != OldI) {
@@ -260,7 +260,7 @@ VolZmap::AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag)
    b3Box.LocToLoc( frBox, m_MapFrame[0]) ;
 
   // BBox dello Zmap nel suo riferimento intrinseco
-   BBox3d b3Zmap( ORIG, Point3d( m_nVNx[0] * m_dStep, m_nVNy[0] * m_dStep, m_dVMaxZ[0])) ;
+   BBox3d b3Zmap( ORIG, Point3d( m_nNx[0] * m_dStep, m_nNy[0] * m_dStep, m_dMaxZ[0])) ;
 
   // Se non interferiscono, posso uscire
    BBox3d b3Int ;
@@ -268,10 +268,10 @@ VolZmap::AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag)
       return true ;
 
   // Limiti su indici
-   int nStI = Clamp( int( b3Int.GetMin().x / m_dStep), 0, m_nVNx[0] -1) ;
-   int nEnI = Clamp( int( b3Int.GetMax().x / m_dStep), 0, m_nVNx[0] -1) ;
-   int nStJ = Clamp( int( b3Int.GetMin().y / m_dStep), 0, m_nVNy[0] -1) ;
-   int nEnJ = Clamp( int( b3Int.GetMax().y / m_dStep), 0, m_nVNy[0] -1) ;
+   int nStI = Clamp( int( b3Int.GetMin().x / m_dStep), 0, m_nNx[0] -1) ;
+   int nEnI = Clamp( int( b3Int.GetMax().x / m_dStep), 0, m_nNx[0] -1) ;
+   int nStJ = Clamp( int( b3Int.GetMin().y / m_dStep), 0, m_nNy[0] -1) ;
+   int nEnJ = Clamp( int( b3Int.GetMax().y / m_dStep), 0, m_nNy[0] -1) ;
 
   // Vettore direzione dei dexel nel riferimento del Box
    Vector3d vtK = Z_AX ;  vtK.LocToLoc( m_MapFrame[0], frBox) ;
@@ -286,8 +286,8 @@ VolZmap::AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag)
 
       for ( int j = nStJ ; j <= nEnJ ; ++ j) {
 
-         int nPos = j * m_nVNx[0] + i ;
-         int nSize = int( m_TriZValues[0][nPos].size()) ;
+         int nPos = j * m_nNx[0] + i ;
+         int nSize = int( m_Values[0][nPos].size()) ;
          if ( nSize == 0)
             continue ;
 
@@ -297,8 +297,8 @@ VolZmap::AvoidBox( const Frame3d& frBox, const Vector3d& vtDiag)
          if ( IntersLineBox( ptC, vtK, ORIG, ORIG + vtDiag, dZmin, dZmax)) {
 
             for ( int nIndex = 0 ; nIndex < nSize ; nIndex += 2) {
-               if ( ! ( dZmax < m_TriZValues[0][nPos][nIndex] - EPS_SMALL  ||
-                        dZmin > m_TriZValues[0][nPos][nIndex + 1] + EPS_SMALL))
+               if ( ! ( dZmax < m_Values[0][nPos][nIndex].dZVal - EPS_SMALL  ||
+                        dZmin > m_Values[0][nPos][nIndex + 1].dZVal + EPS_SMALL))
                   return false ;
             }
          }
@@ -340,7 +340,7 @@ VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
    int nRoot = PolynomialRoots( 2, vdCoef, vdRoots) ;
 
   // Nessuna soluzione 
-   if ( nRoot == 0) {
+   if ( nRoot == 0 || nRoot == 1) {
 
       if ( abs( vtV.x) > EPS_ZERO) {
       
@@ -375,26 +375,30 @@ VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
 
       if ( ptInt1.x > ptInt2.x)
          swap( ptInt1, ptInt2) ;  
+      
 
-      if ( ptInt1.x < 0  &&  ptInt2.x >= 0  &&  ptInt2.x <= dL) {
+      if ( ptInt1.x < dL + EPS_SMALL) {
       
-         ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;
+         if (  ptInt1.x > - EPS_SMALL) {
+
+            if ( ptInt2.x > dL)
+
+               ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;  
+         }
+         else {
+
+            if ( ptInt2.x > dL) {
+            
+               ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;
+               ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
+            }
+            else if ( ptInt2.x > 0) 
+            
+               ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;     
+            else 
+               return false ;
+         }
       }
-      else if ( ptInt1.x < 0  &&  ptInt2.x > dL) {
-      
-         ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;
-         ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
-      }
-      else if ( ptInt1.x >= 0  &&  ptInt2.x <= dL) {
-      
-         ;
-      }
-      else if ( ptInt1.x >= 0  &&  ptInt1.x < dL  &&  ptInt2.x >= dL) {
-      
-         ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
-      }
-     // Intersezioni esterne alla regione di interesse
-     // (quella compresa fra 0 e dL)
       else 
          return false ;
 
@@ -409,7 +413,7 @@ VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
 //----------------------------------------------------------------------------
 bool 
 VolZmap::IntersZLineCylinder( const Point3d& ptLine,
-                              const Point3d& ptBase, const Point3d& ptTop, const Vector3d& vtDir, double dCylR,
+                              const Point3d& ptBase, const Point3d& ptTop, double dCylR,
                               double& dInfZ, double& dSupZ) 
 {
   // NB: Le coordinate sono espresse nel sistema griglia
@@ -422,7 +426,7 @@ VolZmap::IntersZLineCylinder( const Point3d& ptLine,
    if ( AreSamePointXYApprox( ptBase, ptTop)) {
 
      // Intersezione
-      if ( SqDistXY( ptLine, ptBase) <= dSqRad) {
+      if ( SqDistXY( ptLine, ptBase) < dSqRad) {
          dInfZ = min( ptBase.z, ptTop.z) ;
          dSupZ = max( ptBase.z, ptTop.z) ;
          return true ;
@@ -440,7 +444,9 @@ VolZmap::IntersZLineCylinder( const Point3d& ptLine,
       Point3d ptS = ( ptBase.z < ptTop.z ? ptBase : ptTop) ;
       Point3d ptE = ( ptBase.z < ptTop.z ? ptTop : ptBase) ;
 
-      Vector3d vtV1 = ptE - ptS ;  vtV1.z = 0 ;
+      Vector3d vtAx = ptE - ptS ;  
+
+      Vector3d vtV1( vtAx.x, vtAx.y, 0) ;
 
       double dLenXY = vtV1.LenXY() ;
       double dSZ = ptS.z ;
@@ -456,7 +462,7 @@ VolZmap::IntersZLineCylinder( const Point3d& ptLine,
       Vector3d vtV2 = vtV1 ;
       vtV2.Rotate( Z_AX, 90) ;
 
-      double dLen = ( ptE - ptS).Len() ;
+      double dLen = vtAx.Len() ;
 
      // Sono seno e coseno dell'angolo complementare
      // rispetto a quello formato dal vettore movimento
@@ -478,9 +484,9 @@ VolZmap::IntersZLineCylinder( const Point3d& ptLine,
         // Minimi
          if ( dLocX1 < dX1_0) {
 
-            double dDotS = vtDir * ( ptS - ORIG) ;
+            double dDotS = vtAx * ( ptS - ORIG) ;
            // Qui usiamo ptLine perché servono coordinate griglia
-            dInfZ = ( dDotS - vtDir.x * ptLine.x - vtDir.y * ptLine.y) / vtDir.z ;
+            dInfZ = ( dDotS - vtAx.x * ptLine.x - vtAx.y * ptLine.y) / vtAx.z ;
          }
          else {
 
@@ -490,17 +496,17 @@ VolZmap::IntersZLineCylinder( const Point3d& ptLine,
          } 
             
         // Massimi
-         if ( dLocX1 < dLenXY - dX1_0)  {
+         if ( dLocX1 <= dLenXY - dX1_0)  {
 
             double dZ0 = dSin * dSqRoot ;
 
-            dSupZ = dSZ + dZ0 + ( dLocX1 - dX1_0) * dDeltaZ / dLenXY ;       
+            dSupZ = dSZ + dZ0 + ( dLocX1 + dX1_0) * dDeltaZ / dLenXY ;       
          }
          else {
 
-            double dDotE = vtDir * ( ptE - ORIG) ;
+            double dDotE = vtAx * ( ptE - ORIG) ;
            // Qui usiamo ptLine perché servono coordinate griglia
-            dSupZ = ( dDotE - vtDir.x * ptLine.x - vtDir.y * ptLine.y) / vtDir.z ;
+            dSupZ = ( dDotE - vtAx.x * ptLine.x - vtAx.y * ptLine.y) / vtAx.z ;
          }
 
          return true ;
@@ -533,6 +539,8 @@ VolZmap::IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
    DBLVECTOR vdRoots ;
 
    double dSqTan = dTan * dTan ;
+   double dMinRad = dTan * dl ;
+   double dMaxRad = dTan * dL ;
           
    vdCoef[0] = dSqTan * ptP.x * ptP.x - ptP.y * ptP.y - ptP.z * ptP.z ;
    vdCoef[1] = 2 * ( dSqTan * ptP.x * vtV.x - ptP.y * vtV.y - ptP.z * vtV.z) ;
@@ -550,21 +558,33 @@ VolZmap::IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
    if ( nRoot == 1) {
 
       ptInt1 = ptP + vdRoots[0] * vtV ;
-            
-      if ( ptInt1.x >= dl  &&  ptInt1.x < dL) {
 
-         ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;   
-      } 
-      else if ( ptInt1.x >= 0  &&  ptInt1.x < dl) {
+      if ( ptInt1.x < dL + EPS_SMALL) {
 
-         ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
-         ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
-      }  
+         if ( ptInt1.x > dl)
+      
+               ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
 
-     // Riporto le coordinate nel sistema di riferimento
-     // griglia
-      ptInt1.ToGlob( ConusFrame) ;
-      ptInt2.ToGlob( ConusFrame) ;
+         else if ( ptInt1.x > - EPS_SMALL) {
+
+            ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
+            ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;  
+
+            if ( ptInt2.y * ptInt2.y + ptInt2.z * ptInt2.z > dMaxRad * dMaxRad)
+
+                 return false ;
+         }
+         else 
+            return false ;
+
+         ptInt1.ToGlob( ConusFrame) ;
+         ptInt2.ToGlob( ConusFrame) ;
+
+         return true ;
+      }
+      else 
+         return false ;
+      
    }
   // Due soluzioni: la retta interseca due volte la 
   // superficie laterale
@@ -573,54 +593,67 @@ VolZmap::IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
       ptInt1 = ptP + vdRoots[0] * vtV ;
       ptInt2 = ptP + vdRoots[1] * vtV ;
 
-      if ( ptInt1.x > ptInt2.x) {
+      if ( ptInt1.x > ptInt2.x) 
          swap( ptInt1, ptInt2) ;
-      }
-            
-      if ( ptInt1.x < 0  &&  ptInt2.x > 0  &&  ptInt2.x < dl) {
+     
 
-         ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
-         ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ; 
-      }
-      else if ( ptInt1.x < 0  &&  ptInt2.x >= dl  &&  ptInt2.x < dL) {
-            
-         ptInt1 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;       
-      }
-      else if ( ptInt1.x > 0  &&  ptInt1.x < dl  &&  ptInt2.x >= dl  &&  ptInt2.x < dL) {
-                  
-         ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
-      }
-      else if ( ptInt1.x > 0  &&  ptInt1.x < dl  &&  ptInt2.x >= dL) {
+      if ( ptInt1.x < dL + EPS_SMALL) {
+      
+         if ( ptInt1.x > dl - EPS_SMALL) {
 
-         ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
-         ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;               
-      }
-      else if ( ptInt1.x >= dl  &&  ptInt1.x < dL  &&  ptInt2.x < dL) {
+            if ( ptInt2.x > dL) 
 
-         ; 
+               ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ; 
+         }
+         else if ( ptInt1.x > - EPS_SMALL) {
+
+            if ( ptInt2.x > dL) {
+
+               ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
+               ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;     
+            }
+            else if ( ptInt2.x > dl - EPS_SMALL) 
+
+               ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
+
+            else 
+               return false ;
+         }
+         else {
+
+            if ( ptInt2.x < 0) 
+
+               return false ;
+
+            else if ( ptInt2.x < dl) {
+
+               ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
+               ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;             
+            }          
+            else if ( ptInt2.x < dL) 
+
+               ptInt1 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
+
+            else 
+               return false ;
+         }
+
+         ptInt1.ToGlob( ConusFrame) ;
+         ptInt2.ToGlob( ConusFrame) ;
+
+         return true ;
       }
-      else if ( ptInt1.x >= dl  &&  ptInt1.x < dL  &&  ptInt2.x >= dL) {
-            
-         ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;    
-      }
-     // Intersezioni esterne alla regione di interesse
-     // (quella compresa fra dl e dL)
       else 
          return false ;
-
-     // Riporto le coordinate nel sistema di riferimento
-     // griglia
-      ptInt1.ToGlob( ConusFrame) ;
-      ptInt2.ToGlob( ConusFrame) ;
    }
-  
-   return true ;
+   return false ;
 }
 
 //----------------------------------------------------------------------------
 bool 
-VolZmap::IntersLineEllipticalCylinder( const Frame3d & CircFrame, const Vector3d & vtLineDir, const Point3d & ptLineSt,
-                                         std::vector <Point3d> & ptInters, double dObCoef, double dSqRad, double dL)
+VolZmap::IntersLineEllipticalCylinder( const Vector3d& vtLineDir, const Point3d& ptLineSt,
+                                       const Frame3d& CircFrame, double dSqRad, double dLongMvLen, double dOrtMvLen,
+                                       Point3d& ptInt1, Point3d& ptInt2)
 {
   // NB: L'origine del sistema di riferimento deve essere 
   // nel centro della circonferenza di base, la cui tralsazione obliqua
@@ -628,21 +661,20 @@ VolZmap::IntersLineEllipticalCylinder( const Frame3d & CircFrame, const Vector3d
   // di simmetria di tale circonferenza.
   // La funzione restituisce true in caso di intersezione,
   // false altrimenti.
-  // NB: Il Parametro dObCoef è il coeffociente angolare della retta movimento
-  // rispetto all'asse x, e dSqRad è il quadrato del raggio della circonferenza. 
+  // NB: dSqRad è il quadrato del raggio della circonferenza la cui
+  // traslazione obliqua genera il cilindro ellittico, dLongMvLen e 
+  // dOrtMvLen sono rispettivamente le lunghezze delle proiezioni del 
+  // movimento su x e y del sistema di riferimento CircFrame. 
 
+   double dObCoef = dOrtMvLen / dLongMvLen ;
    double dSqCoef = dObCoef * dObCoef ;
 
    Point3d ptP = ptLineSt ;
    Vector3d vtV = vtLineDir ; 
 
-  // Sistema di riferimanto grigia
-   Frame3d GridFrame ;        
-   GridFrame.Set( ORIG, X_AX, Y_AX, Z_AX) ;
-
   // Trasformazione delle coordinate
-   ptP.LocToLoc( GridFrame, CircFrame) ;
-   vtV.LocToLoc( GridFrame, CircFrame) ;
+   ptP.ToLoc( CircFrame) ;
+   vtV.ToLoc( CircFrame) ;
 
    std::vector <double> vdCoef(3) ;
    std::vector <double> vdRoots ;
@@ -653,26 +685,20 @@ VolZmap::IntersLineEllipticalCylinder( const Frame3d & CircFrame, const Vector3d
 
    int nRoot = PolynomialRoots( 2, vdCoef, vdRoots) ;
 
-   Point3d ptR1, ptR2 ;
 
    // Nessuna soluzione 
-   if ( nRoot == 0) {
+   if ( nRoot == 0 || nRoot == 1) {
 
       if ( abs( vtV.x) > EPS_ZERO) {
       
-         ptR1 = ptP - ( ptP.x / vtV.x) * vtV ;
-         ptR2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
+         ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;
+         ptInt2 = ptP + ( ( dLongMvLen - ptP.x) / vtV.x) * vtV ;
 
-         if ( ptR1.y * ptR1.y + ptR1.z * ptR1.z < dSqRad &&
-              ptR1.y * ptR1.y + ptR1.z * ptR1.z < dSqRad) {
+         if ( ptInt1.y * ptInt1.y + ptInt1.z * ptInt1.z < dSqRad &&
+            ( ptInt2.y - dOrtMvLen) * ( ptInt2.y - dOrtMvLen) + ptInt2.z * ptInt2.z < dSqRad) {
 
-            ptR1.LocToLoc( CircFrame, GridFrame) ;
-            ptR2.LocToLoc( CircFrame, GridFrame) ;
-
-            ptInters.resize(2) ;
-
-            ptInters[0] = ptR1 ;
-            ptInters[0] = ptR2 ;
+            ptInt1.ToGlob( CircFrame) ;
+            ptInt2.ToGlob( CircFrame) ;
 
             return true ;
          }
@@ -689,48 +715,340 @@ VolZmap::IntersLineEllipticalCylinder( const Frame3d & CircFrame, const Vector3d
   // coincidenti) oppure nessuna o infinite se la la retta
   // appartiene alla superficie
 
-   ptInters.resize(2) ;
-
    if ( nRoot == 2) {
 
-      ptR1 = ptP + vdRoots[0] * vtV ;
-      ptR2 = ptP + vdRoots[1] * vtV ;
+      ptInt1 = ptP + vdRoots[0] * vtV ;
+      ptInt2 = ptP + vdRoots[1] * vtV ;
 
    
-      if ( ptR1.x > ptR2.x) {
+      if ( ptInt1.x > ptInt2.x) 
          
-           Point3d ptTemp = ptR1 ;
-           ptR1 = ptR2 ;
-           ptR2 = ptTemp ;
-      }
+         swap( ptInt1, ptInt2) ;
 
-      if ( ptR1.x >= 0 && ptR1.x < dL &&
-           ptR2.x > dL) {
 
-         ptR1 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;    
-      }
-      else if ( ptR1.x >= 0 && ptR2.x <= dL) {
+      if ( ptInt1.x < dLongMvLen + EPS_SMALL) {
+      
+         if (  ptInt1.x > - EPS_SMALL) {
 
-         ;
-      }
-      else if ( ptR1.x < 0 && ptR2.x > dL) {
+            if ( ptInt2.x > dLongMvLen)
 
-         ptR1 = ptP - ( ptP.x / vtV.x) * vtV ;
-         ptR2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
-      }
-      else if ( ptR1.x < 0 && ptR2.x >= 0 && ptR2.x <= dL) {
+               ptInt2 = ptP + ( ( dLongMvLen - ptP.x) / vtV.x) * vtV ;  
+         }
+         else {
 
-         ptR1 = ptP - ( ptP.x / vtV.x) * vtV ;    
+            if ( ptInt2.x > dLongMvLen) {
+            
+               ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;
+               ptInt2 = ptP + ( ( dLongMvLen - ptP.x) / vtV.x) * vtV ;
+
+               if ( ptInt1.y * ptInt1.y + ptInt1.z * ptInt1.z > dSqRad &&
+                    ptInt2.y * ptInt2.y + ptInt2.z * ptInt2.z > dSqRad)
+
+                    return false ;
+            }
+            else if ( ptInt2.x > 0) 
+            
+               ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;     
+            else 
+               return false ;
+         }
       }
+      else 
+         return false ;
 
      // Riporto le coordinate nel sistema di riferimento
      // griglia
-      ptR1.LocToLoc( CircFrame, GridFrame) ;
-      ptR2.LocToLoc( CircFrame, GridFrame) ;
-      
-      ptInters[0] = ptR1 ;
-      ptInters[1] = ptR2 ;
+      ptInt1.ToGlob( CircFrame) ;
+      ptInt2.ToGlob( CircFrame) ;
    }   
 
    return true ;
-}
\ No newline at end of file
+}
+
+//----------------------------------------------------------------------------
+bool 
+VolZmap::IntersLineMyPolyhedron( const Point3d& ptLineSt, const Vector3d& vtLineDir,
+                                      const Frame3d& PolyFrame, double dLenX, double dLenY, double dLenZ, double dDeltaX,
+                                      Point3d& ptInt1, Point3d& ptInt2) 
+{
+
+   double SqIndet = EPS_SMALL * EPS_SMALL ;
+
+   Point3d ptP = ptLineSt ;
+   Vector3d vtV = vtLineDir ;
+
+  // Trasformazione delle coordinate
+   ptP.ToLoc( PolyFrame) ;
+   vtV.ToLoc( PolyFrame) ;
+
+  // Facce 1 e 2 parallele a XY
+  // Facce 3 e 4 parallele a XZ
+  // Facce 5 e 6 oblique
+   Point3d ptFacet135( 0, 0, dLenZ /2) ;
+   Point3d ptFacet246( dLenX + dDeltaX, dLenY, - dLenZ / 2) ;
+
+  // Servono per descrivere i piani obliqui
+   Vector3d vtFacet5 = ptFacet135 - ptP ;
+   Vector3d vtFacet6 = ptFacet246 - ptP ;
+
+   Vector3d vtOb( dLenY, - dDeltaX, 0) ;
+
+   Point3d ptI1 = ptP + ( ( ptFacet135.z - ptP.z) / vtV.z) * vtV ;
+   Point3d ptI2 = ptP + ( ( ptFacet246.z - ptP.z) / vtV.z) * vtV ;
+   Point3d ptI3 = ptP + ( ( ptFacet135.y - ptP.y) / vtV.y) * vtV ;
+   Point3d ptI4 = ptP + ( ( ptFacet246.y - ptP.y) / vtV.y) * vtV ;
+   Point3d ptI5 = ptP + ( ( vtFacet5 * vtOb) / ( vtV * vtOb)) * vtV ;
+   Point3d ptI6 = ptP + ( ( vtFacet6 * vtOb) / ( vtV * vtOb)) * vtV ;
+
+   int nIntNum = 0 ;
+
+  // Intersezione con la prima faccia
+   if ( ptI1.y >= 0 && ptI1.y <= dLenY && 
+        ptI1.x * dLenY >= dDeltaX * ptI1.y && ( ptI1.x - dLenX) * dLenY <= dDeltaX * ptI1.y) {
+
+      ptInt1 = ptI1 ;
+      ++ nIntNum ;
+   }
+  
+  // Intersezione con la seconda faccia
+   if ( ptI2.y >= 0 && ptI2.y <= dLenY && 
+        ptI2.x * dLenY >= dDeltaX * ptI2.y && ( ptI2.x - dLenX) * dLenY <= dDeltaX * ptI2.y) {
+
+      if ( nIntNum == 0) {
+      
+         ptInt1 = ptI2 ;
+         ++ nIntNum ;
+      }
+      else if ( ( ptInt1 - ptI2).SqLen() > SqIndet) {
+      
+         ptInt2 = ptI2 ;
+         ++ nIntNum ;
+      }
+   }
+
+  // Intersezione con la terza faccia
+   if ( nIntNum < 2 &&
+        ptI3.x >= 0 && ptI3.x <= dLenX && 
+        ptI3.z >= - ptFacet135.z && ptI3.z <= ptFacet135.z) {
+
+      if ( nIntNum == 0) {
+      
+         ptInt1 = ptI3 ;
+         ++ nIntNum ;
+      }
+      else if ( ( ptInt1 - ptI3).SqLen() > SqIndet) {
+      
+         ptInt2 = ptI3 ;
+         ++ nIntNum ;
+      }
+   }
+
+  // Intersezione con la quarta faccia
+   if ( nIntNum < 2 &&
+        ptI4.x >= dDeltaX && ptI4.x <= dLenX + dDeltaX && 
+        ptI4.z >= - ptFacet135.z && ptI4.z <= ptFacet135.z) {
+
+      if ( nIntNum == 0) {
+      
+         ptInt1 = ptI4 ;
+         ++ nIntNum ;
+      }
+      else if ( ( ptInt1 - ptI4).SqLen() > SqIndet) {
+      
+         ptInt2 = ptI4 ;
+         ++ nIntNum ;
+      }
+   }
+
+  // Intersezione con la quinta faccia
+   if ( nIntNum < 2 &&
+        ptI5.y >= 0 && ptI5.y <= dLenY && 
+        ptI5.z >= - ptFacet135.z && ptI5.z <= ptFacet135.z) {
+
+      if ( nIntNum == 0) {
+      
+         ptInt1 = ptI5 ;
+         ++ nIntNum ;
+      }
+      else if ( ( ptInt1 - ptI5).SqLen() > SqIndet) {
+      
+         ptInt2 = ptI5 ;
+         ++ nIntNum ;
+      }  
+   }
+
+  // Intersezione con la sesta faccia
+   if ( nIntNum < 2 &&
+        ptI6.y >= 0 && ptI6.y <= dLenY && 
+        ptI6.z >= - ptFacet135.z && ptI6.z <= ptFacet135.z) {
+
+      if ( nIntNum == 0) {
+      
+         ptInt1 = ptI6;
+         ++ nIntNum ;
+      }
+      else if ( ( ptInt1 - ptI6).SqLen() > SqIndet) {
+      
+         ptInt2 = ptI6;
+         ++ nIntNum ;
+      } 
+   }
+
+   
+   if ( nIntNum == 2) {
+   
+      ptInt1.ToGlob( PolyFrame) ;
+      ptInt2.ToGlob( PolyFrame) ;
+
+      return true ;
+   }
+   else 
+      return false ;
+}
+/*
+//----------------------------------------------------------------------------
+bool 
+VolZmap::IntersLineMyPolyhedron( const Point3d& ptLineSt, const Vector3d& vtLineDir,
+                                      const Frame3d& PolyFrame, double dLenX, double dLenY, double dLenZ, double dDeltaX,
+                                      Point3d& ptInt1, Point3d& ptInt2) 
+{
+
+   double SqIndet = EPS_SMALL * EPS_SMALL ;
+
+   Point3d ptP = ptLineSt ;
+   Vector3d vtV = vtLineDir ;
+
+  // Trasformazione delle coordinate
+   ptP.ToLoc( PolyFrame) ;
+   vtV.ToLoc( PolyFrame) ;
+
+  // Facce 1 e 2 parallele a XY
+  // Facce 3 e 4 parallele a XZ
+  // Facce 5 e 6 oblique
+   Point3d ptFacet135( 0, 0, dLenZ /2) ;
+   Point3d ptFacet246( dLenX + dDeltaX, dLenY, - dLenZ / 2) ;
+
+  // Servono per descrivere i piani obliqui
+   Vector3d vtFacet5 = ptFacet135 - ptP ;
+   Vector3d vtFacet6 = ptFacet246 - ptP ;
+
+   Vector3d vtOb( dLenY, - dDeltaX, 0) ;
+
+   Point3d ptI1 = ptP + ( ( ptFacet135.z - ptP.z) / vtV.z) * vtV ;
+   Point3d ptI2 = ptP + ( ( ptFacet246.z - ptP.z) / vtV.z) * vtV ;
+   Point3d ptI3 = ptP + ( ( ptFacet135.y - ptP.y) / vtV.y) * vtV ;
+   Point3d ptI4 = ptP + ( ( ptFacet246.y - ptP.y) / vtV.y) * vtV ;
+   Point3d ptI5 = ptP + ( ( vtFacet5 * vtOb) / ( vtV * vtOb)) * vtV ;
+   Point3d ptI6 = ptP + ( ( vtFacet6 * vtOb) / ( vtV * vtOb)) * vtV ;
+
+   int nIntNum = 0 ;
+
+  // Intersezione con la prima faccia
+   if ( ptI1.y > - EPS_SMALL && ptI1.y < dLenY + EPS_SMALL && 
+        ptI1.x * dLenY > dDeltaX * ptI1.y - EPS_SMALL && 
+        ( ptI1.x - dLenX) * dLenY < dDeltaX * ptI1.y + EPS_SMALL) {
+
+      ptInt1 = ptI1 ;
+      ++ nIntNum ;
+   }
+  
+  // Intersezione con la seconda faccia
+   if ( ptI2.y > - EPS_SMALL && ptI2.y <dLenY + EPS_SMALL && 
+        ptI2.x * dLenY > dDeltaX * ptI2.y - EPS_SMALL &&
+        ( ptI2.x - dLenX) * dLenY < dDeltaX * ptI2.y + EPS_SMALL) {
+
+      if ( nIntNum == 0) {
+      
+         ptInt1 = ptI2 ;
+         ++ nIntNum ;
+      }
+      else if ( ( ptInt1 - ptI2).SqLen() > SqIndet) {
+      
+         ptInt2 = ptI2 ;
+         ++ nIntNum ;
+      }
+   }
+
+  // Intersezione con la terza faccia
+   if ( nIntNum < 2 &&
+        ptI3.x > - EPS_SMALL && ptI3.x < dLenX + EPS_SMALL && 
+        ptI3.z > - ptFacet135.z - EPS_SMALL && 
+        ptI3.z < ptFacet135.z + EPS_SMALL) {
+
+      if ( nIntNum == 0) {
+      
+         ptInt1 = ptI3 ;
+         ++ nIntNum ;
+      }
+      else if ( ( ptInt1 - ptI3).SqLen() > SqIndet) {
+      
+         ptInt2 = ptI3 ;
+         ++ nIntNum ;
+      }
+   }
+
+  // Intersezione con la quarta faccia
+   if ( nIntNum < 2 &&
+        ptI4.x > dDeltaX - EPS_SMALL && ptI4.x < dLenX + dDeltaX + EPS_SMALL && 
+        ptI4.z > - ptFacet135.z - EPS_SMALL &&
+        ptI4.z < ptFacet135.z + EPS_SMALL) {
+
+      if ( nIntNum == 0) {
+      
+         ptInt1 = ptI4 ;
+         ++ nIntNum ;
+      }
+      else if ( ( ptInt1 - ptI4).SqLen() > SqIndet) {
+      
+         ptInt2 = ptI4 ;
+         ++ nIntNum ;
+      }
+   }
+
+  // Intersezione con la quinta faccia
+   if ( nIntNum < 2 &&
+        ptI5.y > - EPS_SMALL && ptI5.y < dLenY + EPS_SMALL && 
+        ptI5.z > - ptFacet135.z - EPS_SMALL && 
+        ptI5.z < ptFacet135.z + EPS_SMALL) {
+
+      if ( nIntNum == 0) {
+      
+         ptInt1 = ptI5 ;
+         ++ nIntNum ;
+      }
+      else if ( ( ptInt1 - ptI5).SqLen() > SqIndet) {
+      
+         ptInt2 = ptI5 ;
+         ++ nIntNum ;
+      }  
+   }
+
+  // Intersezione con la sesta faccia
+   if ( nIntNum < 2 &&
+        ptI6.y > - EPS_SMALL && ptI6.y < dLenY + EPS_SMALL && 
+        ptI6.z > - ptFacet135.z - EPS_SMALL &&
+        ptI6.z < ptFacet135.z + EPS_SMALL) {
+
+      if ( nIntNum == 0) {
+      
+         ptInt1 = ptI6;
+         ++ nIntNum ;
+      }
+      else if ( ( ptInt1 - ptI6).SqLen() > SqIndet) {
+      
+         ptInt2 = ptI6;
+         ++ nIntNum ;
+      } 
+   }
+
+   
+   if ( nIntNum == 2) {
+   
+      ptInt1.ToGlob( PolyFrame) ;
+      ptInt2.ToGlob( PolyFrame) ;
+
+      return true ;
+   }
+   else 
+      return false ;
+} */
\ No newline at end of file
diff --git a/VolTriZmapCreation.cpp b/VolTriZmapCreation.cpp
index 2936b89..7b79422 100644
--- a/VolTriZmapCreation.cpp
+++ b/VolTriZmapCreation.cpp
@@ -31,11 +31,11 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
 {
 
   // Controlli l'ammissibilità delle dimensioni lineari del grezzo e del passo
-   if ( dPrec < EPS_SMALL || dLengthX < EPS_SMALL || dLengthY < EPS_SMALL || dLengthZ < EPS_SMALL)
+   if ( dPrec < EPS_SMALL  ||  dLengthX < EPS_SMALL  ||  dLengthY < EPS_SMALL  ||  dLengthZ < EPS_SMALL)
       return false ; 
 
-  // Aggiorno il passo
-   m_dStep = dPrec ;
+  // Il passo di discretizzazione non può essere inferiore a 100 * EPS_SMALL
+   m_dStep = max( dPrec, 100 * EPS_SMALL) ;
 
   // Aggiorno la dimensione della mappa 1 o 3
    m_nMapNum = ( bFlag ? 3 : 1) ;
@@ -48,30 +48,48 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
    m_MapFrame[0].Set( ptO, X_AX, Y_AX, Z_AX) ;
 
   // Definisco i vettori dei limiti su indici
-   m_nVNx[0] = static_cast <unsigned int> ( ceil( dLengthX / m_dStep)) ;
-   m_nVNy[0] = static_cast <unsigned int> ( ceil( dLengthY / m_dStep)) ;
+   m_nNx[0] = static_cast <unsigned int> ( floor( ( dLengthX + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
+   m_nNy[0] = static_cast <unsigned int> ( floor( ( dLengthY + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
 
-   if ( m_nMapNum > 1) {
+  // Definisco il numero di blocchi lungo x e y
+   unsigned int nMinBlockNum = 1 ;
+
+   m_nFracLin[0] = max( nMinBlockNum,
+                        m_nNx[0] / m_nDexNumPBlock +
+                        ( m_nNx[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
+   m_nFracLin[1] = max( nMinBlockNum,
+                        m_nNy[0] / m_nDexNumPBlock +
+                        ( m_nNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
+
+   if ( bFlag) {
 
       m_MapFrame[1].Set( ptO, Y_AX, Z_AX, X_AX) ;
       m_MapFrame[2].Set( ptO, Z_AX, X_AX, Y_AX) ;
  
-      m_nVNx[1] = static_cast <unsigned int> ( ceil( dLengthY / m_dStep)) ;
-      m_nVNy[1] = static_cast <unsigned int> ( ceil( dLengthZ / m_dStep)) ;
+      m_nNx[1] = static_cast <unsigned int> ( floor( ( dLengthY + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
+      m_nNy[1] = static_cast <unsigned int> ( floor( ( dLengthZ + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
 
-      m_nVNx[2] = static_cast <unsigned int> ( ceil( dLengthZ / m_dStep)) ;
-      m_nVNy[2] = static_cast <unsigned int> ( ceil( dLengthX / m_dStep)) ;
+      m_nNx[2] = static_cast <unsigned int> ( floor( ( dLengthZ + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
+      m_nNy[2] = static_cast <unsigned int> ( floor( ( dLengthX + 0.5 * m_dStep + EPS_SMALL) / m_dStep)) ;
+
+     // Definisco il numero di blocchi lungo z
+      m_nFracLin[2] = max( nMinBlockNum,
+                           m_nNy[1] / m_nDexNumPBlock +
+                           ( m_nNy[1] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
    }
    else {
 
       m_MapFrame[1].Set( ptO, Y_AX, Z_AX, X_AX) ;
       m_MapFrame[2].Set( ptO, Z_AX, X_AX, Y_AX) ;
 
-      m_nVNx[1] = 0 ;
-      m_nVNy[1] = 0 ;
+      m_nNx[1] = 0 ;
+      m_nNy[1] = 0 ;
 
-      m_nVNx[2] = 0 ;
-      m_nVNy[2] = 0 ; 
+      m_nNx[2] = 0 ;
+      m_nNy[2] = 0 ; 
+
+     // Definisco il numero di blocchi lungo z
+      m_nFracLin[2] = 1 ;
    }
 
   // Definizione della mappa
@@ -80,41 +98,61 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
   // Calcolo del numero di celle per ogni mappa
    for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i)
 
-      m_nVDim[i] = m_nVNx[i] * m_nVNy[i] ;
+      m_nDim[i] = m_nNx[i] * m_nNy[i] ;
 
   // Creazione delle celle per ogni mappa
    for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i)
 
-      m_TriZValues[i].resize( m_nVDim[i]) ;
+      m_Values[i].resize( m_nDim[i]) ;
 
   // Riempimento delle celle
    for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i)
-      for ( unsigned int j = 0 ; j < m_nVDim[i] ; ++ j) {
+      for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j) {
 
-         m_TriZValues[i][j].resize(2) ;
+         m_Values[i][j].resize(2) ;
 
-         m_TriZValues[i][j][0] = 0 ;
+         m_Values[i][j][0].dZVal = 0 ;
 
-         if ( i == 0)
-            m_TriZValues[i][j][1] = dLengthZ ;
-         else if ( i == 1)
-            m_TriZValues[i][j][1] = dLengthX ;
-         else if ( i == 2)
-            m_TriZValues[i][j][1] = dLengthY ;
+         switch ( i) {
+         case 0 :
+            m_Values[i][j][1].dZVal = dLengthZ ; 
+            m_Values[i][j][0].vtN = Vector3d( 0, 0, - 1) ;
+            m_Values[i][j][1].vtN = Vector3d( 0, 0, 1) ;
+            break ;
+         case 1 :
+            m_Values[i][j][1].dZVal = dLengthX ; 
+            m_Values[i][j][0].vtN = Vector3d( - 1, 0, 0) ;
+            m_Values[i][j][1].vtN = Vector3d( 1, 0, 0) ;
+            break ;
+         case 2 :
+            m_Values[i][j][1].dZVal = dLengthY ; 
+            m_Values[i][j][0].vtN = Vector3d( 0, - 1, 0) ;
+            m_Values[i][j][1].vtN = Vector3d( 0, 1, 0) ;
+            break ; 
+         }
       }
 
   // Definizione delle limitazioni iniziali in Z per ogni mappa
    for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) {
    
-      m_dVMinZ[i] = 0 ;
+      m_dMinZ[i] = 0 ;
 
       if ( i == 0)
-         m_dVMaxZ[i] = dLengthZ ;
+         m_dMaxZ[i] = dLengthZ ;
       else if ( i == 1)
-         m_dVMaxZ[i] = dLengthX ;
+         m_dMaxZ[i] = dLengthX ;
       else if ( i == 2)
-         m_dVMaxZ[i] = dLengthY ;
+         m_dMaxZ[i] = dLengthY ;
    }
+
+  // Ridimensiono e setto il vettore dei blocchi a falso
+   int BlockVecSize = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ;
+
+   m_BlockToUpdate.resize( BlockVecSize) ;
+
+   for ( int nCount = 0 ; nCount < BlockVecSize ; ++ nCount)
+
+      m_BlockToUpdate[nCount] = true ;
   
   // Aggiornamento dello stato
    m_nStatus = OK ;
@@ -122,10 +160,11 @@ VolZmap::Create( const Point3d& ptO, double dLengthX, double dLengthY, double dL
    return true ;
 }
 
+//----------------------------------------------------------------------------------------------------
 bool
 VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dPrec, bool bFlag) 
 {
-
+#if 0
    Point3d ptMapOrig, ptMapEnd ; 
 
   // Aggiorno la dimensione della mappa 1 o 3
@@ -159,6 +198,16 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
   // Ridimensiono il vettore di dexel e creo lo Zmap
    m_TriZValues[0].resize( m_nVDim[0]) ;
 
+  // Definisco il numero di blocchi lungo x e y
+   unsigned int nMinBlockNum = 1 ;
+
+   m_nFracLin[0] = max( nMinBlockNum,
+                        m_nVNx[0] / m_nDexNumPBlock +
+                        ( m_nVNx[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
+   m_nFracLin[1] = max( nMinBlockNum,
+                        m_nVNy[0] / m_nDexNumPBlock +
+                        ( m_nVNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
+
   // Se Tridexel ridimensiono anche gli altri vettori
    if ( bFlag) {
 
@@ -177,6 +226,11 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
 
       m_TriZValues[1].resize( m_nVDim[1]) ;
       m_TriZValues[2].resize( m_nVDim[2]) ;
+
+     // Definisco il numero di blocchi lungo z
+      m_nFracLin[2] = max( nMinBlockNum,
+                           m_nVNy[1] / m_nDexNumPBlock +
+                           ( m_nVNy[1] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
    }
    else {
 
@@ -324,10 +378,19 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
       m_dVMinZ[2] = 0 ;  
       m_dVMaxZ[2] = 0 ; 
    }
+
+  // Ridimensiono e setto il vettore dei blocchi a falso
+   int BlockVecSize = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ;
+
+   m_BlockToUpdate.resize( BlockVecSize) ;
+
+   for ( int nCount = 0 ; nCount < BlockVecSize ; ++ nCount)
+
+      m_BlockToUpdate[nCount] = true ;
    
   // Aggiornamento dello stato
    m_nStatus = OK ;
-
+#endif
    return true ;
 }
 
@@ -335,7 +398,8 @@ VolZmap::CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double
 bool
 VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
 {
-  // Se la superficie non è chiusa non ha senso continuare
+#if 0
+   // Se la superficie non è chiusa non ha senso continuare
    if ( ! Surf.IsClosed())
       return false ;
 
@@ -372,6 +436,16 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
   // Ridimensiono il vettore di dexel e creo lo Zmap
    m_TriZValues[0].resize( m_nVDim[0]) ;
 
+  // Definisco il numero di blocchi lungo x e y
+   unsigned int nMinBlockNum = 1 ;
+
+   m_nFracLin[0] = max( nMinBlockNum,
+                        m_nVNx[0] / m_nDexNumPBlock +
+                        ( m_nVNx[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
+   m_nFracLin[1] = max( nMinBlockNum,
+                        m_nVNy[0] / m_nDexNumPBlock +
+                        ( m_nVNy[0] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
+
   // Se Tridexel ridimensiono anche gli altri vettori
    if ( bFlag) {
 
@@ -390,6 +464,11 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
 
       m_TriZValues[1].resize( m_nVDim[1]) ;
       m_TriZValues[2].resize( m_nVDim[2]) ;
+
+     // Definisco il numero di blocchi lungo z
+      m_nFracLin[2] = max( nMinBlockNum,
+                           m_nVNy[1] / m_nDexNumPBlock +
+                           ( m_nVNy[1] % m_nDexNumPBlock >= m_nDexNumPBlock / 2 ? 1 : 0)) ;
    }
 
 
@@ -587,9 +666,16 @@ VolZmap::CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bFlag)
       m_dVMaxZ[2] = 0 ;      
    }
 
-                 
+  // Ridimensiono e setto il vettore dei blocchi a falso
+   int BlockVecSize = m_nFracLin[0] * m_nFracLin[1] * m_nFracLin[2] ;
+
+   m_BlockToUpdate.resize( BlockVecSize) ;
+
+   for ( int nCount = 0 ; nCount < BlockVecSize ; ++ nCount)
+
+      m_BlockToUpdate[nCount] = true ;               
 
    m_nStatus = OK ;
-
+#endif
    return true ;   
 }
\ No newline at end of file
diff --git a/VolTriZmapGraphics.cpp b/VolTriZmapGraphics.cpp
index 4e816a1..c37ca6e 100644
--- a/VolTriZmapGraphics.cpp
+++ b/VolTriZmapGraphics.cpp
@@ -18,13 +18,97 @@
 #include "VolZmap.h"
 #include "GeoConst.h"
 #include "IntersLineSurfTm.h"
+#include "MC_Tables.h"
 #include "\EgtDev\Include\EGkIntervals.h"
 #include "\EgtDev\Include\EgtNumUtils.h"
-#include "MC_Tables.h"
+#include "\EgtDev\Extern\Eigen\Core"
+#include "\EgtDev\Extern\Eigen\SVD"
 
 
 using namespace std ;
 
+// ------------------------- STRUTTURA VERTICE TRIANGOLO - NORMALE ALLA SUPERFICIE ------------------------------------------------
+
+struct VectorField {
+
+   Point3d ptInt ;
+   Vector3d vtNorm ;
+} ;
+
+// ------------------------- TABELLA BLOCCHI ADIACENTI ----------------------------------------------------------------------------
+
+static int NeighbourTable[8][4] = {
+
+   {0, -1, -1, -1},
+   {1, 1, -1, -1},
+   {1, 1, 2, -1},
+   {2, 1, 2, -1},
+   {1, 3, -1, -1},
+   {2, 1, 3, -1},
+   {2, 2, 3, -1},
+   {3, 1, 2, 3}    
+   } ;
+
+// ------------------------- FUNZIONE TEST SULLE NORMALI --------------------------------------------------------------------------
+
+enum FatureType { NoFeature = 0, Corner = 1, Edge = 2} ;
+
+//----------------------------------------------------------------------------
+bool
+TestOnNormal( const VectorField CompoVert[], int nCompoElem, int& FeatureType)
+{
+   int nI, nJ ;
+   double dMinCosTheta = 1.001 ;
+   double dCosThetaSharp = 0.9 ;
+   
+  // Nota 0-esimo indice è vuoto
+   for ( int i = 0 ; i < nCompoElem ; ++ i) {
+
+      for  ( int j = i + 1 ; j < nCompoElem ; ++ j) {
+
+         double dCurrentCos = CompoVert[i].vtNorm * CompoVert[j].vtNorm ;
+
+         if ( dCurrentCos < dMinCosTheta) {
+
+            nI = i ;
+            nJ = j ;
+            dMinCosTheta = dCurrentCos ;        
+         }  
+      }  
+   } 
+      
+   if ( dMinCosTheta >= dCosThetaSharp) {
+   
+      FeatureType = NoFeature ;
+      return false ;
+   }
+
+   Vector3d vtI = CompoVert[nI].vtNorm ;
+   Vector3d vtJ = CompoVert[nJ].vtNorm ;
+   Vector3d vtK = vtI ^ vtJ ;
+
+   double dMaxAbsCosPhi = 0 ;
+   double dCosPhiCorner = 0.7 ;
+
+   for ( int i = 0 ; i < nCompoElem ; ++ i) {
+
+      double dAbsCurrentCos = abs( CompoVert[i].vtNorm * vtK) ;
+
+      if ( dAbsCurrentCos > dCosPhiCorner) {
+      
+        // nI = i ;
+         dMaxAbsCosPhi = dAbsCurrentCos ;
+      } 
+   }
+
+   if ( dMaxAbsCosPhi <= dCosPhiCorner)
+      FeatureType = Edge ;
+   else 
+      FeatureType = Corner ;
+
+   return true ;
+}
+
 // ------------------------- VISUALIZZAZIONE --------------------------------------------------------------------------------------
 
 //----------------------------------------------------------------------------
@@ -36,12 +120,12 @@ VolZmap::GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) con
       return false ;
 
   // Verifiche sugli indici
-   if ( nPos1 < 0  ||  nPos1 >= int( m_nVNx[nDir])  ||  nPos2 < 0  ||  nPos2 >= int( m_nVNy[nDir]))
+   if ( nPos1 < 0  ||  nPos1 >= int( m_nNx[nDir])  ||  nPos2 < 0  ||  nPos2 >= int( m_nNy[nDir]))
       return false ;
 
-   int nPos = nPos1 + nPos2 * m_nVNx[nDir] ;
+   int nPos = nPos1 + nPos2 * m_nNx[nDir] ;
 
-   if ( nPos < 0  ||  nPos >= int( m_TriZValues[nDir].size()))
+   if ( nPos < 0  ||  nPos >= int( m_Values[nDir].size()))
       return false ;
 
   // Calcolo coordinate punto
@@ -52,12 +136,12 @@ VolZmap::GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) con
    Point3d ptP = m_MapFrame[nDir].Orig() + dX * m_MapFrame[nDir].VersX() + dY * m_MapFrame[nDir].VersY() ;
 
   // Creo le polilinee
-   for ( int j = 1 ; j < int( m_TriZValues[nDir][nPos].size()) ; j += 2) {
+   for ( int j = 1 ; j < int( m_Values[nDir][nPos].size()) ; j += 2) {
      // aggiungo polilinea a lista
       lstPL.emplace_back() ;
      // inserisco punti estremi
-      lstPL.back().AddUPoint( 0, ptP + m_TriZValues[nDir][nPos][j-1] * m_MapFrame[nDir].VersZ()) ;
-      lstPL.back().AddUPoint( 1, ptP + m_TriZValues[nDir][nPos][j] * m_MapFrame[nDir].VersZ()) ;
+      lstPL.back().AddUPoint( 0, ptP + m_Values[nDir][nPos][j-1].dZVal * m_MapFrame[nDir].VersZ()) ;
+      lstPL.back().AddUPoint( 1, ptP + m_Values[nDir][nPos][j].dZVal * m_MapFrame[nDir].VersZ()) ;
    }
    return true ;
 }
@@ -68,17 +152,86 @@ VolZmap::GetAllTriangles( TRIA3DLIST& lstTria) const
 {
    if ( m_nMapNum == 1) {
       const int MAX_DIM_CHUNK = 128 ;
-      for ( int i = 0 ; i < int( m_nVNx[0]) ; i += MAX_DIM_CHUNK) {
-         int nDimChunkX = min( MAX_DIM_CHUNK, int( m_nVNx[0]) - i) ;
-         for ( int j = 0 ; j < int( m_nVNy[0]) ; j += MAX_DIM_CHUNK) {
-            int nDimChunkY = min( MAX_DIM_CHUNK, int( m_nVNy[0]) - j) ;
+      for ( int i = 0 ; i < int( m_nNx[0]) ; i += MAX_DIM_CHUNK) {
+         int nDimChunkX = min( MAX_DIM_CHUNK, int( m_nNx[0]) - i) ;
+         for ( int j = 0 ; j < int( m_nNy[0]) ; j += MAX_DIM_CHUNK) {
+            int nDimChunkY = min( MAX_DIM_CHUNK, int( m_nNy[0]) - j) ;
+            GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, MAX_DIM_CHUNK, lstTria) ;
+         } 
+      }
+   }
+   //else  {
+   //
+   //   //std::vector <TriHolder> vecTria ;
+   //   //vecTria.resize( int( m_BlockToUpdate.size())) ;
+
+   //   //for ( int i = 0 ; i < int( m_BlockToUpdate.size()) ; ++ i) {
+   //   
+   //      //if ( m_BlockToUpdate[i])   
+   //        // ExtMarchingCubes( i, lstTria, vecTria[i]) ;    }
+
+   //   TriHolder triHold ;
+
+   //   ExtMarchingCubes( 0, lstTria, triHold) ;
+   //   FlipEdges( triHold) ;
+   //   
+   //   for ( int i = 0 ; i < int( triHold.size()) ; ++ i) 
+   //      for ( int j = 0 ; j < int( triHold[i].vecTria.size()) ; ++ j)    
+
+   //         lstTria.emplace_back( triHold[i].vecTria[j]) ;   
+   //}
+   
+   else
+      MarchingCubes( lstTria) ;
+
+   return true ;
+}   
+
+//----------------------------------------------------------------------------
+bool 
+VolZmap::GetBlockTriangles( int nBlock, TRIA3DLIST& lstTria) const
+{
+   if ( m_nMapNum == 1) {
+
+      const int MAX_DIM_CHUNK = 128 ;
+
+     // Calcolo posizione del blocco nella griglia
+      int nIBlock = nBlock % int( m_nFracLin[0]) ;
+      int nJBlock = nBlock / int( m_nFracLin[0]) ;
+
+     // Calcolo limiti per l'indice i
+      int nStartI = nIBlock * int( m_nDexNumPBlock) ;
+      int nEndI = ( nIBlock + 1 == int( m_nFracLin[0]) ? 
+                    int( m_nNx[0]) : ( nIBlock + 1) * int( m_nDexNumPBlock)) ;
+
+     // Calcolo limiti per l'indice j
+      int nStartJ = nJBlock * int( m_nDexNumPBlock) ;
+      int nEndJ = ( nJBlock + 1 == int( m_nFracLin[1]) ? 
+                    int( m_nNy[0]) : ( nJBlock + 1) * int( m_nDexNumPBlock)) ;
+
+     // Ciclo su i e j 
+      for ( int i = nStartI ; i < nEndI ; i += MAX_DIM_CHUNK) {
+         int nDimChunkX = min( MAX_DIM_CHUNK, nEndI - i) ;
+         for ( int j = nStartJ ; j < nEndJ ; j += MAX_DIM_CHUNK) {
+            int nDimChunkY = min( MAX_DIM_CHUNK, nEndJ - j) ;
             GetChunkPrisms( i, j, nDimChunkX, nDimChunkY, MAX_DIM_CHUNK, lstTria) ;
          } 
       }
    }
    else 
-      MarchingCubes( lstTria) ;
+      
+      //ExtMarchingCubes( nBlock, lstTria, triHold) ;
 
+      MarchingCubes( nBlock, lstTria) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+VolZmap::GetBlockInfo( std::vector<bool> & bModified) const
+{
+   bModified = m_BlockToUpdate ;
    return true ;
 }
 
@@ -92,16 +245,16 @@ VolZmap::GetChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, int nDimChk
    double dTopZ ;
    for ( int i = 0 ; i < nDim1 && bIsSimple ; ++ i) {
       for ( int j = 0 ; j < nDim2 && bIsSimple ; ++ j) {
-         int nPos = ( nPos1 + i) + ( nPos2 + j) * m_nVNx[0] ;
-         if ( nPos > int( m_nVDim[0])  ||
-              int( m_TriZValues[0][nPos].size()) != 2)
+         int nPos = ( nPos1 + i) + ( nPos2 + j) * m_nNx[0] ;
+         if ( nPos > int( m_nDim[0])  ||
+              int( m_Values[0][nPos].size()) != 2)
             bIsSimple = false ;  
          else if ( i == 0  &&  j == 0) {
-            dBotZ = m_TriZValues[0][nPos][0] ;
-            dTopZ = m_TriZValues[0][nPos][1] ;
+            dBotZ = m_Values[0][nPos][0].dZVal ;
+            dTopZ = m_Values[0][nPos][1].dZVal ;
          }
-         else if ( abs( m_TriZValues[0][nPos][0] - dBotZ) > EPS_SMALL  ||
-                   abs( m_TriZValues[0][nPos][1] - dTopZ) > EPS_SMALL)
+         else if ( abs( m_Values[0][nPos][0].dZVal - dBotZ) > EPS_SMALL  ||
+                   abs( m_Values[0][nPos][1].dZVal - dTopZ) > EPS_SMALL)
             bIsSimple = false ;  
       }
    }
@@ -138,10 +291,10 @@ bool
 VolZmap::CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST& lstTria) const
 {
   // verifiche sugli indici
-   if ( nPos1 < 0  ||  nPos1 + nDim1 > int( m_nVNx[0])  ||  nPos2 < 0  ||  nPos2 + nDim2 > int( m_nVNy[0]))
+   if ( nPos1 < 0  ||  nPos1 + nDim1 > int( m_nNx[0])  ||  nPos2 < 0  ||  nPos2 + nDim2 > int( m_nNy[0]))
       return false ;
-   int nPos = nPos1 + nPos2 * m_nVNx[0] ;
-   if ( nPos < 0  ||  nPos >= int( m_nVDim[0]))
+   int nPos = nPos1 + nPos2 * m_nNx[0] ;
+   if ( nPos < 0  ||  nPos >= int( m_nDim[0]))
       return false ;
 
   // calcolo coordinate punti
@@ -153,8 +306,8 @@ VolZmap::CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST
    Point3d ptP4 = ptP1 + nDim2 * m_dStep * m_MapFrame[0].VersY() ;
 
   // creo le facce sopra e sotto
-   Vector3d vtDZt = m_TriZValues[0][nPos][1] * m_MapFrame[0].VersZ() ;
-   Vector3d vtDZb = m_TriZValues[0][nPos][0] * m_MapFrame[0].VersZ() ;
+   Vector3d vtDZt = m_Values[0][nPos][1].dZVal * m_MapFrame[0].VersZ() ;
+   Vector3d vtDZb = m_Values[0][nPos][0].dZVal * m_MapFrame[0].VersZ() ;
    // faccia superiore P1t->P2t->P3t->P4t : sempre visibile
    lstTria.emplace_back() ;
    lstTria.back().Set( ptP1 + vtDZt, ptP2 + vtDZt, ptP3 + vtDZt, m_MapFrame[0].VersZ()) ;
@@ -168,21 +321,21 @@ VolZmap::CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST
 
   // creo le facce laterali
    for ( int j = 0 ; j < nDim2 ; ++ j) {
-      int nPosD = nPos + nDim1 - 1 + j * m_nVNx[0] ;
-      int nPosEst = ( nPos1 + nDim1 - 1 < int( m_nVNx[0] - 1) ? nPosD + 1 : - 1) ;
+      int nPosD = nPos + nDim1 - 1 + j * m_nNx[0] ;
+      int nPosEst = ( nPos1 + nDim1 - 1 < int( m_nNx[0] - 1) ? nPosD + 1 : - 1) ;
       Point3d ptP2D = ptP2 + j * m_dStep * m_MapFrame[0].VersY() ;
       Point3d ptP3D = ptP2D + m_dStep * m_MapFrame[0].VersY() ;
       AddDexelSideFace( nPosD, nPosEst, ptP2D, ptP3D, m_MapFrame[0].VersZ(), m_MapFrame[0].VersX(), lstTria) ;
    }
    for ( int i = 0 ; i < nDim1 ; ++ i) {
-      int nPosD = nPos + ( nDim2 - 1) * m_nVNx[0] + i ;
-      int nPosNord = ( nPos2 + nDim2 - 1 < int( m_nVNy[0] - 1) ? nPosD + m_nVNx[0] : - 1) ;
+      int nPosD = nPos + ( nDim2 - 1) * m_nNx[0] + i ;
+      int nPosNord = ( nPos2 + nDim2 - 1 < int( m_nNy[0] - 1) ? nPosD + m_nNx[0] : - 1) ;
       Point3d ptP4D = ptP4 + i * m_dStep * m_MapFrame[0].VersX() ;
       Point3d ptP3D = ptP4D + m_dStep * m_MapFrame[0].VersX() ;
       AddDexelSideFace( nPosD, nPosNord, ptP3D, ptP4D, m_MapFrame[0].VersZ(), m_MapFrame[0].VersY(), lstTria) ;
    }
    for ( int j = 0 ; j < nDim2 ; ++ j) {
-      int nPosD = nPos + j * m_nVNx[0] ;
+      int nPosD = nPos + j * m_nNx[0] ;
       int nPosWest = ( nPos1 > 0 ? nPosD - 1 : - 1) ;
       Point3d ptP1D = ptP1 + j * m_dStep * m_MapFrame[0].VersY() ;
       Point3d ptP4D = ptP1D + m_dStep * m_MapFrame[0].VersY() ;
@@ -190,7 +343,7 @@ VolZmap::CalcChunkPrisms( int nPos1, int nPos2, int nDim1, int nDim2, TRIA3DLIST
    }
    for ( int i = 0 ; i < nDim1 ; ++ i) {
       int nPosD = nPos + i ;
-      int nPosSud = ( nPos2 > 0 ? nPosD - m_nVNx[0] : - 1) ;
+      int nPosSud = ( nPos2 > 0 ? nPosD - m_nNx[0] : - 1) ;
       Point3d ptP1D = ptP1 + i * m_dStep * m_MapFrame[0].VersX() ;
       Point3d ptP2D = ptP1D + m_dStep * m_MapFrame[0].VersX() ;
       AddDexelSideFace( nPosD, nPosSud, ptP1D, ptP2D, m_MapFrame[0].VersZ(), - m_MapFrame[0].VersY(), lstTria) ;
@@ -204,10 +357,10 @@ bool
 VolZmap::CalcDexelPrisms( int nPos1, int nPos2, TRIA3DLIST& lstTria) const
 {
   // verifiche sugli indici
-   if ( nPos1 < 0  ||  nPos1 >= int( m_nVNx[0])  ||  nPos2 < 0  ||  nPos2 >= int( m_nVNy[0]))
+   if ( nPos1 < 0  ||  nPos1 >= int( m_nNx[0])  ||  nPos2 < 0  ||  nPos2 >= int( m_nNy[0]))
       return false ;
-   int nPos = nPos1 + nPos2 * m_nVNx[0] ;
-   if ( nPos < 0  ||  nPos >= int( m_nVDim[0]))
+   int nPos = nPos1 + nPos2 * m_nNx[0] ;
+   if ( nPos < 0  ||  nPos >= int( m_nDim[0]))
       return false ;
 
   // calcolo coordinate punto
@@ -219,9 +372,9 @@ VolZmap::CalcDexelPrisms( int nPos1, int nPos2, TRIA3DLIST& lstTria) const
    Point3d ptP4 = ptP1 + m_dStep * m_MapFrame[0].VersY() ;
 
   // creo le facce sopra e sotto di ogni intervallo (sempre visibili)
-   for ( int i = 1 ; i < int( m_TriZValues[0][nPos].size()) ; i += 2) {
-      Vector3d vtDZt = m_TriZValues[0][nPos][i] * m_MapFrame[0].VersZ() ;
-      Vector3d vtDZb = m_TriZValues[0][nPos][i-1] * m_MapFrame[0].VersZ() ;
+   for ( int i = 1 ; i < int( m_Values[0][nPos].size()) ; i += 2) {
+      Vector3d vtDZt = m_Values[0][nPos][i].dZVal * m_MapFrame[0].VersZ() ;
+      Vector3d vtDZb = m_Values[0][nPos][i-1].dZVal * m_MapFrame[0].VersZ() ;
      // faccia superiore P1t->P2t->P3t->P4t : sempre visibile
       lstTria.emplace_back() ;
       lstTria.back().Set( ptP1 + vtDZt, ptP2 + vtDZt, ptP3 + vtDZt, m_MapFrame[0].VersZ()) ;
@@ -235,13 +388,13 @@ VolZmap::CalcDexelPrisms( int nPos1, int nPos2, TRIA3DLIST& lstTria) const
    }
 
   // creo le facce laterali
-   int nPosEst = ( nPos1 < int( m_nVNx[0] - 1) ? nPos + 1 : - 1) ;
+   int nPosEst = ( nPos1 < int( m_nNx[0] - 1) ? nPos + 1 : - 1) ;
    AddDexelSideFace( nPos, nPosEst, ptP2, ptP3, m_MapFrame[0].VersZ(), m_MapFrame[0].VersX(), lstTria) ;
-   int nPosNord = ( nPos2 < int( m_nVNy[0] - 1) ? nPos + m_nVNx[0] : - 1) ;
+   int nPosNord = ( nPos2 < int( m_nNy[0] - 1) ? nPos + m_nNx[0] : - 1) ;
    AddDexelSideFace( nPos, nPosNord, ptP3, ptP4, m_MapFrame[0].VersZ(), m_MapFrame[0].VersY(), lstTria) ;
    int nPosWest = ( nPos1 > 0 ? nPos - 1 : - 1) ;
    AddDexelSideFace( nPos, nPosWest, ptP4, ptP1, m_MapFrame[0].VersZ(), - m_MapFrame[0].VersX(), lstTria) ;
-   int nPosSud = ( nPos2 > 0 ? nPos - m_nVNx[0] : - 1) ;
+   int nPosSud = ( nPos2 > 0 ? nPos - m_nNx[0] : - 1) ;
    AddDexelSideFace( nPos, nPosSud, ptP1, ptP2, m_MapFrame[0].VersZ(), - m_MapFrame[0].VersY(), lstTria) ;
 
    return true ;
@@ -253,11 +406,11 @@ VolZmap::AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Poin
                            const Vector3d& vtZ, const Vector3d& vtNorm, TRIA3DLIST& lstTria) const
 {
    Intervals intFace ;
-   for ( int i = 1 ; i < int( m_TriZValues[0][nPos].size()) ; i += 2)
-       intFace.Add( m_TriZValues[0][nPos][i-1], m_TriZValues[0][nPos][i]) ;
+   for ( int i = 1 ; i < int( m_Values[0][nPos].size()) ; i += 2)
+       intFace.Add( m_Values[0][nPos][i-1].dZVal, m_Values[0][nPos][i].dZVal) ;
    if ( nPosAdj > 0) {
-      for ( int i = 1 ; i < int( m_TriZValues[0][nPosAdj].size()) ; i += 2)
-          intFace.Subtract( m_TriZValues[0][nPosAdj][i-1], m_TriZValues[0][nPosAdj][i]) ;
+      for ( int i = 1 ; i < int( m_Values[0][nPosAdj].size()) ; i += 2)
+          intFace.Subtract( m_Values[0][nPosAdj][i-1].dZVal, m_Values[0][nPosAdj][i].dZVal) ;
    }
    double dMin, dMax ;
    bool bFound = intFace.GetFirst( dMin, dMax) ;
@@ -273,52 +426,17 @@ VolZmap::AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Poin
    return true ;
 }
 
-
-/*
 //----------------------------------------------------------------------------
 bool 
-VolZmap::MarchingCubes( TRIA3DLIST& lstTria) 
+VolZmap::MarchingCubes( TRIA3DLIST& lstTria) const 
 {
-  // Limiti superiori sui tre indici
-   unsigned int nLimI = m_nVNx[0] ;
-   unsigned int nLimJ = m_nVNy[0] ;
-   unsigned int nLimK = m_nVNy[1] ;
-
-   struct Corner {
-   
-      int nCornerNumber ;
-      unsigned int nI, nJ, nK ;
-   } ;
-
   // Ciclo su tutti i voxel dello Zmap
-   for ( unsigned int k = 0 ; k < nLimK ; ++ k) {
-      for ( unsigned int i = 0 ; i < nLimI ; ++ i) {
-         for ( unsigned int j = 0 ; j < nLimJ ; ++ j) {       
-         }    
-      }
-   }
-   return true ;
-}
-*/
-
-/*
-//----------------------------------------------------------------------------
-bool 
-VolZmap::MarchingCubes( TRIA3DLIST& lstTria) 
-{
-   unsigned int nLimI = m_nVNx[0] ;
-   unsigned int nLimJ = m_nVNy[0] ;
-   unsigned int nLimK = m_nVNy[1] ;
-
-
-  // Ciclo su tutti i voxel dello Zmap
-   for ( unsigned int k = 0 ; k < nLimK ; ++ k) {
-      for ( unsigned int i = 0 ; i < nLimI ; ++ i) {
-         for ( unsigned int j = 0 ; j < nLimJ ; ++ j) {
+   for ( int i = - 1 ; i < int( m_nNx[0]) ; ++ i) {
+      for ( int j = - 1 ; j < int( m_nNy[0]) ; ++ j) {
+         for ( int k = - 1 ; k < int( m_nNy[1]) ; ++ k) {  
 
            // Indici i,j,k dei vertici
             int IndexCorner[8][3] = {
-            
                { i, j, k}, 
                { i + 1, j, k}, 
                { i + 1, j + 1, k}, 
@@ -327,328 +445,114 @@ VolZmap::MarchingCubes( TRIA3DLIST& lstTria)
                { i + 1, j, k + 1}, 
                { i + 1, j + 1, k + 1}, 
                { i, j + 1, k + 1} 
-            } ;
-
-            int nIndex = 0 ;
-
-            bool CornerTF[8] = { false, false, false, false, 
-                                 false, false, false, false,} ;
-
+            } ;  
+            
            // Classificazione dei vertici: interni o esterni al materiale 
-            if ( IsThereMat( i, j, k)) {
+            int nIndex = 0 ;
+            if ( IsThereMat( i, j, k)) 
                nIndex |= ( 1 << 0) ;
-               CornerTF[0] = true ;
-            }
-            if ( IsThereMat( i + 1, j, k)) {
+            if ( IsThereMat( i + 1, j, k)) 
                nIndex |= ( 1 << 1) ;
-               CornerTF[1] = true ;
-            }
-            if ( IsThereMat( i + 1, j + 1, k)) {
+            if ( IsThereMat( i + 1, j + 1, k)) 
                nIndex |= ( 1 << 2) ;
-               CornerTF[2] = true ;
-            }
-            if ( IsThereMat( i, j + 1, k)) {
+            if ( IsThereMat( i, j + 1, k)) 
                nIndex |= ( 1 << 3) ;
-               CornerTF[3] = true ;
-            }
-            if ( IsThereMat( i, j, k + 1)) {
+            if ( IsThereMat( i, j, k + 1)) 
                nIndex |= ( 1 << 4) ;
-               CornerTF[4] = true ;
-            }
-            if ( IsThereMat( i + 1, j, k + 1)) {
+            if ( IsThereMat( i + 1, j, k + 1)) 
                nIndex |= ( 1 << 5) ;
-               CornerTF[5] = true ;
-            }
-            if ( IsThereMat( i + 1, j + 1, k + 1)) {
+            if ( IsThereMat( i + 1, j + 1, k + 1)) 
                nIndex |= ( 1 << 6) ;
-               CornerTF[6] = true ;
-            }
-            if ( IsThereMat( i, j + 1, k + 1)) {
-               nIndex |= ( 1 << 7) ;
-               CornerTF[7] = true ;
-            }
-
+            if ( IsThereMat( i, j + 1, k + 1)) 
+               nIndex |= ( 1 << 7) ; 
+         
            // Se vi è qualche intersezione fra segmenti e superficie
            // continuo altrimenti passo al prossimo voxel 
-            if ( EdgeTable[nIndex] != 0) {
+            if ( EdgeTable[nIndex] == 0) 
+               continue ;
 
-               static int intersections[12][2] = {
+            static int intersections[12][2] = {
+               { 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 0 }, { 4, 5 }, { 5, 6 },
+               { 6, 7 }, { 7, 4 }, { 0, 4 }, { 1, 5 }, { 2, 6 }, { 3, 7 }
+            } ;
 
-                  { 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 0 }, { 4, 5 }, { 5, 6 },
-                  { 6, 7 }, { 7, 4 }, { 0, 4 }, { 1, 5 }, { 2, 6 }, { 3, 7 }
-               } ;
+            Point3d ptIntPoint[12] ;
 
-               Point3d ptIntPoint[12] ;
+           // Ciclo sui segmenti
+            for ( int EdgeIndex = 0 ; EdgeIndex < 12 ; ++ EdgeIndex) {
+              // Se il segmento non attraversa la superficie 
+              // passo al successivo
+               if ( ! ( EdgeTable[nIndex] & ( 1 << EdgeIndex)))
+                  continue ;
 
-              // Ciclo sui segmenti
-               for ( int i = 0 ; i < 12 ; ++ i) {
-                 // Se il segmento non attraversa la superficie 
-                 // passo al successivo
-                  if ( ! ( EdgeTable[nIndex] & ( 1 << i)))
-                     continue ;
+               int n1 = intersections[EdgeIndex][0] ;
+               int n2 = intersections[EdgeIndex][1] ;    
 
-                  int n1 = intersections[i][0];
-                  int n2 = intersections[i][1];
+              // Determino con precisione il punto di intersezione sullo spigolo
+               IntersPos( IndexCorner[n1], IndexCorner[n2], ptIntPoint[EdgeIndex]) ;
+              
+               ptIntPoint[EdgeIndex].ToGlob( m_MapFrame[0]) ;
+            }
 
-                 // Determino con precisione il punto di intersezione sullo spigolo
-                  IntersPos( IndexCorner[n1], IndexCorner[n2], ptIntPoint[i]) ;                 
-               }
+           // Costruzione dei triangoli
+            for ( int TriIndex = 0 ; TriangleTableEn[nIndex][0][TriIndex] != - 1 ; TriIndex += 3) {
 
-              // Costruzione dei triangoli
-               for ( int i = 0 ; TriangleTable[nIndex][i] != - 1 ; ++ i) {
+              // Costruzione triangolo
+               int i0 = TriangleTableEn[nIndex][0][TriIndex + 2] ;
+               int i1 = TriangleTableEn[nIndex][0][TriIndex + 1] ;
+               int i2 = TriangleTableEn[nIndex][0][TriIndex] ;
 
-                 // Costruzione triangolo
-                  int i0 = TriangleTable[nIndex][i] ;
-                  int i1 = TriangleTable[nIndex][i+1] ;
-                  int i2 = TriangleTable[nIndex][i+2] ;
+              // Il triangolo è pronto    
+               Triangle3d CurrentTriangle ;
+               CurrentTriangle.Set( ptIntPoint[i0], ptIntPoint[i1], ptIntPoint[i2]) ;
+               CurrentTriangle.Validate() ;
 
-                  Triangle3d CurrentTriangle ;
-       
-                  Vector3d vtV1 = ptIntPoint[i1] - ptIntPoint[i0] ;
-                  Vector3d vtV2 = ptIntPoint[i2] - ptIntPoint[i0] ;
-                  Vector3d vtN = vtV1 ^ vtV2 ;
-
-                  vtN.Normalize() ;
-
-                  int nCorner = intersections[i0][0] ;
-
-                  Point3d ptCorner( IndexCorner[nCorner][0] * m_dStep, 
-                                    IndexCorner[nCorner][1] * m_dStep,
-                                    IndexCorner[nCorner][2] * m_dStep) ;
-
-                  Vector3d vtT = ptCorner - ptIntPoint[i0] ;
-
-                  vtT.Normalize() ;
-
-                  if ( CornerTF[nCorner]) {
-                     if ( vtN * vtT < 0)
-                        vtN = - vtN ;
-                  }
-                  else {
-                     if ( vtN * vtT > 0)
-                        vtN = - vtN ;
-                  }*/
-
-                  /*
-                  oppure:
-                  if( nIndex & ( 1 << nCorner)) {
-                     if( vtN * vtT < 0)
-                  }
-                  else {
-                     if ( vtN * vtT > 0)
-                        vtN = - vtN ;
-                  }
-                  */  /*
-
-                  CurrentTriangle.Set( ptIntPoint[i0], ptIntPoint[i1], ptIntPoint[i2], vtN) ;
-
-                 // Aggiungo triangolo
-                  lstTria.emplace_back( CurrentTriangle) ;   
-               }
+              // Aggiungo triangolo
+               lstTria.emplace_back( CurrentTriangle) ;   
             }
          }
       }
    }
+
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::IsThereMat( unsigned int nI, unsigned int nJ, unsigned int nK)
-{
-   double dZ[3] ; 
-
-   dZ[0] = ( nI + 0.5) * m_dStep ;
-   dZ[1] = ( nK + 0.5) * m_dStep ;
-   dZ[2] = ( nJ + 0.5) * m_dStep ;
-   
-   int nCount = 0 ;
-
-   for ( int nGrid = 0 ; nGrid < int ( m_nMapNum) ; ++ nGrid) {
-
-      unsigned int nGrI, nGrJ ;
-      
-      if ( nGrid == 0) {
-         nGrI = nI ;
-         nGrJ = nJ ; 
-      } 
-      else if ( nGrid == 1) {  
-         nGrI = nJ ;
-         nGrJ = nK ;
-      }
-      else {     
-         nGrI = nK ;
-         nGrJ = nI ;
-      }
-
-      unsigned int nPos = nGrJ * m_nVNx[nGrid] + nGrI ;
-      unsigned int nDexSize = m_TriZValues[nGrid][nPos].size() ;
-      unsigned int nIndex = 0 ;   
-        
-      while ( nIndex < nDexSize) {
-
-         if ( dZ[nGrid] > m_TriZValues[nGrid][nPos][nIndex] + EPS_SMALL ||
-              dZ[nGrid] < m_TriZValues[nGrid][nPos][nIndex + 1] - EPS_SMALL) {
-         
-            ++ nCount ;
-            break ;
-         } 
-         ++ nIndex ;
-      }   
-   }
-
-   if ( nCount > 1)
-      return true ;
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-VolZmap::IntersPos( int nVec1[], int nVec2[], Point3d & ptInt) {
-
-   if ( nVec1[0] != nVec2[0]) {
-
-      int nMinI = min( nVec1[0], nVec2[0]) ;
-      int nMaxI = max( nVec1[0], nVec2[0]) ;
-      
-      double dMinX = nMinI * m_dStep ;
-      double dMaxX = nMaxI * m_dStep ;
-
-      unsigned int nDexel = nVec1[2] * m_nVNx[1] + nVec1[1] ;
-      unsigned int nSize = m_TriZValues[1][nDexel].size() ;
-
-      ptInt.y = nVec1[1] * m_dStep ;
-      ptInt.z = nVec1[2] * m_dStep ;
-
-      for ( unsigned int i = 0 ; i < nSize ; i += 2) {
-      
-         double dx1 = m_TriZValues[1][nDexel][i] ;
-         double dx2 = m_TriZValues[1][nDexel][i+1] ; 
-
-         if ( dx1 < dMinX && dx2 > dMinX && dx2 < dMaxX) {
-         
-            ptInt.x = dx2 ;
-            break ;
-         }
-         else if ( dx1 > dMinX && dx1 < dMaxX && dx2 > dMaxX) {
-         
-            ptInt.x = dx1 ;
-            break ;
-         }
-      }                   
-   }
-   else if ( nVec1[1] != nVec2[1]) {
-
-      int nMinJ = min( nVec1[1], nVec2[1]) ;
-      int nMaxJ = max( nVec1[1], nVec2[1]) ;
-      
-      double dMinY = nMinJ * m_dStep ;
-      double dMaxY = nMaxJ * m_dStep ;
-
-      unsigned int nDexel = nVec1[2] * m_nVNx[2] + nVec1[0] ;
-      unsigned int nSize = m_TriZValues[2][nDexel].size() ;
-
-      ptInt.x = nVec1[0] * m_dStep ;
-      ptInt.z = nVec1[2] * m_dStep ;
-
-      for ( unsigned int j = 0 ; j < nSize ; j += 2) {
-      
-         double dy1 = m_TriZValues[2][nDexel][j] ;
-         double dy2 = m_TriZValues[2][nDexel][j+1] ; 
-
-         if ( dy1 < dMinY && dy2 > dMinY && dy2 < dMaxY) {
-         
-            ptInt.y = dy2 ;
-            break ;
-         }
-         else if ( dy1 > dMinY && dy1 < dMaxY && dy2 > dMaxY) {
-         
-            ptInt.y = dy1 ;
-            break ;
-         }
-      }                     
-   }  
-   else if ( nVec1[2] != nVec2[2]) {
-
-      int nMinK = min( nVec1[2], nVec2[2]) ;
-      int nMaxK = max( nVec1[2], nVec2[2]) ;
-      
-      double dMinZ = nMinK * m_dStep ;
-      double dMaxZ = nMaxK * m_dStep ;
-
-      unsigned int nDexel = nVec1[1] * m_nVNx[0] + nVec1[0] ;
-      unsigned int nSize = m_TriZValues[0][nDexel].size() ;
-
-      ptInt.x = nVec1[0] * m_dStep ;
-      ptInt.y = nVec1[1] * m_dStep ;
-
-      for ( unsigned int k = 0 ; k < nSize ; k += 2) {
-      
-         double dz1 = m_TriZValues[0][nDexel][k] ;
-         double dz2 = m_TriZValues[0][nDexel][k+1] ; 
-
-         if ( dz1 < dMinZ && dz2 > dMinZ && dz2 < dMaxZ) {
-         
-            ptInt.z = dz2 ;
-            break ;
-         }
-         else if ( dz1 > dMinZ && dz1 < dMaxZ && dz2 > dMaxZ) {
-         
-            ptInt.z = dz1 ;
-            break ;
-         }
-      }                       
-   }
-   return true ;
-}  */
-
-// Prova 
-
-bool function( const Vector3d & vtV)
-{
-   if ( 100 - vtV * vtV < 0)
-      return true ;
-   return false ;
-}
-
-bool midpoint( int nVec1[], int nVec2[], Point3d & ptInt, double dStep) 
-{
-   Point3d pt1( ( nVec1[0] + 0.5) * dStep,
-                ( nVec1[1] + 0.5) * dStep,
-                ( nVec1[2] + 0.5) * dStep) ;
-
-   Point3d pt2( ( nVec2[0] + 0.5) * dStep,
-                ( nVec2[1] + 0.5) * dStep,
-                ( nVec2[2] + 0.5) * dStep) ; 
-                
-                 
-   ptInt = pt1 + 0.5 * ( pt2 - pt1) ;
-             
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool 
-VolZmap::MarchingCubes( TRIA3DLIST& lstTria) const 
+VolZmap::MarchingCubes( int nBlock, TRIA3DLIST& lstTria) const
 {
+   if ( nBlock < 0 || nBlock >= int( m_BlockToUpdate.size()))
+      return false ;
 
    Point3d ptMapOrig = m_MapFrame[0].Orig() ;
 
-   int nLimI = int( m_nVNx[0]) ;
-   int nLimJ = int( m_nVNy[0]) ;
-   int nLimK = int( m_nVNy[1]) ;
+  // Calcolo posizione del blocco nel reticolo 
+   int nIBlock = ( nBlock % int( m_nFracLin[0] * m_nFracLin[1])) % int( m_nFracLin[0]) ;
+   int nJBlock = ( nBlock % int( m_nFracLin[0] * m_nFracLin[1])) / int( m_nFracLin[0]) ;
+   int nKBlock = ( nBlock / int( m_nFracLin[0] * m_nFracLin[1])) ;
+
+  // Calcolo limiti per l'indice i
+   int nStartI = nIBlock * int( m_nDexNumPBlock) - 1 ; //( nIBlock > 0 ? nIBlock * int( m_nDexNumPBlock) : - 1) ;
+   int nEndI =   ( nIBlock + 1 == int( m_nFracLin[0]) ? 
+                   int( m_nNx[0]) : ( nIBlock + 1) * int( m_nDexNumPBlock)) ;
+
+  // Calcolo limiti per l'indice j
+   int nStartJ = nJBlock * int( m_nDexNumPBlock) - 1 ; //( nJBlock > 0 ? nJBlock * int( m_nDexNumPBlock) : - 1) ;
+   int nEndJ =   ( nJBlock + 1 == int( m_nFracLin[1]) ? 
+                   int( m_nNy[0]) : ( nJBlock + 1) * int( m_nDexNumPBlock)) ;
+
+  // Calcolo limiti per l'indice k
+   int nStartK = nKBlock * int( m_nDexNumPBlock) - 1 ; //( nKBlock > 0 ? nKBlock * int( m_nDexNumPBlock) : - 1) ;
+   int nEndK =   ( nKBlock + 1 == int( m_nFracLin[2]) ? 
+                   int( m_nNy[1]) : ( nKBlock + 1) * int( m_nDexNumPBlock)) ;
+
 
-  
   // Ciclo su tutti i voxel dello Zmap
-   for ( int i = - 1 ; i < nLimI ; ++ i) {
-      for ( int j = - 1 ; j < nLimJ ; ++ j) {
-         for ( int k = - 1 ; k < nLimK ; ++ k) {  
-
-            if ( i == 0 && j == 6 && k == 8) {
-            
-               double bau = 1 ;
-            }
+   for ( int i = nStartI ; i < nEndI ; ++ i) {
+      for ( int j = nStartJ ; j < nEndJ ; ++ j) {
+         for ( int k = nStartK ; k < nEndK ; ++ k) {  
 
+          
            // Indici i,j,k dei vertici
             int IndexCorner[8][3] = {
             
@@ -716,20 +620,17 @@ VolZmap::MarchingCubes( TRIA3DLIST& lstTria) const
 
               // Determino con precisione il punto di intersezione sullo spigolo
                IntersPos( IndexCorner[n1], IndexCorner[n2], ptIntPoint[EdgeIndex]) ;
-              // midpoint( IndexCorner[n1], IndexCorner[n2], ptIntPoint[EdgeIndex], m_dStep) ;
-
-               ptIntPoint[EdgeIndex] = ptIntPoint[EdgeIndex] ;
-
+                           
                ptIntPoint[EdgeIndex].ToGlob( m_MapFrame[0]) ;
             }
 
            // Costruzione dei triangoli
-            for ( int TriIndex = 0 ; TriangleTable[nIndex][TriIndex] != - 1 ; TriIndex += 3) {
+            for ( int TriIndex = 0 ; TriangleTableEn[nIndex][0][TriIndex] != - 1 ; TriIndex += 3) {
 
               // Costruzione triangolo
-               int i0 = TriangleTable[nIndex][TriIndex + 2] ;
-               int i1 = TriangleTable[nIndex][TriIndex + 1] ;
-               int i2 = TriangleTable[nIndex][TriIndex] ;
+               int i0 = TriangleTableEn[nIndex][0][TriIndex + 2] ;
+               int i1 = TriangleTableEn[nIndex][0][TriIndex + 1] ;
+               int i2 = TriangleTableEn[nIndex][0][TriIndex] ;
 
                Triangle3d CurrentTriangle ;
                   
@@ -748,6 +649,502 @@ VolZmap::MarchingCubes( TRIA3DLIST& lstTria) const
          }
       }
    }
+          
+   m_BlockToUpdate[nBlock] = false ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool 
+VolZmap::ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold) const
+{
+
+   if ( nBlock < 0 || nBlock >= int( m_BlockToUpdate.size()))
+      return false ;
+
+   Point3d ptMapOrig = m_MapFrame[0].Orig() ;
+
+  // Calcolo posizione del blocco nel reticolo 
+   int nIBlock = ( nBlock % int( m_nFracLin[0] * m_nFracLin[1])) % int( m_nFracLin[0]) ;
+   int nJBlock = ( nBlock % int( m_nFracLin[0] * m_nFracLin[1])) / int( m_nFracLin[0]) ;
+   int nKBlock = ( nBlock / int( m_nFracLin[0] * m_nFracLin[1])) ;
+
+  // Calcolo limiti per l'indice i
+   int nStartI = nIBlock * int( m_nDexNumPBlock) - 1 ; 
+   int nEndI =   ( nIBlock + 1 == int( m_nFracLin[0]) ? 
+                   int( m_nNx[0]) : ( nIBlock + 1) * int( m_nDexNumPBlock)) ;
+
+  // Calcolo limiti per l'indice j
+   int nStartJ = nJBlock * int( m_nDexNumPBlock) - 1 ; 
+   int nEndJ =   ( nJBlock + 1 == int( m_nFracLin[1]) ? 
+                   int( m_nNy[0]) : ( nJBlock + 1) * int( m_nDexNumPBlock)) ;
+
+  // Calcolo limiti per l'indice k
+   int nStartK = nKBlock * int( m_nDexNumPBlock) - 1 ; 
+   int nEndK =   ( nKBlock + 1 == int( m_nFracLin[2]) ? 
+                   int( m_nNy[1]) : ( nKBlock + 1) * int( m_nDexNumPBlock)) ;
+
+
+  // Ciclo su tutti i voxel dello Zmap
+   for ( int i = nStartI ; i < nEndI ; ++ i) {
+      for ( int j = nStartJ ; j < nEndJ ; ++ j) {
+         for ( int k = nStartK ; k < nEndK ; ++ k) {  
+
+          
+           // Indici i,j,k dei vertici
+            int IndexCorner[8][3] = {
+            
+               { i, j, k}, 
+               { i + 1, j, k}, 
+               { i + 1, j + 1, k}, 
+               { i, j + 1, k}, 
+               { i, j, k + 1}, 
+               { i + 1, j, k + 1}, 
+               { i + 1, j + 1, k + 1}, 
+               { i, j + 1, k + 1} 
+            } ;  
+            
+  
+            int nIndex = 0 ;
+            
+           // Classificazione dei vertici: interni o esterni al materiale 
+            if ( IsThereMat( i, j, k))              nIndex |= ( 1 << 0) ;                        
+            if ( IsThereMat( i + 1, j, k))          nIndex |= ( 1 << 1) ;                          
+            if ( IsThereMat( i + 1, j + 1, k))      nIndex |= ( 1 << 2) ;                          
+            if ( IsThereMat( i, j + 1, k))          nIndex |= ( 1 << 3) ;                          
+            if ( IsThereMat( i, j, k + 1))          nIndex |= ( 1 << 4) ;                           
+            if ( IsThereMat( i + 1, j, k + 1))      nIndex |= ( 1 << 5) ;                          
+            if ( IsThereMat( i + 1, j + 1, k + 1))  nIndex |= ( 1 << 6) ;                            
+            if ( IsThereMat( i, j + 1, k + 1))      nIndex |= ( 1 << 7) ; 
+                                   
+           // Se vi è qualche intersezione fra segmenti e superficie
+           // continuo altrimenti passo al prossimo voxel 
+            if ( EdgeTable[nIndex] == 0) 
+               continue ;
+
+            static int intersections[12][2] = {
+
+               { 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 0 }, { 4, 5 }, { 5, 6 },
+               { 6, 7 }, { 7, 4 }, { 0, 4 }, { 1, 5 }, { 2, 6 }, { 3, 7 }
+            } ;
+
+           // Arrey di strutture punto di intersezione 
+           // e normale alla superficie in esso.
+            VectorField VecField[12] ;
+       
+           // Ciclo sui segmenti
+            for ( int EdgeIndex = 0 ; EdgeIndex < 12 ; ++ EdgeIndex) {
+              // Se il segmento non attraversa la superficie 
+              // passo al successivo
+               if ( ! ( EdgeTable[nIndex] & ( 1 << EdgeIndex)))
+                  continue ;
+
+               int n1 = intersections[EdgeIndex][0] ;
+               int n2 = intersections[EdgeIndex][1] ;    
+
+              // Determino con precisione il punto di intersezione sullo spigolo
+               IntersPos( IndexCorner[n1], IndexCorner[n2], 
+                          VecField[EdgeIndex].ptInt,
+                          VecField[EdgeIndex].vtNorm) ;
+                            
+               VecField[EdgeIndex].ptInt.ToGlob( m_MapFrame[0]) ;
+               VecField[EdgeIndex].vtNorm.ToGlob( m_MapFrame[0]) ;
+            }
+
+           // Determino il numero di componenti connesse 
+            int nComponents = TriangleTableEn[nIndex][1][0] ;
+
+           // Serve nel ciclo che salva i punti e vettori di 
+           // una componente nell'arrey di compentenza: La tabella 
+           // fornisce numero di componenti, numero di vertici per 
+           // componenti per OGNUNA delle componenti e in fine 
+           // elenca i vertici della prima componente, seguiti da quelli
+           // della seconda e così via.
+            int nTableOffset = nComponents ;
+
+           // Ciclo sulle componenti
+            for ( int nCompCount = 1 ; nCompCount <= nComponents ; ++ nCompCount) {
+            
+              // Numero vertici per componenti
+               int nVertComp = TriangleTableEn[nIndex][1][nCompCount] ;
+
+              // Vettore di Vector3d 
+               VectorField CompoVert[12] ;
+
+              // Riempio il vettore  
+               for ( int nVertCount = 0 ; nVertCount < nVertComp ; ++ nVertCount) 
+                 // Nota che il primo elemento dell'arrey 
+                 // (0-esimo) non viene iniziallizzato
+                  CompoVert[nVertCount] = VecField[TriangleTableEn[nIndex][1][nVertCount + nTableOffset + 1]] ;
+
+               int nFeatureType ;
+
+              // Valuto le relazioni reciproche fra le normali
+               bool bExt = TestOnNormal( CompoVert, nVertComp, nFeatureType) ;
+
+              // Extended MC
+               if ( bExt)  {
+
+                 // Ridimensiono il vettore che contiene i 
+                  triHold.resize( triHold.size() + 1) ;
+
+                  int nCurrent = int( triHold.size()) - 1 ;
+
+                  triHold[nCurrent].i = i ;
+                  triHold[nCurrent].j = j ;
+                  triHold[nCurrent].k = k ;
+
+                  Point3d ptGravityCenter( 0, 0, 0) ;
+
+                  for ( int i = 0 ; i < nVertComp ; ++ i) 
+
+                     ptGravityCenter += CompoVert[i].ptInt ;
+
+                  ptGravityCenter /= nVertComp ;
+
+                  Vector3d vtO = ptGravityCenter - ORIG ;
+
+                  Point3d ptTrasf[12] ;
+
+                  for ( int i = 0 ; i < nVertComp ; ++ i) 
+
+                     ptTrasf[i] = CompoVert[i].ptInt - vtO ;
+
+                  typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> dSystemMatrix ;
+                  typedef Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic> dSystemVector ;
+
+                  dSystemMatrix dMatrixN ;
+                  dSystemVector dKnownVector ;
+                  dSystemVector dUnknownVector ;
+
+                  dMatrixN.resize( nVertComp, 3) ;
+                  dKnownVector.resize( nVertComp, 1) ;
+                  
+                  for ( int i = 0 ; i < nVertComp ; ++ i) {
+                  
+                      dMatrixN( i, 0) = CompoVert[i].vtNorm.x ;
+                      dMatrixN( i, 1) = CompoVert[i].vtNorm.y ;
+                      dMatrixN( i, 2) = CompoVert[i].vtNorm.z ;
+
+                      dKnownVector( i) = CompoVert[i].vtNorm * ( ptTrasf[i] - ORIG) ;
+                  }
+
+                  typedef Eigen::JacobiSVD<dSystemMatrix> DecomposerSVD ;
+
+#define ComputeU Eigen::ComputeThinU
+#define ComputeV Eigen::ComputeThinV
+                  
+                  DecomposerSVD svd( dMatrixN, ComputeU | ComputeV) ;
+
+#undef ComputeU
+#undef ComputeV
+
+                  dSystemVector dSingularValue = svd.singularValues( ) ;
+
+                  if ( nFeatureType == 2) {
+                  
+                     int nIMin = 0 ;
+                     int nRank = min( nVertComp, 3) ;
+                     double dMinVal = DBL_MAX ;
+
+                     for ( int i = 0 ; i < nRank ; ++ i) {
+                     
+                        if ( dSingularValue( i) < dMinVal) {
+                        
+                           nIMin = i ;
+                           dMinVal = dSingularValue( i)  ;
+                        }
+                     }
+
+                     dSingularValue( nIMin) = 0 ;
+                  } 
+                
+                  dUnknownVector = svd.solve( dKnownVector) ;
+
+                  Point3d ptSol( dUnknownVector( 0) + vtO.x, 
+                                 dUnknownVector( 1) + vtO.y,
+                                 dUnknownVector( 2) + vtO.z) ; 
+
+                  for ( int i = 0 ; i < nVertComp ; ++ i)
+
+                     ptTrasf[i] = ptTrasf[i] + vtO ;
+                  //ptSol += vtO ;  
+
+                  Triangle3d CurrentTriangle ;
+
+                  for ( int i = 0 ; i < nVertComp - 1 ; ++ i) {
+
+                    // Il triangolo è pronto    
+                     CurrentTriangle.Set( ptSol, CompoVert[i+1].ptInt, CompoVert[i].ptInt) ;
+                     CurrentTriangle.Validate( true) ;
+                    
+                    // Aggiungo triangolo
+                     triHold[nCurrent].vecTria.emplace_back( CurrentTriangle) ;                     
+                  }
+
+                 // Ultimo triangolo
+                  CurrentTriangle.Set( ptSol, CompoVert[0].ptInt, CompoVert[nVertComp - 1].ptInt) ;
+                  CurrentTriangle.Validate( true) ;
+
+                 // Aggiungo ultimo triangolo 
+                  triHold[nCurrent].vecTria.emplace_back( CurrentTriangle) ; 
+                  triHold[nCurrent].ptVert = ptSol ; 
+               }
+              // Standard MC
+               else {
+
+                 // Costruzione dei triangoli
+                  for ( int TriIndex = 0 ; TriangleTableEn[nIndex][0][TriIndex] != - 1 ; TriIndex += 3) {
+
+                    // Costruzione triangolo
+                     int i0 = TriangleTableEn[nIndex][0][TriIndex + 2] ;
+                     int i1 = TriangleTableEn[nIndex][0][TriIndex + 1] ;
+                     int i2 = TriangleTableEn[nIndex][0][TriIndex] ;
+
+                     Triangle3d CurrentTriangle ;
+                  
+                    // Il triangolo è pronto    
+                     CurrentTriangle.Set( VecField[i0].ptInt, VecField[i1].ptInt, VecField[i2].ptInt) ;
+                     CurrentTriangle.Validate( true) ;
+
+                    // Aggiungo triangolo
+                     lstTria.emplace_back( CurrentTriangle) ;   
+                  }              
+               }
+
+               nTableOffset += nVertComp ;
+            }     
+         }
+      }
+   }
+          
+   m_BlockToUpdate[nBlock] = false ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+VolZmap::FlipEdges( TriHolder& triHold) const
+{
+   int nVoxelNum = int( triHold.size()) ;
+
+   for ( int n = 0 ; n < nVoxelNum ; ++ n) {
+
+      for ( int m = n + 1 ; m < nVoxelNum ; ++ m) {
+      
+         if ( ( triHold[m].i < int( m_nNx[0])  &&
+                triHold[m].j < int( m_nNy[0])  &&
+                triHold[m].k < int( m_nNy[1])) &&
+            ( ( triHold[m].i == triHold[n].i + 1) ||
+              ( triHold[m].j == triHold[n].j + 1) ||
+              ( triHold[m].k == triHold[n].k + 1))) {
+         
+            int nNumN = int( triHold[n].vecTria.size()) ;
+            int nNumM = int( triHold[m].vecTria.size()) ;
+       
+            for ( int triN = 0 ; triN < nNumN ; ++ triN) { 
+
+               bool bModified = false ;
+            
+               for ( int triM = 0 ; triM < nNumM ; ++ triM) {
+
+                  std::vector <int> SharedIndex ;
+             
+                  for ( int vertN = 0 ; vertN < 3 ; ++ vertN) {
+
+                     for ( int vertM = 0 ; vertM < 3 ; ++ vertM) {
+                     
+                        Point3d ptN = triHold[n].vecTria[triN].GetP( vertN) ;
+                        Point3d ptM = triHold[m].vecTria[triM].GetP( vertM) ;
+
+                        if ( SqDist( ptN, ptM) < EPS_SMALL * EPS_SMALL) { 
+                        
+                           SharedIndex.emplace_back( vertN) ;
+                           SharedIndex.emplace_back( vertM) ;
+                        }
+                         
+
+                        if ( SharedIndex.size() > 2) 
+                           break ;
+                     }
+
+                     if ( SharedIndex.size() > 2) 
+                           break ;
+                  }
+                 // Si deve operare la modifica dei triangoli
+                  if ( SharedIndex.size() > 2) {
+                    
+                    // Modifico i triangoli
+                     triHold[n].vecTria[triN].SetP( SharedIndex[0], triHold[m].ptVert) ;
+                     triHold[m].vecTria[triM].SetP( SharedIndex[3], triHold[n].ptVert) ;
+                                           
+                     triHold[n].vecTria[triN].Validate( true) ;
+                     triHold[m].vecTria[triM].Validate( true) ;
+                      
+                     bModified = true ;
+                     break ;
+                  }                 
+               }
+
+               if( bModified) 
+                  break ;
+            }
+         }
+      }   
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+VolZmap::FlipEdges( int nBlock, TriHolder& triHold)
+{
+  // Controllo sulla validità del blocco
+   if ( nBlock < 0  ||  nBlock > int( m_nNumBlock))
+      return false ;
+
+  // Calcolo posizione del blocco nel reticolo 
+   int nIBlock = ( nBlock % int( m_nFracLin[0] * m_nFracLin[1])) % int( m_nFracLin[0]) ;
+   int nJBlock = ( nBlock % int( m_nFracLin[0] * m_nFracLin[1])) / int( m_nFracLin[0]) ;
+   int nKBlock = ( nBlock / int( m_nFracLin[0] * m_nFracLin[1])) ;
+
+  // Calcolo limiti per l'indice i
+   //int nStartI = nIBlock * int( m_nDexNumPBlock) - 1 ; 
+   int nEndI =   ( nIBlock + 1 == int( m_nFracLin[0]) ? 
+                   int( m_nNx[0]) : ( nIBlock + 1) * int( m_nDexNumPBlock)) ;
+
+  // Calcolo limiti per l'indice j
+   //int nStartJ = nJBlock * int( m_nDexNumPBlock) - 1 ; 
+   int nEndJ =   ( nJBlock + 1 == int( m_nFracLin[1]) ? 
+                   int( m_nNy[0]) : ( nJBlock + 1) * int( m_nDexNumPBlock)) ;
+
+  // Calcolo limiti per l'indice k
+   //int nStartK = nKBlock * int( m_nDexNumPBlock) - 1 ; 
+   int nEndK =   ( nKBlock + 1 == int( m_nFracLin[2]) ? 
+                   int( m_nNy[1]) : ( nKBlock + 1) * int( m_nDexNumPBlock)) ;
+
+   int nFirstVoxelLim = int( triHold.size()) ;
+   int nSecondVoxelLim ;
+
+   for ( int n = 0 ; n < nFirstVoxelLim ; ++ n) {
+
+     // Determino se il voxel è di frontiera
+     // per qualche blocco adiacente.
+
+      int nNeighbour = 0 ;
+
+      if ( triHold[n].i == nEndI - 1)  nNeighbour |= ( 1 << 0) ;    
+      
+      if ( triHold[n].j == nEndJ - 1)  nNeighbour |= ( 1 << 1) ;
+
+      if ( triHold[n].k == nEndK - 1)  nNeighbour |= ( 1 << 2) ; 
+
+      int nNumAdjBlocks = NeighbourTable[nNeighbour][0] ;
+  
+     //  
+      for ( int nTabInd = 0 ; nTabInd <= nNumAdjBlocks ; ++ nTabInd) {
+      
+         if ( ( ! nTabInd) && ( ! nNumAdjBlocks)) 
+
+            nSecondVoxelLim = nFirstVoxelLim ;
+
+         else if ( nTabInd && ( NeighbourTable[nNeighbour][nTabInd] == 1)) {
+            ;
+         }
+         else if ( nTabInd && ( NeighbourTable[nNeighbour][nTabInd] == 2)) {
+            ;
+         }
+         else if ( nTabInd && ( NeighbourTable[nNeighbour][nTabInd] == 3)) {
+            ;
+         }
+
+         // metti l'intero for dopo con gli aggiustamenti      
+      }
+      
+
+     
+
+      for ( int m = n + 1 ; m < nSecondVoxelLim ; ++ m) {
+
+         int nNumN = int( triHold[n].vecTria.size()) ;
+         int nNumM = int( triHold[m].vecTria.size()) ;
+
+         bool bFlag = false ;
+
+         std::vector <int> SharedIndex ;
+
+         for ( int triN = 0 ; triN < nNumN ; ++ triN) {
+            
+            for ( int triM = 0 ; triM < nNumM ; ++ triM) {
+
+               int nSharedVertex = 0 ;
+             
+               for ( int vertN = 0 ; vertN < 3 ; ++ vertN) {
+
+                  for ( int vertM = 0 ; vertM < 3 ; ++ vertM) {
+                     
+                     Point3d ptN = triHold[n].vecTria[triN].GetP( vertN) ;
+                     Point3d ptM = triHold[m].vecTria[triM].GetP( vertM) ;
+
+                     if ( SqDist( ptN, ptM) < EPS_SMALL * EPS_SMALL) {
+                        
+                        nSharedVertex ++ ;
+
+                        SharedIndex.emplace_back( vertN) ;
+                        SharedIndex.emplace_back( vertM) ;
+
+                     } 
+
+                     if ( nSharedVertex > 1) 
+                        break ;
+                  }
+
+                     if ( nSharedVertex > 1) 
+                        break ;
+               }
+
+               if ( nSharedVertex > 1) {
+
+                  triHold[n].vecTria[triN].SetP( SharedIndex[3], triHold[m].ptVert) ;
+                  triHold[m].vecTria[triM].SetP( SharedIndex[2], triHold[n].ptVert) ;
+
+                  bFlag = true ;
+                  break ;
+               }                 
+            }
+
+            if ( bFlag)
+               break ;
+         }
+      } 
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+VolZmap::FlipEdges( int nNumBlocks, int nBlocks[], TriHolder triHold[])
+{
+  // Controllo sulla validità dei blocchi
+   for ( int i = 0 ; i < nNumBlocks ; ++ i)
+      if ( nBlocks[i] < 0 || nBlocks[i] > int( m_nNumBlock))
+         return false ;
+  
+  // Dispongo i blocchi in ordine crescente
+   for ( int i = 0 ; i < nNumBlocks ; ++ i) 
+      for ( int j = i + 1 ; j < nNumBlocks ; ++ j)
+         if ( nBlocks[i] > nBlocks[j])
+            swap( nBlocks[i], nBlocks[j]) ;
+
+
+  // Ciclo sui blocchi
+   for ( int i = 0 ; i < nNumBlocks ; ++ i) {
+   
+   }
    return true ;
 }
 
@@ -755,13 +1152,11 @@ VolZmap::MarchingCubes( TRIA3DLIST& lstTria) const
 bool
 VolZmap::IsThereMat( int nI, int nJ, int nK) const
 {
-
-   if ( nI == - 1  ||  nI == m_nVNx[0]  || 
-        nJ == - 1  ||  nJ == m_nVNy[0]  ||
-        nK == - 1  ||  nK == m_nVNy[1])  
-
+   if ( nI == - 1  ||  nI == m_nNx[0]  || 
+        nJ == - 1  ||  nJ == m_nNy[0]  ||
+        nK == - 1  ||  nK == m_nNy[1])  
       return false ;
-
+  
    double dZ[3] ; 
 
    dZ[0] = ( nK + 0.5) * m_dStep ;
@@ -787,14 +1182,14 @@ VolZmap::IsThereMat( int nI, int nJ, int nK) const
          nGrJ = nI ;
       }
 
-      unsigned int nPos = nGrJ * m_nVNx[nGrid] + nGrI ;
-      size_t nDexSize = m_TriZValues[nGrid][nPos].size() ;
-      unsigned int nIndex = 0 ;   
+      unsigned int nPos = nGrJ * m_nNx[nGrid] + nGrI ;
+      size_t nDexSize = m_Values[nGrid][nPos].size() ;
+      size_t nIndex = 0 ;   
         
       while ( nIndex < nDexSize) {
 
-         if ( dZ[nGrid] > m_TriZValues[nGrid][nPos][nIndex] &&
-              dZ[nGrid] < m_TriZValues[nGrid][nPos][nIndex + 1]) {
+         if ( dZ[nGrid] > m_Values[nGrid][nPos][nIndex].dZVal - EPS_SMALL  &&
+              dZ[nGrid] < m_Values[nGrid][nPos][nIndex + 1].dZVal + EPS_SMALL) {
          
             ++ nCount ;
             break ;
@@ -802,24 +1197,128 @@ VolZmap::IsThereMat( int nI, int nJ, int nK) const
          nIndex += 2 ;
       }   
    }
-   //if ( nCount > 0)
-   if ( nCount == 3)
-      return true ;
-   return false ;
+
+   return ( nCount == 3) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::IsThereMat( const int nMatr[][3], int nNum, double & dHx, double & dHy, double & dHz) const
+VolZmap::IntersPos( int nVec1[], int nVec2[], Point3d& ptInt) const
 {
-      return true ;
+   
+   if ( nVec1[0] != nVec2[0]) {
+
+      ptInt.y = ( nVec1[1] + 0.5) * m_dStep ;
+      ptInt.z = ( nVec1[2] + 0.5) * m_dStep ;
+
+      int nMinI = min( nVec1[0], nVec2[0]) ;
+      int nMaxI = max( nVec1[0], nVec2[0]) ;
+ 
+      double dMinX = ( nMinI + 0.5) * m_dStep ;
+      double dMaxX = ( nMaxI + 0.5) * m_dStep ;
+
+      unsigned int nDexel = nVec1[2] * m_nNx[1] + nVec1[1] ;
+      size_t nSize = m_Values[1][nDexel].size() ;
+
+      bool bFound = false ;
+      for ( size_t i = 0 ; i < nSize ; i += 2) {
+        
+         double dx1 = m_Values[1][nDexel][i].dZVal ;
+         double dx2 = m_Values[1][nDexel][i+1].dZVal ; 
+
+         if ( dx1 < dMinX - EPS_SMALL  &&  dx2 > dMinX - EPS_SMALL  &&  dx2 < dMaxX + EPS_SMALL) {
+            ptInt.x = dx2 ;
+            bFound = true ;
+            break ;
+         }
+         else if ( dx1 > dMinX - EPS_SMALL  &&  dx1 < dMaxX + EPS_SMALL  &&  dx2 > dMaxX + EPS_SMALL) {        
+            ptInt.x = dx1 ;           
+            bFound = true ;
+            break ;
+         }
+      }
+      if ( ! bFound)
+         ptInt.x = ( dMinX + dMaxX) / 2 ;
+   }
+
+   else if ( nVec1[1] != nVec2[1]) {
+
+      ptInt.x = ( nVec1[0] + 0.5) * m_dStep ;
+      ptInt.z = ( nVec1[2] + 0.5) * m_dStep ;
+
+      int nMinJ = min( nVec1[1], nVec2[1]) ;
+      int nMaxJ = max( nVec1[1], nVec2[1]) ;
+      
+      double dMinY = ( nMinJ + 0.5) * m_dStep ;
+      double dMaxY = ( nMaxJ + 0.5) * m_dStep ;
+
+      unsigned int nDexel = nVec1[0] * m_nNx[2] + nVec1[2] ;
+      size_t nSize = m_Values[2][nDexel].size() ;
+
+      bool bFound = false ;
+      for ( size_t j = 0 ; j < nSize ; j += 2) {
+             
+         double dy1 = m_Values[2][nDexel][j].dZVal ;
+         double dy2 = m_Values[2][nDexel][j+1].dZVal ; 
+
+         if ( dy1 < dMinY - EPS_SMALL  &&  dy2 > dMinY - EPS_SMALL  &&  dy2 < dMaxY + EPS_SMALL) {
+            ptInt.y = dy2 ;            
+            bFound = true ;
+            break ;
+         }
+         else if ( dy1 > dMinY - EPS_SMALL  &&  dy1 < dMaxY + EPS_SMALL  &&  dy2 > dMaxY + EPS_SMALL) {
+            ptInt.y = dy1 ;           
+            bFound = true ;
+            break ;
+         }
+      } 
+      if ( ! bFound)
+         ptInt.y = ( dMinY + dMaxY) / 2 ;
+   }  
+
+   else if ( nVec1[2] != nVec2[2]) {
+
+      ptInt.x = ( nVec1[0] + 0.5) * m_dStep ;
+      ptInt.y = ( nVec1[1] + 0.5) * m_dStep ;
+
+      int nMinK = min( nVec1[2], nVec2[2]) ;
+      int nMaxK = max( nVec1[2], nVec2[2]) ;
+      
+      double dMinZ = ( nMinK + 0.5) * m_dStep ;
+      double dMaxZ = ( nMaxK + 0.5) * m_dStep ;
+
+      unsigned int nDexel = nVec1[1] * m_nNx[0] + nVec1[0] ;
+      size_t nSize = m_Values[0][nDexel].size() ;
+
+      bool bFound = false ;
+      for ( size_t k = 0 ; k < nSize ; k += 2) {
+        
+         double dz1 = m_Values[0][nDexel][k].dZVal ;
+         double dz2 = m_Values[0][nDexel][k+1].dZVal ; 
+
+         if ( dz1 < dMinZ - EPS_SMALL  &&  dz2 > dMinZ - EPS_SMALL  &&  dz2 < dMaxZ + EPS_SMALL) {
+            ptInt.z = dz2 ;            
+            bFound = true ;
+            break ;
+         }
+         else if ( dz1 > dMinZ - EPS_SMALL  &&  dz1 < dMaxZ + EPS_SMALL  &&  dz2 > dMaxZ + EPS_SMALL) {
+            ptInt.z = dz1 ;          
+            bFound = true ;
+            break ;
+         }
+      }    
+      if ( ! bFound)
+         ptInt.z = ( dMinZ + dMaxZ) / 2 ;
+   }
+
+   return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::IntersPos( int nVec1[], int nVec2[], Point3d & ptInt) const
+VolZmap::IntersPos( int nVec1[], int nVec2[], Point3d& ptInt, Vector3d& vtNormal) const
 {
-
+   
    if ( nVec1[0] != nVec2[0]) {
 
       int nMinI = min( nVec1[0], nVec2[0]) ;
@@ -828,34 +1327,37 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], Point3d & ptInt) const
       double dMinX = ( nMinI + 0.5) * m_dStep ;
       double dMaxX = ( nMaxI + 0.5) * m_dStep ;
 
-      unsigned int nDexel = nVec1[2] * m_nVNx[1] + nVec1[1] ;
-      size_t nSize = m_TriZValues[1][nDexel].size() ;
-
       ptInt.y = ( nVec1[1] + 0.5) * m_dStep ;
       ptInt.z = ( nVec1[2] + 0.5) * m_dStep ;
 
-      unsigned int i ;
+      unsigned int nDexel = nVec1[2] * m_nNx[1] + nVec1[1] ;
+      size_t nSize = m_Values[1][nDexel].size() ;
 
-      for ( i = 0 ; i < nSize ; i += 2) {
-      
-         double dx1 = m_TriZValues[1][nDexel][i] ;
-         double dx2 = m_TriZValues[1][nDexel][i+1] ; 
+      bool bFound = false ;
+      for ( size_t i = 0 ; i < nSize ; i += 2) {
+        
+         double dx1 = m_Values[1][nDexel][i].dZVal ;
+         double dx2 = m_Values[1][nDexel][i+1].dZVal ; 
 
-         if ( dx1 <= dMinX && dx2 >= dMinX && dx2 <= dMaxX) {
-         
+         if ( dx1 < dMinX - EPS_SMALL  &&  dx2 > dMinX - EPS_SMALL  &&  dx2 < dMaxX + EPS_SMALL) {
             ptInt.x = dx2 ;
+            vtNormal = m_Values[1][nDexel][i+1].vtN ;
+            bFound = true ;
             break ;
          }
-         else if ( dx1 >= dMinX && dx1 <= dMaxX && dx2 >= dMaxX) {
-         
+         else if ( dx1 > dMinX - EPS_SMALL  &&  dx1 < dMaxX + EPS_SMALL  &&  dx2 > dMaxX + EPS_SMALL) {
             ptInt.x = dx1 ;
+            vtNormal = m_Values[1][nDexel][i].vtN ;
+            bFound = true ;
             break ;
          }
       }
-
-      if ( i == nSize)
-        ptInt.x = 0.5 * ( dMinX + dMaxX) ;
+      if ( ! bFound) {
+         ptInt.x = ( dMinX + dMaxX) / 2 ;
+         // Versore Normale ???
+      }
    }
+
    else if ( nVec1[1] != nVec2[1]) {
 
       int nMinJ = min( nVec1[1], nVec2[1]) ;
@@ -863,35 +1365,38 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], Point3d & ptInt) const
       
       double dMinY = ( nMinJ + 0.5) * m_dStep ;
       double dMaxY = ( nMaxJ + 0.5) * m_dStep ;
-                                 // 2                    0
-      unsigned int nDexel = nVec1[0] * m_nVNx[2] + nVec1[2] ;
-      size_t nSize = m_TriZValues[2][nDexel].size() ;
 
       ptInt.x = ( nVec1[0] + 0.5) * m_dStep ;
       ptInt.z = ( nVec1[2] + 0.5) * m_dStep ;
 
-      unsigned int j ;
+      unsigned int nDexel = nVec1[0] * m_nNx[2] + nVec1[2] ;
+      size_t nSize = m_Values[2][nDexel].size() ;
 
-      for ( j = 0 ; j < nSize ; j += 2) {
-      
-         double dy1 = m_TriZValues[2][nDexel][j] ;
-         double dy2 = m_TriZValues[2][nDexel][j+1] ; 
+      bool bFound = false ;
+      for ( size_t j = 0 ; j < nSize ; j += 2) {
+             
+         double dy1 = m_Values[2][nDexel][j].dZVal ;
+         double dy2 = m_Values[2][nDexel][j+1].dZVal ; 
 
-         if ( dy1 <= dMinY && dy2 >= dMinY && dy2 <= dMaxY) {
-         
+         if ( dy1 < dMinY - EPS_SMALL  &&  dy2 > dMinY - EPS_SMALL  &&  dy2 < dMaxY + EPS_SMALL) {
             ptInt.y = dy2 ;
+            vtNormal = m_Values[2][nDexel][j+1].vtN ;
+            bFound = true ;
             break ;
          }
-         else if ( dy1 >= dMinY && dy1 <= dMaxY && dy2 >= dMaxY) {
-         
+         else if ( dy1 > dMinY - EPS_SMALL  &&  dy1 < dMaxY + EPS_SMALL  &&  dy2 > dMaxY + EPS_SMALL) {
             ptInt.y = dy1 ;
+            vtNormal = m_Values[2][nDexel][j].vtN ;
+            bFound = true ;
             break ;
          }
       } 
-
-      if ( j == nSize) 
-        ptInt.y = 0.5 * ( dMinY + dMaxY) ;
+      if ( ! bFound) {
+         ptInt.y = ( dMinY + dMaxY) / 2 ;
+         // Versore Normale ???
+      }
    }  
+
    else if ( nVec1[2] != nVec2[2]) {
 
       int nMinK = min( nVec1[2], nVec2[2]) ;
@@ -900,127 +1405,36 @@ VolZmap::IntersPos( int nVec1[], int nVec2[], Point3d & ptInt) const
       double dMinZ = ( nMinK + 0.5) * m_dStep ;
       double dMaxZ = ( nMaxK + 0.5) * m_dStep ;
 
-      unsigned int nDexel = nVec1[1] * m_nVNx[0] + nVec1[0] ;
-      size_t nSize = m_TriZValues[0][nDexel].size() ;
-
       ptInt.x = ( nVec1[0] + 0.5) * m_dStep ;
       ptInt.y = ( nVec1[1] + 0.5) * m_dStep ;
 
-      unsigned int k ;
+      unsigned int nDexel = nVec1[1] * m_nNx[0] + nVec1[0] ;
+      size_t nSize = m_Values[0][nDexel].size() ;
 
-      for ( k = 0 ; k < nSize ; k += 2) {
-      
-         double dz1 = m_TriZValues[0][nDexel][k] ;
-         double dz2 = m_TriZValues[0][nDexel][k+1] ; 
+      bool bFound = false ;
+      for ( size_t k = 0 ; k < nSize ; k += 2) {
+        
+         double dz1 = m_Values[0][nDexel][k].dZVal ;
+         double dz2 = m_Values[0][nDexel][k+1].dZVal ; 
 
-         if ( dz1 <= dMinZ && dz2 >= dMinZ && dz2 <= dMaxZ) {
-         
+         if ( dz1 < dMinZ - EPS_SMALL  &&  dz2 > dMinZ - EPS_SMALL  &&  dz2 < dMaxZ + EPS_SMALL) {
             ptInt.z = dz2 ;
+            vtNormal = m_Values[0][nDexel][k+1].vtN ; 
+            bFound = true ;
             break ;
          }
-         else if ( dz1 >= dMinZ && dz1 <= dMaxZ && dz2 >= dMaxZ) {
-         
+         else if ( dz1 > dMinZ - EPS_SMALL  &&  dz1 < dMaxZ + EPS_SMALL  &&  dz2 > dMaxZ + EPS_SMALL) {
             ptInt.z = dz1 ;
+            vtNormal = m_Values[0][nDexel][k].vtN ;
+            bFound = true ;
             break ;
          }
       }    
-
-      if ( k == nSize)
-        ptInt.z = 0.5 * ( dMinZ + dMaxZ) ;
+      if ( ! bFound) {
+         ptInt.z = ( dMinZ + dMaxZ) / 2 ;
+         // Versore Normale ???
+      }
    }
+
    return true ;
 }
-
-/*
-            Point3d ptProva[8] ;
-            Vector3d vtProva[8] ;
-
-            ptProva[0].x = ( i + 0.5) * m_dStep ;
-            ptProva[0].y = ( j + 0.5) * m_dStep ;
-            ptProva[0].z = ( k + 0.5) * m_dStep ;
-            ptProva[1].x = ( i + 1.5) * m_dStep ;
-            ptProva[1].y = ( j + 0.5) * m_dStep ;
-            ptProva[1].z = ( k + 0.5) * m_dStep ;
-            ptProva[2].x = ( i + 1.5) * m_dStep ;
-            ptProva[2].y = ( j + 1.5) * m_dStep ;
-            ptProva[2].z = ( k + 0.5) * m_dStep ;
-            ptProva[3].x = ( i + 0.5) * m_dStep ;
-            ptProva[3].y = ( j + 1.5) * m_dStep ;
-            ptProva[3].z = ( k + 0.5) * m_dStep ;
-            ptProva[4].x = ( i + 0.5) * m_dStep ;
-            ptProva[4].y = ( j + 0.5) * m_dStep ;
-            ptProva[4].z = ( k + 1.5) * m_dStep ;
-            ptProva[5].x = ( i + 1.5) * m_dStep ;
-            ptProva[5].y = ( j + 0.5) * m_dStep ;
-            ptProva[5].z = ( k + 1.5) * m_dStep ;
-            ptProva[6].x = ( i + 1.5) * m_dStep ;
-            ptProva[6].y = ( j + 1.5) * m_dStep ;
-            ptProva[6].z = ( k + 1.5) * m_dStep ;
-            ptProva[7].x = ( i + 0.5) * m_dStep ;
-            ptProva[7].y = ( j + 1.5) * m_dStep ;
-            ptProva[7].z = ( k + 1.5) * m_dStep ;
-
-            Point3d ptC( 10, 10, 10) ;
-
-            for ( int boh = 0 ; boh < 8 ; ++ boh) 
-
-               vtProva[boh] = ptProva[boh] - ptC ;    */
-
-/*
-            if ( function( vtProva[0])) 
-               nIndex |= ( 1 << 0) ;
-           
-            if ( function( vtProva[1])) 
-               nIndex |= ( 1 << 1) ;
-            
-            if ( function( vtProva[2])) 
-               nIndex |= ( 1 << 2) ;
-             
-            if ( function( vtProva[3])) 
-               nIndex |= ( 1 << 3) ;
-              
-            if ( function( vtProva[4])) 
-               nIndex |= ( 1 << 4) ;
-             
-            if ( function( vtProva[5])) 
-               nIndex |= ( 1 << 5) ;
-             
-            if ( function( vtProva[6])) 
-               nIndex |= ( 1 << 6) ;
-              
-            if ( function( vtProva[7])) 
-               nIndex |= ( 1 << 7) ;    */
-
-/*
-                  Vector3d vtV1 = ptIntPoint[i1] - ptIntPoint[i0] ;
-                  Vector3d vtV2 = ptIntPoint[i2] - ptIntPoint[i0] ;
-                  Vector3d vtN = vtV1 ^ vtV2 ;
-
-                  vtN.Normalize() ;
-
-                  int nCorner = intersections[i0][0] ;
-
-                  Point3d ptCorner( IndexCorner[nCorner][0] * m_dStep, 
-                                    IndexCorner[nCorner][1] * m_dStep,
-                                    IndexCorner[nCorner][2] * m_dStep) ;
-
-                  Vector3d vtT = ptCorner - ptIntPoint[i0] ;
-
-                  vtT.Normalize() ;
-
-               
-                  if( nIndex & ( 1 << nCorner)) {
-                     if( vtN * vtT < 0)
-                        vtN = - vtN ;
-                  }
-                  else {
-                     if ( vtN * vtT > 0)
-                        vtN = - vtN ;
-                  }*/
-
-
-
-
-
-
-       
\ No newline at end of file
diff --git a/VolTriZmapVolume.cpp b/VolTriZmapVolume.cpp
index 274162f..be29a76 100644
--- a/VolTriZmapVolume.cpp
+++ b/VolTriZmapVolume.cpp
@@ -31,8 +31,9 @@ using namespace std ;
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, double dMin, double dMax)    
-{
+VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ,
+                            double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax)    
+{   
    
    // Controllo che dMin e dMax non siano quasi coincidenti
    if ( abs( dMax - dMin) < EPS_SMALL)
@@ -47,67 +48,87 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ
       swap( dMin, dMax) ;
 
    // Controllo che indici nI, nJ siano entro i limiti
-   if ( nI < 0 && nI >= m_nVNx[nGrid] && 
-        nJ < 0 && nJ >= m_nVNy[nGrid])
+   if ( nI < 0 && nI >= m_nNx[nGrid] && 
+        nJ < 0 && nJ >= m_nNy[nGrid])
       return false ;
+
+  // Riporto le coordinate cicliche nell'ordine di partenza
+   Vector3d vtNmi = vtNMin ;
+   Vector3d vtNma = vtNMax ;
+   if ( nGrid == 1) {
+      swap( vtNmi.x, vtNmi.z) ;
+      swap( vtNmi.y, vtNmi.z) ;
+      swap( vtNma.x, vtNma.z) ;
+      swap( vtNma.y, vtNma.z) ;
+   }
+   else if ( nGrid == 2) {
+      swap( vtNmi.y, vtNmi.z) ;
+      swap( vtNmi.x, vtNmi.z) ;
+      swap( vtNma.y, vtNma.z) ;
+      swap( vtNma.x, vtNma.z) ;
+   }
    
    // Calcolo nPos
-   unsigned int nPos = nJ * m_nVNx[nGrid] + nI ;  // O nJ*m_Nx + nI + 1 ?
-
-  /* Non serve: se size == 0 non entra nel ciclo
-  // Se il dexel è vuoto non succede niente 
-   if ( m_TriZValues[nGrid][nPos].size() == 0)
-      return true ;  */
-
+   unsigned int nPos = nJ * m_nNx[nGrid] + nI ;  
+ 
    // Ciclo sugli intervalli del singolo dexel
    bool bModified = false ;
    unsigned int i = 0 ;
 
-   while ( i + 1 < m_TriZValues[nGrid][nPos].size()) {
+   while ( i + 1 < m_Values[nGrid][nPos].size()) {
 
       // Casi:
       // Intervallo da sottrarre è tutto a sinistra di quello corrente, non vi è intersezione 
-      if ( m_TriZValues[nGrid][nPos][i] > dMax - EPS_SMALL) {
+      if ( m_Values[nGrid][nPos][i].dZVal > dMax - EPS_SMALL) {
          ;
       }
       // Intersezione
-      else if ( m_TriZValues[nGrid][nPos][i + 1] > dMax + EPS_SMALL) {
+      else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMax + EPS_SMALL) {
          // L'intervallo corrente corrente viene limitato a sinistra
-         if ( m_TriZValues[nGrid][nPos][i] > dMin - EPS_SMALL) {
+         if ( m_Values[nGrid][nPos][i].dZVal > dMin - EPS_SMALL) {
             bModified = true ;
-            m_TriZValues[nGrid][nPos][i] = dMax ;
+            m_Values[nGrid][nPos][i].dZVal = dMax ;
+            m_Values[nGrid][nPos][i].vtN = vtNma ;
          }
          // L'intervallo si divide in due intervalli
          else {
             bModified = true ;
-            m_TriZValues[nGrid][nPos].resize( m_TriZValues[nGrid][nPos].size() + 2) ;
+            m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ;
 
-            for ( size_t j = m_TriZValues[nGrid][nPos].size() - 1 ; j >= i + 3 ; -- j)
+            for ( size_t j = m_Values[nGrid][nPos].size() - 1 ; j >= i + 3 ; -- j) {
 
-               m_TriZValues[nGrid][nPos][j] = m_TriZValues[nGrid][nPos][j - 2] ;
+               m_Values[nGrid][nPos][j].dZVal = m_Values[nGrid][nPos][j - 2].dZVal ;
+               m_Values[nGrid][nPos][j].vtN = m_Values[nGrid][nPos][j - 2].vtN ;
+            }
 
-            m_TriZValues[nGrid][nPos][i + 1] = dMin ;
-            m_TriZValues[nGrid][nPos][i + 2] = dMax ;
+            m_Values[nGrid][nPos][i + 1].dZVal = dMin ;
+            m_Values[nGrid][nPos][i + 2].dZVal = dMax ;
+
+            m_Values[nGrid][nPos][i + 1].vtN = vtNMin ;
+            m_Values[nGrid][nPos][i + 2].vtN = vtNma ;
 
             i = i + 2 ;
          }
       }
       else {
          // L'intervallo corrente viene eliminato
-         if ( m_TriZValues[nGrid][nPos][i] > dMin - EPS_SMALL) {
+         if ( m_Values[nGrid][nPos][i].dZVal > dMin - EPS_SMALL) {
             bModified = true ;
-            for ( unsigned int j = i ; j < m_TriZValues[nGrid][nPos].size() - 2 ; ++ j)
+            for ( unsigned int j = i ; j < m_Values[nGrid][nPos].size() - 2 ; ++ j) {
 
-               m_TriZValues[nGrid][nPos][j] = m_TriZValues[nGrid][nPos][j + 2] ;
+               m_Values[nGrid][nPos][j].dZVal = m_Values[nGrid][nPos][j + 2].dZVal ;
+               m_Values[nGrid][nPos][j].vtN = m_Values[nGrid][nPos][j + 2].vtN ;
+            }
 
-            m_TriZValues[nGrid][nPos].resize( m_TriZValues[nGrid][nPos].size() - 2) ;
+            m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() - 2) ;
 
             i = i - 2 ;
          }
          // L'intervallo corrente viene limitato a destra
-         else if ( m_TriZValues[nGrid][nPos][i + 1] > dMin + EPS_SMALL) {
+         else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMin + EPS_SMALL) {
             bModified = true ;
-            m_TriZValues[nGrid][nPos][i + 1] = dMin ;
+            m_Values[nGrid][nPos][i + 1].dZVal = dMin ;
+            m_Values[nGrid][nPos][i + 1].vtN = vtNmi ;
          }
          // L'intervallo da sottrarre è tutto a destra di quello corrente, non vi è intersezione
          else {
@@ -119,15 +140,55 @@ VolZmap::SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ
    }
 
    // Se eseguita modifica, imposto ricalcolo della grafica
-   if ( bModified)
+   if ( bModified) {
+
+      // Determino quali blocchi sono stati modificati
+      int nLayerBlock = m_nFracLin[0] * m_nFracLin[1] ;
+  
+      if ( nGrid == 0) {
+
+         int nXBlock = min( nI / m_nDexNumPBlock, m_nFracLin[0] - 1) ;
+         int nYBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[1] - 1) ;
+         int nMinZBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
+         int nMaxZBlock = min( int( m_nFracLin[2] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
+         
+         for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k) 
+
+            m_BlockToUpdate[k * nLayerBlock + nYBlock * m_nFracLin[0] + nXBlock] = true ;
+      }
+      else if ( nGrid == 1) {
+
+         int nYBlock = min( nI / m_nDexNumPBlock, m_nFracLin[1] - 1) ;
+         int nZBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[2] - 1) ;
+         int nMinXBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
+         int nMaxXBlock = min( int( m_nFracLin[0] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
+         
+         for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k) 
+
+            m_BlockToUpdate[nZBlock * nLayerBlock + nYBlock * m_nFracLin[0] + k] = true ;
+      }
+      else if ( nGrid == 2) {
+
+         int nXBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[0] - 1) ;
+         int nZBlock = min( nI / m_nDexNumPBlock, m_nFracLin[2] - 1) ;
+         int nMinYBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
+         int nMaxYBlock = min( int( m_nFracLin[1] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
+         
+         for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k) 
+
+            m_BlockToUpdate[nZBlock * nLayerBlock + k * m_nFracLin[0] + nXBlock] = true ;
+      }
+
       m_OGrMgr.Reset() ;
+   }
 
    return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::SubtractIntervals( unsigned int nGrid, const Point3d & ptP, double dMin, double dMax) 
+VolZmap::SubtractIntervals( unsigned int nGrid, const Point3d & ptP, 
+                            double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) 
 {
   // Controllo che il numero di griglia sia entro i limiti.
    if ( nGrid < 0 || nGrid > 2)
@@ -152,10 +213,10 @@ VolZmap::SubtractIntervals( unsigned int nGrid, const Point3d & ptP, double dMin
 
   // Controllo che gli indici ottenuti siano nella griglia:
   // se sono dentro la griglia chiamo l'altra subtract
-   if ( i >= 0 && i < m_nVNx[nGrid] &&
-        j >= 0 && j < m_nVNy[nGrid])  
+   if ( i >= 0 && i < m_nNx[nGrid] &&
+        j >= 0 && j < m_nNy[nGrid])  
       
-      return SubtractIntervals( nGrid, i, j, dhMin, dhMax) ;
+      return SubtractIntervals( nGrid, i, j, dhMin, dhMax, vtNMin, vtNMax) ;
   // altrimenti non succede niente
    else 
       return true ;
@@ -163,7 +224,8 @@ VolZmap::SubtractIntervals( unsigned int nGrid, const Point3d & ptP, double dMin
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AddIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, double dMin, double dMax)     
+VolZmap::AddIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ,
+                       double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax)     
 {
    // Controllo che dMin e dMax non siano quasi coincidenti
    if ( abs( dMax - dMin) < EPS_SMALL)
@@ -172,31 +234,52 @@ VolZmap::AddIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, dou
    // Controllo che il numero di griglia sia entro i limiti
    if ( nGrid < 0 || nGrid > 2)
       return false ;
-   
-   // Controllo che indici nI, nJ siano entro i limiti
-   if ( nI < 0 && nI >= m_nVNx[nGrid] && 
-        nJ < 0 && nJ >= m_nVNy[nGrid])
-      return false ;
-
-   // Calcolo nPos
-   unsigned int nPos = nJ * m_nVNx[nGrid] + nI ;
 
    // Controllo che dMin < dMax
-   swap( dMin, dMax) ; 
+   if ( dMin > dMax)
+      swap( dMin, dMax) ; 
+   
+   // Controllo che indici nI, nJ siano entro i limiti
+   if ( nI < 0 && nI >= m_nNx[nGrid] && 
+        nJ < 0 && nJ >= m_nNy[nGrid])
+      return false ;
 
+  // Riporto le coordinate cicliche nell'ordine di partenza
+   Vector3d vtNmi = vtNMin ;
+   Vector3d vtNma = vtNMax ;
+   if ( nGrid == 1) {
+      swap( vtNmi.x, vtNmi.z) ;
+      swap( vtNmi.y, vtNmi.z) ;
+      swap( vtNma.x, vtNma.z) ;
+      swap( vtNma.y, vtNma.z) ;
+   }
+   else if ( nGrid == 2) {
+      swap( vtNmi.y, vtNmi.z) ;
+      swap( vtNmi.x, vtNmi.z) ;
+      swap( vtNma.y, vtNma.z) ;
+      swap( vtNma.x, vtNma.z) ;
+   }
+
+   // Calcolo nPos
+   unsigned int nPos = nJ * m_nNx[nGrid] + nI ;
+
+   
    // Se spillone vuoto
-   if ( m_TriZValues[nGrid][nPos].size() == 0) {
+   if ( m_Values[nGrid][nPos].size() == 0) {
    
-      m_TriZValues[nGrid][nPos].resize( 2) ;
+      m_Values[nGrid][nPos].resize( 2) ;
    
-      m_TriZValues[nGrid][nPos][0] = dMin ;
-      m_TriZValues[nGrid][nPos][1] = dMax ;
+      m_Values[nGrid][nPos][0].dZVal = dMin ;
+      m_Values[nGrid][nPos][1].dZVal = dMax ;
 
-      if ( dMax > m_dVMaxZ[nGrid])
-         m_dVMinZ[nGrid] = dMax ;
+      m_Values[nGrid][nPos][0].vtN = vtNmi ;
+      m_Values[nGrid][nPos][1].vtN = vtNma ;
 
-      if ( dMin < m_dVMinZ[nGrid])
-         m_dVMinZ[nGrid] = dMin ;
+      if ( dMax > m_dMaxZ[nGrid])
+         m_dMinZ[nGrid] = dMax ;
+
+      if ( dMin < m_dMinZ[nGrid])
+         m_dMinZ[nGrid] = dMin ;
 
       m_OGrMgr.Reset() ;
 
@@ -206,69 +289,95 @@ VolZmap::AddIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, dou
    // Ciclo sugli intervalli dello spillone
    bool bModified = false ;
    unsigned int i = 0 ;
-   while ( i + 1 < m_TriZValues[nGrid][nPos].size()) {
+   while ( i + 1 < m_Values[nGrid][nPos].size()) {
 
       // Eventuale aggiustamento di intervalli sovrapposti
       if ( i > 0) {
-         if ( m_TriZValues[nGrid][nPos][i] < m_TriZValues[nGrid][nPos][i - 1] + EPS_SMALL) {
+
+         if ( m_Values[nGrid][nPos][i].dZVal < m_Values[nGrid][nPos][i - 1].dZVal + EPS_SMALL) {
+
             // Se l'intervallo corrente non è contenuto totalmente si esegue l'istruzione successiva
-            if ( m_TriZValues[nGrid][nPos][i - 1] < m_TriZValues[nGrid][nPos][i + 1] + EPS_SMALL)
+            if ( m_Values[nGrid][nPos][i - 1].dZVal < m_Values[nGrid][nPos][i + 1].dZVal + EPS_SMALL) {
          
-               m_TriZValues[nGrid][nPos][i - 1] = m_TriZValues[nGrid][nPos][i + 1] ;
+               m_Values[nGrid][nPos][i - 1].dZVal = m_Values[nGrid][nPos][i + 1].dZVal ;
+               m_Values[nGrid][nPos][i - 1].vtN = m_Values[nGrid][nPos][i + 1].vtN ;
+            }
          
-            for ( unsigned int j = i ; j < m_TriZValues[nGrid][nPos].size() - 2 ; ++ j) 
-               m_TriZValues[nGrid][nPos][j] = m_TriZValues[nGrid][nPos][j + 2] ;
+            for ( unsigned int j = i ; j < m_Values[nGrid][nPos].size() - 2 ; ++ j) {
+
+               m_Values[nGrid][nPos][j].dZVal = m_Values[nGrid][nPos][j + 2].dZVal ;
+               m_Values[nGrid][nPos][j].vtN = m_Values[nGrid][nPos][j + 2].vtN ;
+            }
          
-            m_TriZValues[nGrid][nPos].resize( m_TriZValues[nGrid][nPos].size() - 2) ; 
+            m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() - 2) ; 
             
             i = i - 2 ; 
          }
       }
 
       // Caso in cui devo aggiungere un intervallo a sinistra dell'intervallo corrente
-      if ( m_TriZValues[nGrid][nPos][i] > dMax + EPS_SMALL) {
+      if ( m_Values[nGrid][nPos][i].dZVal > dMax + EPS_SMALL) {
+
          bModified = true ;   
                   
-         m_TriZValues[nGrid][nPos].resize( m_TriZValues[nGrid][nPos].size() + 2) ;
+         m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ;
          
-         for ( size_t j = m_TriZValues[nGrid][nPos].size() - 1 ; j >= i + 2 ; -- j) 
-            m_TriZValues[nGrid][nPos][j] = m_TriZValues[nGrid][nPos][j - 2] ;
+         for ( size_t j = m_Values[nGrid][nPos].size() - 1 ; j >= i + 2 ; -- j) {
          
-         m_TriZValues[nGrid][nPos][i] = dMin ;
-         m_TriZValues[nGrid][nPos][i + 1] = dMax ;
+            m_Values[nGrid][nPos][j].dZVal = m_Values[nGrid][nPos][j - 2].dZVal ;
+            m_Values[nGrid][nPos][j].vtN = m_Values[nGrid][nPos][j - 2].vtN ;
+         }
+            
+         
+         m_Values[nGrid][nPos][i].dZVal = dMin ;
+         m_Values[nGrid][nPos][i + 1].dZVal = dMax ;
+
+         m_Values[nGrid][nPos][i].vtN = vtNMin ;
+         m_Values[nGrid][nPos][i + 1].vtN = vtNMax ;
 
          i = i + 2 ;
       } 
 
       // Casi d'intersezione:
-      else if ( m_TriZValues[nGrid][nPos][i + 1] > dMax - EPS_SMALL) {
+      else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMax - EPS_SMALL) {
+
          // Se l'intervallo da aggiungere sconfina a sinistra modifico il minimo dell'intervalo corrente
-         if ( m_TriZValues[nGrid][nPos][i] > dMin - EPS_SMALL) { 
+         if ( m_Values[nGrid][nPos][i].dZVal > dMin - EPS_SMALL) { 
+
             bModified = true ;         
-            m_TriZValues[nGrid][nPos][i] = dMin ;
+            m_Values[nGrid][nPos][i].dZVal = dMin ;
+            m_Values[nGrid][nPos][i].vtN = vtNmi ;
          }
       }
 
       else {
          // Se l'intervallo corrente è tutto contenuto nell'intervallo da aggungere modifico gli estremi    
-         if ( m_TriZValues[nGrid][nPos][i] > dMin + EPS_SMALL) {
+         if ( m_Values[nGrid][nPos][i].dZVal > dMin + EPS_SMALL) {
+
                bModified = true ;         
-               m_TriZValues[nGrid][nPos][i] = dMin ;
-               m_TriZValues[nGrid][nPos][i + 1] = dMax ;
+               m_Values[nGrid][nPos][i].dZVal = dMin ;
+               m_Values[nGrid][nPos][i + 1].dZVal = dMax ;
+               m_Values[nGrid][nPos][i].vtN = vtNMin ;
+               m_Values[nGrid][nPos][i + 1].vtN = vtNma ;
          }
          // Se l'intervallo da aggiungere sconfina a destra modifico il massimo dell'intervallo corrente 
-         else if ( m_TriZValues[nGrid][nPos][i + 1] > dMin - EPS_SMALL) {
+         else if ( m_Values[nGrid][nPos][i + 1].dZVal > dMin - EPS_SMALL) {
+
             bModified = true ;         
-            m_TriZValues[nGrid][nPos][i + 1] = dMax ;
+            m_Values[nGrid][nPos][i + 1].dZVal = dMax ;
+            m_Values[nGrid][nPos][i + 1].vtN = vtNma ;
          }
          else {
             // Aggiungo intervallo a destra dell'ultimo intervallo
-            if ( i == m_TriZValues[nGrid][nPos].size() - 2) {
+            if ( i == m_Values[nGrid][nPos].size() - 2) {
+
                bModified = true ;         
-               m_TriZValues[nGrid][nPos].resize( m_TriZValues[nGrid][nPos].size() + 2) ;
+               m_Values[nGrid][nPos].resize( m_Values[nGrid][nPos].size() + 2) ;
                
-               m_TriZValues[nGrid][nPos][i + 2] = dMin ;
-               m_TriZValues[nGrid][nPos][i + 3] = dMax ;
+               m_Values[nGrid][nPos][i + 2].dZVal = dMin ;
+               m_Values[nGrid][nPos][i + 3].dZVal = dMax ;
+               m_Values[nGrid][nPos][i + 2].vtN = vtNmi ;
+               m_Values[nGrid][nPos][i + 3].vtN = vtNma ;
 
                i = i + 2 ;
             }
@@ -281,13 +390,52 @@ VolZmap::AddIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, dou
    // se eseguita modifica, imposto ricalcolo della grafica
    if ( bModified) {
 
+      // Determino quali blocchi sono stati modificati
+      int nLayerBlock = m_nFracLin[0] * m_nFracLin[1] ;
+  
+      if ( nGrid == 0) {
+
+         int nXBlock = min( nI / m_nDexNumPBlock, m_nFracLin[0] - 1) ;
+         int nYBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[1] - 1) ;
+         int nMinZBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
+         int nMaxZBlock = min( int( m_nFracLin[2] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
+         
+         for ( int k = nMinZBlock ; k <= nMaxZBlock ; ++ k) 
+
+            m_BlockToUpdate[k * nLayerBlock + nYBlock * m_nFracLin[0] + nXBlock] = true ;
+      }
+      else if ( nGrid == 1) {
+
+         int nYBlock = min( nI / m_nDexNumPBlock, m_nFracLin[1] - 1) ;
+         int nZBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[2] - 1) ;
+         int nMinXBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
+         int nMaxXBlock = min( int( m_nFracLin[0] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
+         
+         for ( int k = nMinXBlock ; k <= nMaxXBlock ; ++ k) 
+
+            m_BlockToUpdate[nZBlock * nLayerBlock + nYBlock * m_nFracLin[0] + k] = true ;
+      }
+      else if ( nGrid == 2) {
+
+         int nXBlock = min( nJ / m_nDexNumPBlock, m_nFracLin[0] - 1) ;
+         int nZBlock = min( nI / m_nDexNumPBlock, m_nFracLin[2] - 1) ;
+         int nMinYBlock = max( 0, int( floor( ( dMin / m_dStep))) / int( m_nDexNumPBlock)) ;
+         int nMaxYBlock = min( int( m_nFracLin[1] - 1), int( floor( ( dMax / m_dStep))) / int( m_nDexNumPBlock)) ;
+         
+         for ( int k = nMinYBlock ; k <= nMaxYBlock ; ++ k) 
+
+            m_BlockToUpdate[nZBlock * nLayerBlock + k * m_nFracLin[0] + nXBlock] = true ;
+      }
+
       m_OGrMgr.Reset() ;
 
-      if ( dMax > m_dVMaxZ[nGrid])
-         m_dVMinZ[nGrid] = dMax ;
+      // Aggiorno massima e minima Z
+      // sullo Zmap
+      if ( dMax > m_dMaxZ[nGrid])
+         m_dMinZ[nGrid] = dMax ;
 
-      if ( dMin < m_dVMinZ[nGrid])
-         m_dVMinZ[nGrid] = dMin ;
+      if ( dMin < m_dMinZ[nGrid])
+         m_dMinZ[nGrid] = dMin ;
    }
 
    return true ;    
@@ -295,7 +443,8 @@ VolZmap::AddIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, dou
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::AddIntervals( unsigned int nGrid, const Point3d & ptP, double dMin, double dMax)
+VolZmap::AddIntervals( unsigned int nGrid, const Point3d & ptP,
+                       double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax)
 { 
   // Controllo che il numero di griglia sia entro i limiti.
    if ( nGrid < 0 || nGrid > 2)
@@ -320,10 +469,10 @@ VolZmap::AddIntervals( unsigned int nGrid, const Point3d & ptP, double dMin, dou
 
   // Controllo che gli indici ottenuti siano nella griglia:
   // se sono dentro la griglia chiamo l'altra add
-   if ( i >= 0 && i < m_nVNx[nGrid] &&
-        j >= 0 && j < m_nVNy[nGrid])   
+   if ( i >= 0 && i < m_nNx[nGrid] &&
+        j >= 0 && j < m_nNy[nGrid])   
      
-      return AddIntervals( nGrid, i, j, dhMin, dhMax) ;
+      return AddIntervals( nGrid, i, j, dhMin, dhMax, vtNMin, vtNMax) ;
    else
      // altrimenti non succede niente
       return false ;
@@ -336,7 +485,6 @@ VolZmap::AddIntervals( unsigned int nGrid, const Point3d & ptP, double dMin, dou
 bool
 VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Point3d& ptPe, const Vector3d& vtDe) 
 {
-
   // Controllo sull'effettiva esisenza del movimento
    if ( AreSamePointApprox( ptPs, ptPe) && AreSameVectorApprox( vtDs, vtDe)) 
       return true ;
@@ -534,9 +682,7 @@ VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Point3d&
        //  return false ;
    }
    return true ;
-}
-
-
+} 
 
 // ---------- VERSORE UTENSILE DERETTO COME Z --------------------------------
 
@@ -584,16 +730,22 @@ VolZmap::CylBall_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
          if ( dSqLen < dSqRad) 
            // utensile cilindrico
             if ( m_nToolType == CylindricalMill)
-               SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ) ;
+               SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ, vtToolDir, - vtToolDir) ;
            // utensile sferico
             else if ( m_nToolType == BallEndMill) {
 
                double dH = sqrt( dSqRad - dSqLen) ;
 
-               if ( vtToolDir.z > 0)
-                  SubtractIntervals( nGrid, i, j, dMinStemZ - dH, dMaxStemZ) ;
-               else 
-                  SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ + dH) ;
+               if ( vtToolDir.z > 0) {
+                                                                            
+                   Vector3d vtNorm = Point3d( ptSxy.x, ptSxy.y, dMinStemZ) - Point3d( dX, dY, dMinStemZ - dH) ;
+                   SubtractIntervals( nGrid, i, j, dMinStemZ - dH, dMaxStemZ, vtNorm, - vtToolDir) ;
+               }
+               else {
+               
+                   Vector3d vtNorm = Point3d( ptSxy.x, ptSxy.y, dMinStemZ) - Point3d( dX, dY, dMinStemZ + dH) ;
+                   SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ + dH, - vtToolDir, vtNorm) ;
+               } 
             }
       }
    }
@@ -648,7 +800,7 @@ VolZmap::CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& p
                  ( ( dP1 - dLen) * ( dP1 - dLen) + dP2 * dP2) < dSqRad ||
                  ( dP1 > 0 && dP1 < dLen && abs( dP2) < m_dRadius))
                
-                 SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ) ;
+                 SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ, V_NULL, V_NULL) ;
          } 
         // Utensile sferico
          else if ( m_nToolType == BallEndMill) {
@@ -658,27 +810,27 @@ VolZmap::CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& p
                double dH = sqrt( dSqRad - dP1 * dP1 - dP2 * dP2) ;
 
                if ( vtToolDir.z > 0)
-                  SubtractIntervals( nGrid, i, j, dMinStemZ - dH, dMaxStemZ) ;
+                  SubtractIntervals( nGrid, i, j, dMinStemZ - dH, dMaxStemZ, V_NULL, V_NULL) ;
                else 
-                  SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ + dH) ;
+                  SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ + dH, V_NULL, V_NULL) ;
             }
             else if ( dP1 > dLen  &&  ( dP1 - dLen) * ( dP1 - dLen) + dP2 * dP2 < dSqRad) {
 
                double dH = sqrt( dSqRad - ( dP1 - dLen) * ( dP1 - dLen) - dP2 * dP2) ;
 
                if ( vtToolDir.z > 0)
-                  SubtractIntervals( nGrid, i, j, dMinStemZ - dH, dMaxStemZ) ;
+                  SubtractIntervals( nGrid, i, j, dMinStemZ - dH, dMaxStemZ, V_NULL, V_NULL) ;
                else 
-                  SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ + dH) ;
+                  SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ + dH, V_NULL, V_NULL) ;
             }
             else if ( dP1 > - EPS_SMALL  &&  dP1 < dLen + EPS_SMALL  &&  abs( dP2) < m_dRadius) {
             
                double dH = sqrt( dSqRad - dP2 * dP2) ;
 
                if ( vtToolDir.z > 0)
-                  SubtractIntervals( nGrid, i, j, dMinStemZ - dH, dMaxStemZ) ;
+                  SubtractIntervals( nGrid, i, j, dMinStemZ - dH, dMaxStemZ, V_NULL, V_NULL) ;
                else 
-                  SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ + dH) ;
+                  SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ + dH, V_NULL, V_NULL) ;
             }
          } 
       }
@@ -781,7 +933,7 @@ VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
                else 
                   dMin = dZMinI + dDeltaZ * ( dX1 - dX1_0) / dLenXY ;
 
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
             }
             else if ( m_nToolType == BallEndMill) {
 
@@ -809,7 +961,7 @@ VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
                   else 
                      dMin = dZMinF - sqrt( dSqRad - ( dX1 - dLenXY) * ( dX1 - dLenXY) - dX2 * dX2) ;
 
-                  SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+                  SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
                }
                else {
                  // Massimo
@@ -830,7 +982,7 @@ VolZmap::CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
                   else 
                      dMin = dZMinI + dDeltaZ * ( dX2 - dCylX1_0) / dLenXY ;
 
-                  SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+                  SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
                }
             }
          }    
@@ -884,7 +1036,7 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d
 
             if ( dSqDist < dSqMinRad)
 
-               SubtractIntervals( nGrid, i, j, dZMin, dZMax) ;
+               SubtractIntervals( nGrid, i, j, dZMin, dZMax, V_NULL, V_NULL) ;
 
             else if ( dSqDist < dSqMaxRad) {
 
@@ -892,9 +1044,9 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d
             
                if ( vtToolDir.z > 0)
                  
-                  SubtractIntervals( nGrid, i, j, dZMin + m_dTipHeight * ( dr - dMinRad) / dDeltaRad, dZMax) ;  
+                  SubtractIntervals( nGrid, i, j, dZMin + m_dTipHeight * ( dr - dMinRad) / dDeltaRad, dZMax, V_NULL, V_NULL) ;  
                else
-                  SubtractIntervals( nGrid, i, j, dZMin, dZMax -  m_dTipHeight * ( dr - dMinRad) / dDeltaRad) ;  
+                  SubtractIntervals( nGrid, i, j, dZMin, dZMax -  m_dTipHeight * ( dr - dMinRad) / dDeltaRad, V_NULL, V_NULL) ;  
             }     
          }
       }
@@ -915,7 +1067,7 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d
 
             if ( dSqDist < dSqMinRad)
 
-               SubtractIntervals( nGrid, i, j, dZMin, dZMax) ;
+               SubtractIntervals( nGrid, i, j, dZMin, dZMax, V_NULL, V_NULL) ;
 
             else if ( dSqDist < dSqMaxRad) {
 
@@ -923,9 +1075,9 @@ VolZmap::Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d
             
                if ( vtToolDir.z > 0)
                  
-                  SubtractIntervals( nGrid, i, j, dZMin, dZMax - dStemHeigth - m_dTipHeight * ( dr - dMinRad) / dDeltaRad) ;  
+                  SubtractIntervals( nGrid, i, j, dZMin, dZMax - dStemHeigth - m_dTipHeight * ( dr - dMinRad) / dDeltaRad, V_NULL, V_NULL) ;  
                else
-                  SubtractIntervals( nGrid, i, j, dZMin + dStemHeigth + m_dTipHeight * ( dr - dMinRad) / dDeltaRad, dZMax) ;  
+                  SubtractIntervals( nGrid, i, j, dZMin + dStemHeigth + m_dTipHeight * ( dr - dMinRad) / dDeltaRad, dZMax, V_NULL, V_NULL) ;  
             }     
          }
       }
@@ -993,28 +1145,28 @@ VolZmap::Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & p
          if ( dSqDistI < dSqMinRad || dSqDistF < dSqMinRad ||
               ( dX1 > 0 && dX1 < dLenXY && abs( dX2) < dMinRad))
 
-            SubtractIntervals( nGrid, i, j, min( dBaseZ, dTipZ), max( dBaseZ, dTipZ)) ;
+            SubtractIntervals( nGrid, i, j, min( dBaseZ, dTipZ), max( dBaseZ, dTipZ), V_NULL, V_NULL) ;
 
          else if ( dSqDistI < dSqMaxRad && dX1 < 0) {
 
             double dr = sqrt( dSqDistI) ;
          
             SubtractIntervals( nGrid, i, j, min( dZ1, dZ2 + ( dr - dMinRad) * ( dZ3 - dZ2) / dDeltaRad),
-                                            max( dZ1, dZ2 + ( dr - dMinRad) * ( dZ3 - dZ2) / dDeltaRad)) ;
+                                            max( dZ1, dZ2 + ( dr - dMinRad) * ( dZ3 - dZ2) / dDeltaRad), V_NULL, V_NULL) ;
          }      
          else if ( dX1 <= dLenXY && abs( dX2) < dMaxRad) {
 
             double dr = abs( dX2) ; 
 
             SubtractIntervals( nGrid, i, j, min( dZ1, dZ2 + ( dr - dMinRad) * ( dZ3 - dZ2) / dDeltaRad),
-                                            max( dZ1, dZ2 + ( dr - dMinRad) * ( dZ3 - dZ2) / dDeltaRad)) ; 
+                                            max( dZ1, dZ2 + ( dr - dMinRad) * ( dZ3 - dZ2) / dDeltaRad), V_NULL, V_NULL) ; 
          }
          else if ( dSqDistF < dSqMaxRad) {
 
             double dr = sqrt( dSqDistF) ; 
 
             SubtractIntervals( nGrid, i, j, min( dZ1, dZ2 + ( dr - dMinRad) * ( dZ3 - dZ2) / dDeltaRad),
-                                            max( dZ1, dZ2 + ( dr - dMinRad) * ( dZ3 - dZ2) / dDeltaRad)) ;      
+                                            max( dZ1, dZ2 + ( dr - dMinRad) * ( dZ3 - dZ2) / dDeltaRad), V_NULL, V_NULL) ;      
          }
       }
    }
@@ -1270,7 +1422,7 @@ VolZmap::Dr_ZMilling( unsigned int nGrid, const Point3d & ptLs, const Point3d &
                else
                   dMin = dZI + ( dDeltaZ / dLen) * ( dProj + dPMaxCirc) ; 
             }
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
          }
       } 
    }
@@ -1529,7 +1681,7 @@ VolZmap::Sw_ZMilling( unsigned int nGrid, const Point3d & ptLs, const Point3d &
                
                }
             }
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
          }
 
         // Parte cilindrica
@@ -1567,7 +1719,7 @@ VolZmap::Sw_ZMilling( unsigned int nGrid, const Point3d & ptLs, const Point3d &
 
                dMax = dMinZCyl + dDeltaH + ( dCylProj + dSt) * dADeltaZ / dLen ;
 
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
          
          }
       }
@@ -1622,7 +1774,7 @@ VolZmap::GenTool_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
             
                double dRadius = ptStart.x ;
 
-               CompCyl_ZDrilling( nGrid, ptS, ptE, vtToolDir, dHeight, dRadius) ;
+               CompCyl_ZDrilling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius) ;
             }
            // Il componente è un cono con vettore equiverso a quello dell'utensile
             else if ( ptStart.x > ptEnd.x) {
@@ -1630,7 +1782,7 @@ VolZmap::GenTool_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
                double dMaxRad = ptStart.x ;
                double dMinRad = ptEnd.x ;
 
-               CompConus_ZDrilling( nGrid, ptS, ptE, vtToolDir, dHeight, dMaxRad, dMinRad) ;
+               CompConus_ZDrilling( nGrid, ptI, ptF, vtToolDir, dHeight, dMaxRad, dMinRad) ;
             }
            // Il componente è un cono con vettore opposto a quello dell'utesile
             else if ( ptStart.x < ptEnd.x) {
@@ -1792,7 +1944,7 @@ VolZmap::GenTool_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
    return true ;         
 
 }
-
+ 
 
 // ---------- VERSORE UTENSILE NEL PIANO XY ----------------------------------
 
@@ -1843,8 +1995,15 @@ VolZmap::CylBall_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Poin
               abs( dP2) < m_dRadius ) {
 
             double dH = sqrt( dSqRad - dP2 * dP2) ;
+            double dMin = dZ - dH ;
+            double dMax = dZ + dH ;
 
-            SubtractIntervals( nGrid, i, j, dZ - dH , dZ + dH) ;
+            Vector3d vtMin = ( ptI - Point3d( dX, dY, dMin)) -
+                             ( ( ptI - Point3d( dX, dY, dMin)) * vtToolDir) * vtToolDir ;
+            Vector3d vtMax = ( ptI - Point3d( dX, dY, dMax)) - 
+                             ( ( ptI - Point3d( dX, dY, dMax)) * vtToolDir) * vtToolDir ;
+
+            SubtractIntervals( nGrid, i, j, dMin, dMax, vtMin, vtMax) ;
          }
 
         // Se l'utensile è sferico sottraggo anche la punta
@@ -1852,14 +2011,19 @@ VolZmap::CylBall_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Poin
             if ( dSqLen < dSqRad) { // LA SOLUZIONE MOMENTANEA è CREARE UTENSILE GENERICO SE LO STELO è PIù CORTO DEL RAGGIO
 
                double dH = sqrt( dSqRad - dSqLen) ;
+               double dMin = dZ - dH ;
+               double dMax = dZ + dH ;
 
-               SubtractIntervals( nGrid, i, j, dZ - dH, dZ + dH) ;
+               Vector3d vtMin = ptF - Point3d( dX, dY, dMin) ;
+               Vector3d vtMax = ptF - Point3d( dX, dY, dMax) ;
+
+               SubtractIntervals( nGrid, i, j, dZ - dH, dZ + dH, vtMin, vtMax) ;
             }
       }
    }
    return true ;
 }
-
+ 
 //----------------------------------------------------------------------------
 bool
 VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) 
@@ -1967,7 +2131,7 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d
                   dInfZ = dZF - dH ;              
                }
 
-               SubtractIntervals( nGrid, i, j, dInfZ, dSupZ) ;
+               SubtractIntervals( nGrid, i, j, dInfZ, dSupZ, V_NULL, V_NULL) ;
             }
          }
         // Se l'utensile è ball-end sottraggo la punta 
@@ -2005,7 +2169,7 @@ VolZmap::CylBall_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d
                else
                   dMin = dZF - sqrt( dSqRad - ( dP1 - dStemHeigth) * ( dP1 - dStemHeigth) - ( dP2 - dLenXY) * ( dP2 - dLenXY)) ;   
 
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
             } 
          }                                                                        
       }
@@ -2092,14 +2256,14 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3
               abs( dX2) < m_dRadius) {
 
             double dH = sqrt( dSqRad - dX2 * dX2) ;
-            SubtractIntervals( nGrid, i, j, ptI.z - dH, ptI.z + dH) ;
+            SubtractIntervals( nGrid, i, j, ptI.z - dH, ptI.z + dH, V_NULL, V_NULL) ;
          }
          else if ( dX1 >= dMatStemLen && 
                    dX1 < dMatStemLen + m_dTipHeight &&
                    abs( dX2) < dr) {
 
             double dH = sqrt( dr * dr - dX2 * dX2) ;
-            SubtractIntervals( nGrid, i, j, ptI.z - dH, ptI.z + dH) ;
+            SubtractIntervals( nGrid, i, j, ptI.z - dH, ptI.z + dH, V_NULL, V_NULL) ;
          }
 
          if ( m_dTipRadius >= m_dRadius) {
@@ -2109,7 +2273,7 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3
                  abs( dX2) < dSqTipRad) {
             
                double dH = sqrt( dSqTipRad - dX2 * dX2) ;
-               SubtractIntervals( nGrid, i, j, ptI.z - dH, ptI.z + dH) ;
+               SubtractIntervals( nGrid, i, j, ptI.z - dH, ptI.z + dH, V_NULL, V_NULL) ;
             }
          }
       }
@@ -2186,13 +2350,13 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d &
             if ( dX1 > 0 && dX1 < dStemHeigth && abs( dX2) < m_dRadius) {    
 
                double dH = sqrt( dSqRad - dX2 * dX2) ;
-               SubtractIntervals( nGrid, i, j, dZI - dH, dZF + dH) ;             
+               SubtractIntervals( nGrid, i, j, dZI - dH, dZF + dH, V_NULL, V_NULL) ;             
             } 
            // Parte conica
             else if ( dX1 >= dStemHeigth && dX1 < m_dHeight &&  abs( dX2) < dr) {
 
                double dH = sqrt( dr * dr - dX2 * dX2) ;
-               SubtractIntervals ( nGrid, i, j, dZI - dH, dZF + dH) ;
+               SubtractIntervals ( nGrid, i, j, dZI - dH, dZF + dH, V_NULL, V_NULL) ;
             }  
          }
       }
@@ -2259,7 +2423,7 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d &
                else
                   dMin = dZF + sqrt( dSqRad - ( dX2 - dLenXY) * ( dX2 - dLenXY)) ;
 
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
             }
            // Parte conica
             else if ( dX1 >= dStemHeigth && dX1 < m_dHeight && 
@@ -2284,7 +2448,7 @@ VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d &
                else
                   dMin = dZF + sqrt( dr * dr - ( dX2 - dLenXY) * ( dX2 - dLenXY)) ;
                
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
             }
          }
       }   
@@ -2364,23 +2528,23 @@ VolZmap::CylBall_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d
 bool
 VolZmap::Conus_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) {
 
-   double dStemHeigth = m_dHeight - m_dRadius ;
+   double dStemHeigth = m_dHeight - m_dTipHeight ;
  
    CompCyl_Drilling( nGrid, ptS, ptE, vtToolDir, dStemHeigth, m_dRadius) ;
   // Trapano
    if ( m_dTipRadius < m_dRadius) {
 
-      Point3d ptSBall = ptS - dStemHeigth * vtToolDir ;
-      Point3d ptEBall = ptE - dStemHeigth * vtToolDir ;
+      Point3d ptSCone = ptS - dStemHeigth * vtToolDir ;
+      Point3d ptECone = ptE - dStemHeigth * vtToolDir ;
 
-      CompConus_Drilling( nGrid, ptSBall, ptEBall, vtToolDir, m_dTipHeight, m_dRadius, m_dTipRadius) ;  
+      CompConus_Drilling( nGrid, ptSCone, ptECone, vtToolDir, m_dTipHeight, m_dRadius, m_dTipRadius) ;  
    }
    else {
 
-      Point3d ptSBall = ptS - m_dHeight * vtToolDir ;
-      Point3d ptEBall = ptE - m_dHeight * vtToolDir ;
+      Point3d ptSCone = ptS - m_dHeight * vtToolDir ;
+      Point3d ptECone = ptE - m_dHeight * vtToolDir ;
 
-      CompConus_Drilling( nGrid, ptSBall, ptEBall, - vtToolDir, m_dTipHeight, m_dTipRadius, m_dRadius) ;
+      CompConus_Drilling( nGrid, ptSCone, ptECone, - vtToolDir, m_dTipHeight, m_dTipRadius, m_dRadius) ;
    }
 
    return true ;
@@ -2459,7 +2623,7 @@ VolZmap::GenTool_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3
             
                double dRadius = ptStart.x ;
 
-               CompCyl_Drilling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius) ;
+              // CompCyl_Drilling( nGrid, ptI, ptF, vtToolDir, dHeight, dRadius) ;
             }
            // Il componente è un cono con vettore equiverso a quello dell'utensile
             else if ( ptStart.x > ptEnd.x) {
@@ -2634,7 +2798,7 @@ VolZmap::GenTool_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d
 }
 
 
-// ------------------------- COMPONENTI ELEMENTARI -----------------------------------------------------------------------------
+// ------------------------- SOLIDI ELEMENTARI -----------------------------------------------------------------------------
 
 // Asse di simmetria diretto come l'asse Z: FORATURA 
 
@@ -2677,7 +2841,7 @@ VolZmap::CompCyl_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
 
         // Se il punto si trova dentro il cerchio taglio
          if ( dSqLen < dSqRad)            
-            SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ) ;          
+            SubtractIntervals( nGrid, i, j, dMinStemZ, dMaxStemZ, V_NULL, V_NULL) ;          
       }
    }
    return true ;
@@ -2726,7 +2890,7 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Poi
 
          if ( dSqDist < dSqMinRad) 
 
-            SubtractIntervals( nGrid, i, j, dZMin, dZMax) ;
+            SubtractIntervals( nGrid, i, j, dZMin, dZMax, V_NULL, V_NULL) ;
 
          else if ( dSqDist < dSqMaxRad) {
 
@@ -2734,9 +2898,9 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Poi
 
             if ( vtToolDir.z > 0) 
 
-               SubtractIntervals( nGrid, i, j, dZMin + dAngC * ( dr - dMinRad), dZMax) ;
+               SubtractIntervals( nGrid, i, j, dZMin + dAngC * ( dr - dMinRad), dZMax, V_NULL, V_NULL) ;
             else 
-               SubtractIntervals( nGrid, i, j, dZMin, dZMax - dAngC * ( dr - dMinRad)) ;
+               SubtractIntervals( nGrid, i, j, dZMin, dZMax - dAngC * ( dr - dMinRad), V_NULL, V_NULL) ;
          }        
       }
 
@@ -2837,7 +3001,7 @@ VolZmap::CompCyl_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3
             else 
                dMin = dZMinI + dDeltaZ * ( dX1 - dX1_0) / dLenXY ;
 
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;  
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;  
          }    
       }
    }
@@ -2992,7 +3156,7 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin
             dMin = min( dPLim, dMLim) ;
             dMax = max( dPLim, dMLim) ;
             
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
          }
       }
    }
@@ -3005,113 +3169,62 @@ VolZmap::CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Poin
 
 //----------------------------------------------------------------------------
 bool 
-VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dRad) 
+VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir,
+                           double dHei, double dRad) 
 {
    double dMin, dMax;
    unsigned int nStartI, nEndI, nStartJ, nEndJ ;
 
-   bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir, vtToolDir, nStartI, nStartJ, nEndI, nEndJ, dRad, dRad, dHei) ; 
+   bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir, vtToolDir, nStartI, nStartJ, nEndI, nEndJ,
+                                 dRad, dRad, dHei) ; 
 
    if ( ! Control) 
       return true ;
 
   // Studio delle simmetrie
-   Vector3d vtMove = ptE - ptS ;   
-  
-   Point3d ptI = ( vtMove * vtToolDir > 0 ? ptE : ptS) ;
-   Point3d ptF = ( vtMove * vtToolDir > 0 ? ptS - dHei * vtToolDir : ptE - dHei * vtToolDir) ;
+   Point3d ptI = ( ( ptE - ptS) * vtToolDir > 0 ? ptE : ptS) ;
+   Point3d ptF = ( ( ptE - ptS) * vtToolDir > 0 ? ptS - vtToolDir * dHei : ptE - vtToolDir * dHei) ;
 
-   if ( ptI.z > ptF.z) {
-   
-      Point3d ptTemp = ptI ;
-      ptI = ptF ;
-      ptF = ptTemp ;
-   }
+  // Sistema di riferimento cilindro
+   Vector3d vtV1 = - vtToolDir ;
 
-   double dDeltaZ = ptF.z - ptI.z ;
-   double dZI = ptI.z ;
+   Point3d ptP = ( abs( vtV1.z) < EPS_SMALL ? Point3d( ptI.x, ptI.y, ptI.z + 1) : Point3d( ptI.x + 1, ptI.y, ptI.z)) ;
+   Vector3d vtV = ( abs( vtV1.z) < EPS_SMALL ? vtToolDir : Z_AX) ;
 
-  // Definizione 
-   Point3d ptIxy( ptI.x, ptI.y, 0) ;
-   Point3d ptFxy( ptF.x, ptF.y, 0) ;
+   Vector3d vtV2 = ptP - ptI + ( ( ( ptI - ptP) * vtV1) / ( vtV * vtV1)) * vtV ;
 
-   Vector3d vtCyl = ptF - ptI ;                     double dLen = sqrt( vtCyl * vtCyl) ;
-   Vector3d vtCylVer( 0, 0, vtCyl.z) ;              double dLVer = abs( vtCyl.z) ;
-   Vector3d vtCylOri( vtCyl.x, vtCyl.y, 0) ;        double dLOri = vtCylOri.LenXY() ;
+   vtV2.Normalize() ;
 
-   double dCos = dLVer / dLen ;  // Coseno dell'angolo formato da vtCyl con l'asse Z.
-   double dSin = dLOri / dLen ;  // Seno dell'angolo formato da vtCyl con l'asse Z.
+   Vector3d vtV3 = vtV1 ^ vtV2 ;
 
-   double dSemiMin = dRad * dCos ;
-   double dSqRad = dRad * dRad ;
-  
-  // Definizione del sistema di riferimento nel piano
-   Vector3d vtU1 = vtCylOri ; 
-   
-   if ( vtU1.LenXY() < EPS_SMALL) {
-   
-      double dLenVector = sqrt(vtCyl.x * vtCyl.x + vtCyl.y * vtCyl.y) ;
-   
-      vtU1 = ( 1 + dLenVector) / dLenVector * vtU1 ;
-   }
-
-   vtU1.Normalize() ;
-
-   Vector3d vtU2 = vtU1 ;       vtU2.Rotate( Z_AX, 90) ;      
-
-  // Definizione piani
-   Vector3d vtV = vtMove ;       vtV.Normalize() ;  
-   Vector3d vtRI = ptI - ORIG ;  double dDotI = vtRI * vtV ;
-   Vector3d vtRF = ptF - ORIG ;  double dDotF = vtRF * vtV ;
+   Frame3d CylFrame ;  CylFrame.Set( ptI, vtV1, vtV2, vtV3) ;
 
+  // Lunghezzza cilindro totale altezza + moto
+   double dLen = ( ptF - ptI).Len() ;
 
    for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
-
+   
       for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
 
-         double dX = ( i + 0.5) * m_dStep ;  double dY = ( j + 0.5) * m_dStep ;
+         double dX = ( i + 0.5) * m_dStep ;
+         double dY = ( j + 0.5) * m_dStep ;
 
-         Point3d ptC( dX, dY, 0) ;   Vector3d vtCI = ptC - ptIxy ;  Vector3d vtCF = ptC - ptFxy ;
+         Point3d ptC( dX, dY, 0) ;
 
-         double dProjI1 = vtCI * vtU1 ;  double dProjI2 = vtCI * vtU2 ;
-         double dProjF1 = vtCF * vtU1 ;  double dProjF2 = vtCF * vtU2 ;
-
-         if ( dProjI1 > - dCos *  sqrt( dSqRad - dProjI2 * dProjI2) && 
-              dProjI1 < dLOri + dCos *  sqrt( dSqRad - dProjI2 * dProjI2) &&
-              dProjI2 * dProjI2 < dSqRad) {
+         Point3d ptInt1, ptInt2 ;
+      
+         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dLen, dRad, ptInt1, ptInt2)) {
          
-           // Massimi
-            if ( dProjI1 < dLOri - dCos *  sqrt( dSqRad - dProjI2 * dProjI2)) {
+            dMin = min( ptInt1.z, ptInt2.z) ;
+            dMax = max( ptInt1.z, ptInt2.z) ;
 
-               double dZ0 = dSin * sqrt( dSqRad - dProjI2 * dProjI2) ;
-               double dI10 = - dCos * sqrt( dSqRad - dProjI2 * dProjI2) ;
-            
-               dMax = dZI + dZ0 + ( dProjI1 - dI10) * dDeltaZ / dLOri ;
-            }
-            else 
-
-               dMax = ( dDotF - vtV.x * dX - vtV.y *dY) / vtV.z ;
-
-           // Minimi
-            if ( dProjI1 < dCos *  sqrt( dSqRad - dProjI2 * dProjI2)) 
-            
-               dMin = ( dDotI - vtV.x * dX - vtV.y *dY) / vtV.z ;
-
-            else {
-
-               double dZ0 = - dSin * sqrt( dSqRad - dProjI2 * dProjI2) ;
-               double dI10 = dCos * sqrt( dSqRad - dProjI2 * dProjI2) ;
-
-               dMin = dZI + dZ0 + ( dProjI1 - dI10) * dDeltaZ / dLOri ;
-            }
-
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;     
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
          }
       }
    }
    return true ;   
 }
-     
+
 //----------------------------------------------------------------------------
 bool 
 VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE,
@@ -3125,220 +3238,63 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Poin
    if ( ! Control) 
       return true ;
 
-   Vector3d vtMove = ptE - ptS ;            double dLen = vtMove.Len() ;
-   Vector3d vtMZ( 0, 0, vtMove.z) ;           double dLVer = abs( vtMove.z) ;
-   Vector3d vtMXY( vtMove.x, vtMove.y, 0) ;   double dLOri = vtMXY.LenXY() ;
-
-   double dSin = dLOri / dLen ;
-   double dCos = dLVer / dLen ;
-
-   double dSemiMinR = dMaxRad * dCos ;
-   double dSemiMinr = dMinRad * dCos ;
-
-   double dSqMaxRad = dMaxRad * dMaxRad ;
-
-  // Sistema di riferimento sul cono
-   Vector3d vtV1 = vtToolDir ;  // controllare qui e negli altri coni che le proiezioni non siano troppo piccole FORSE CONVIENE FARE I CONTI CON VTMOVE NORMALIZZATO (QUESTO IN TUTTI I MOVIMENTI)
-   
-   double dCoef23 = ( vtV1.z > 0 ? 1 : - 1) ;
-   double dCoef21 = - dCoef23 * vtV1.z ;  //  vtV1.z := vtV1 * Z_AX
-
-   Vector3d vtV2 = dCoef21 * vtV1 + dCoef23 * Z_AX ;  vtV2.Normalize() ;
-   Vector3d vtV3 = vtV1 ^ vtV2 ;
-
-  // Simmetrie del problema riguardanti il cono
-   Point3d ptCBot = ( vtV1 * vtMove > 0 ? ptS : ptE) ;
-   Point3d ptCTip = ptCBot - dHei * vtV1 ;
-
+  // Apertura del cono
    double dDeltaR = dMaxRad - dMinRad ;
    double dTan = dDeltaR / dHei ;
    double dL = ( ( dMaxRad * dHei) / dDeltaR) ;
    double dl = dL - dHei ;
 
-   Point3d ptV = ptCBot - vtV1 * dL ;
-
-  // Simmetrie del problema riguardanti il cilinidro
-   Point3d ptCylI = ( ptS.z < ptE.z ? ptS : ptE) ;
-   Point3d ptCylF = ( ptS.z < ptE.z ? ptE : ptS) ;
-
-   double dDeltaZ = ptCylF.z - ptCylI.z ;
-   double dZCylI = ptCylI.z ;
-
-  // Piani cono
-   Vector3d vtR0B = ptCBot - ORIG ;  double dDotB = vtR0B * vtV1 ;
-   Vector3d vtR0T = ptCTip - ORIG ;  double dDotT = vtR0T * vtV1 ;
-
-
-  // Piani cilindro
-   Vector3d vtR0I = ptCylI - ORIG ;  double dDotI = vtR0I * vtV1 ;
-   Vector3d vtR0F = ptCylF - ORIG ;  double dDotF = vtR0F * vtV1 ;
-
-
-  // Punti sul piano 
-   Point3d ptCylIxy( ptCylI.x, ptCylI.y, 0) ;
-   Point3d ptCBotxy( ptCBot.x, ptCBot.y, 0) ;
-
-
-  // Riferimenti sul piano
-   Vector3d vtU1( ptCylF.x - ptCylI.x, ptCylF.y - ptCylI.y, 0) ;   vtU1.Normalize() ;
-   Vector3d vtU2 = vtU1 ;  vtU2.Rotate( Z_AX, 90) ;
-
-   Vector3d vtW1( vtV1.x, vtV1.y, 0) ;  vtW1.Normalize() ;
-   Vector3d vtW2 = vtW1 ;  vtW2.Rotate( Z_AX, 90) ;
+   Point3d ptVertex = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) - vtToolDir * dL ;
 
   // Sistema di riferimento del cono
-   Frame3d ConusFrame ;  ConusFrame.Set( ptV, vtV1, vtV2, vtV3) ;
-   Frame3d GridFrame ;   GridFrame.Set( ORIG, X_AX, Y_AX, Z_AX) ;
+   Vector3d vtV1 = vtToolDir ;
 
+   Point3d ptP = ( abs( vtV1.z) < EPS_SMALL ? Point3d( ptVertex.x, ptVertex.y, ptVertex.z + 1) : Point3d( ptVertex.x + 1, ptVertex.y, ptVertex.z)) ;
+
+   Vector3d vtV = ( abs( vtV1.z) < EPS_SMALL ? vtToolDir : Z_AX) ;
+
+   Vector3d vtV2 = ptP - ptVertex + ( ( ( ptVertex - ptP) * vtV1) / ( vtV * vtV1)) * vtV ;
+
+   vtV2.Normalize() ;
+
+   Vector3d vtV3 = vtV1 ^ vtV2 ;
+
+   Frame3d ConusFrame ;  ConusFrame.Set( ptVertex, vtV1, vtV2, vtV3) ;
+
+  // Lunghezzza cilindro totale altezza + moto
+   double dLen = ( ptE - ptS).Len() ;
 
-  // Ciclo
    for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
-
+   
       for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
       
-         double dX = ( i + 0.5) * m_dStep ;  double dY = ( j + 0.5) * m_dStep ;
+         double dX = ( i + 0.5) * m_dStep ;
+         double dY = ( j + 0.5) * m_dStep ;
 
-         Point3d ptC( dX, dY, 0) ;  Vector3d vtC = ptC - ptCylIxy ;
+         Point3d ptC( dX, dY, 0) ;
 
-         double dPCyl1 = vtC * vtU1 ;  double dPCyl2 = vtC * vtU2 ;
-          
-        // Parte cilindrica
-         if ( dPCyl2 * dPCyl2 < dSqMaxRad && 
-              dPCyl1 > - dSemiMinR * sqrt( 1 - ( dPCyl2 * dPCyl2) / dSqMaxRad) && 
-              dPCyl1 < dLOri + dSemiMinR * sqrt( 1 - ( dPCyl2 * dPCyl2) / dSqMaxRad)) {
+         Point3d ptInt1, ptInt2 ;
 
-           // Massimi
-            if ( dPCyl1 < dLOri - dSemiMinR * sqrt( 1 - ( dPCyl2 * dPCyl2) / dSqMaxRad)) {
-            
-               double dZ0 = dSin * sqrt( dSqMaxRad - dPCyl2 * dPCyl2) ;  
-               double dP0 = - dSemiMinR * sqrt( 1 - ( dPCyl2 * dPCyl2) / dSqMaxRad) ;
+        // Cilindro
+         if ( IntersLineCylinder( ptC - vtV1 * dL, Z_AX, ConusFrame, dLen, dMaxRad, ptInt1, ptInt2)) {
+         
+            dMin = min( ptInt1.z + vtV1.z * dL, ptInt2.z + vtV1.z * dL) ;
+            dMax = max( ptInt1.z + vtV1.z * dL, ptInt2.z + vtV1.z * dL) ;
 
-               dMax = dZCylI + dZ0 + ( dPCyl1 - dP0) * dDeltaZ / ( dLOri) ;
-            }
-            else 
-
-               dMax = ( dDotF - dX * vtV1.x - dY * vtV1.y) / vtV1.z ;
-
-           // Minimi 
-            if ( dPCyl1 < dSemiMinR * sqrt( 1 - ( dPCyl2 * dPCyl2) / dSqMaxRad))
-
-               dMin = ( dDotI - dX * vtV1.x - dY * vtV1.y) / vtV1.z ;
-
-            else {
-
-               double dZ0 = - dSin * sqrt( dSqMaxRad - dPCyl2 * dPCyl2) ;  
-               double dP0 = dSemiMinR * sqrt( 1 - ( dPCyl2 * dPCyl2) / dSqMaxRad) ;
-
-               dMin = dZCylI + dZ0 + ( dPCyl1 - dP0) * dDeltaZ / ( dLOri) ;     
-            }
-
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
          }
-            
-        // Parte conica
-         Vector3d vtD = Z_AX ;
 
-         ptC.LocToLoc( GridFrame, ConusFrame) ;
+        // Cono
+         if ( IntersLineConus( ptC , Z_AX, ConusFrame, dTan, dl, dL, ptInt1, ptInt2)) {
+         
+            dMin = min( ptInt1.z, ptInt2.z) ;
+            dMax = max( ptInt1.z, ptInt2.z) ;
 
-         vtD.LocToLoc( GridFrame, ConusFrame) ;
-
-         std::vector <double> vdCoef(3);
-         std::vector <double> vdRoots;
-
-         vdCoef[0] = ( dTan * dTan * ptC.x * ptC.x - ptC.y * ptC.y - ptC.z * ptC.z) ;
-         vdCoef[1] = 2 * ( dTan * dTan * ptC.x * vtD.x - ptC.y * vtD.y - ptC.z * vtD.z) ;
-         vdCoef[2] = dTan * dTan * vtD.x * vtD.x - vtD.y * vtD.y - vtD.z * vtD.z ;
-
-         int nRoot = PolynomialRoots( 2, vdCoef, vdRoots) ;
-
-         if ( nRoot == 1) {
-
-            Point3d ptR1 = ptC + vdRoots[0] * vtD ;
-
-            if ( ptR1.x >= dl && ptR1.x < dL) {
-
-               ptR1.LocToLoc( ConusFrame, GridFrame) ;
-
-               dMin = min( ptR1.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR1.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;    
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            } 
-            else if ( ptR1.x >= 0 && ptR1.x < dl) {
-
-               dMin = min( ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
          }
-         else if ( nRoot == 2) {
-
-            Point3d ptR1 = ptC + vdRoots[0] * vtD ;
-            Point3d ptR2 = ptC + vdRoots[1] * vtD ;
-
-            if ( ptR1.x > ptR2.x) {
-            
-               Point3d ptTemp = ptR1 ;
-               ptR1 = ptR2 ;
-               ptR2 = ptTemp ;
-            }
-
-            if ( ptR1.x < 0 && ptR2.x > 0 && ptR2.x < dl) {
-
-               dMin = min( ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x < 0 && ptR2.x >= dl && ptR2.x < dL) {
-   
-               ptR2.LocToLoc( ConusFrame, GridFrame) ;
-
-               dMin = min( ptR2.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR2.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x > 0 && ptR1.x < dl && ptR2.x >= dl && ptR2.x < dL) {
-
-               ptR2.LocToLoc( ConusFrame, GridFrame) ;
-
-               dMin = min( ptR2.z, ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR2.z, ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x > 0 && ptR1.x < dl && ptR2.x >= dL) {
-
-               dMin = min( ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= dl && ptR1.x < dL && ptR2.x < dL) {
-
-               ptR1.LocToLoc( ConusFrame, GridFrame) ;
-               ptR2.LocToLoc( ConusFrame, GridFrame) ;
-            
-               dMin = min( ptR1.z, ptR2.z) ;
-               dMax = max( ptR1.z, ptR2.z) ;
-            
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= dl && ptR1.x < dL && ptR2.x >= dL) {
-            
-               ptR1.LocToLoc( ConusFrame, GridFrame) ;
-
-               dMin = min( ptR1.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR1.z, ( dDotB - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-         } 
       }
    }
-   return true ; 
+   return true ;
 }
 
 // Asse di simmetria con orientazione generica: FRESATURA
@@ -3347,8 +3303,7 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Poin
 bool
 VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE,
                           const Vector3d& vtToolDir, double dHei, double dRad) 
-{
-   double dMin, dMax ;
+{  
    unsigned int nStartI, nStartJ, nEndI, nEndJ ;
 
   // Verifica sull'interferenza utensile Zmap
@@ -3357,502 +3312,119 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
    if ( ! Control)
       return true ;
 
-   Point3d ptI ;
-   Point3d ptF ;
-   Vector3d vtV1 ;
- 
+
   // Studio delle simmetrie
-   if ( vtToolDir.z < 0) {
-   
-      vtV1 = - vtToolDir ;
-      ptI = ( vtV1 * ( ptE - ptS) > 0 ? ptS + dHei * vtV1 : ptE + dHei * vtV1) ;
-      ptF = ( vtV1 * ( ptE - ptS) > 0 ? ptE + dHei * vtV1 : ptS + dHei * vtV1) ;
-   }
-   else {
-   
-      vtV1 = vtToolDir ;
-      ptI = ( vtV1 * ( ptE - ptS) > 0 ? ptS : ptE) ;
-      ptF = ( vtV1 * ( ptE - ptS) > 0 ? ptE : ptS) ;
-   }
+   Point3d ptI = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) ;
+   Point3d ptF = ( vtToolDir * ( ptE - ptS) > 0 ? ptE : ptS) ;
 
-   Point3d ptIT = ptI - vtV1 * dHei ;
-   Point3d ptFT = ptF - vtV1 * dHei ;
 
-  // Definizione di un sintema di riferimento nel piano
-  // Ocio che |V1| sia maggiore di EPS_SMALL
-   Vector3d vtU1( - vtV1.x, - vtV1.y, 0) ;
-   vtU1.Normalize() ; 
-   Vector3d vtU2 = vtU1 ;  vtU2.Rotate( Z_AX, 90) ;
+   Point3d ptITip = ptI - vtToolDir * dHei ;
+   Point3d ptFTip = ptF - vtToolDir * dHei ;
 
-   Vector3d vtMove = ptF - ptI ;                       
-   Vector3d vtMLong = ( vtMove * vtV1) * vtV1 ;        
-   Vector3d vtMOrt = vtMove - vtMLong ;                
 
-  // Parametri geometrici dell'utensile 
-  // e della traiettoria
-   double dCos = vtV1.z ;
-   double dSin = vtV1.LenXY() ;
+  // Definizione terne vettoriali e sistemi di riferimento intrinseci al movimento
+   Vector3d vtMove = ptF - ptI ;
+   Vector3d vtMoveLong = ( vtMove * vtToolDir) * vtToolDir ;
+   Vector3d vtMoveOrt = vtMove - vtMoveLong ;
 
-   double dZI = ptI.z ;
-   double dZF = ptF.z ;
-   double dDeltaZ = ptIT.z - ptI.z ;
-   double dL = dSin * dHei ;
-
-   double dLen = vtMove.Len() ;
-   double dLLong = vtMLong.Len() ;
-   double dLOrt = vtMOrt.Len() ;
-   
-   double dCoef = dLOrt / dLLong ;
-   double dAng = atan( 1 / dCoef) ;
-
-   double dSqRad = dRad * dRad ;
-   double dSemiAxMin = dCos * dRad ;
-
-  // vtV1, vtV2 e vtV3 definiscono gli assi dei sistemi di riferimento intrinseci
-   Vector3d vtV2 = vtMOrt ;  vtV2.Normalize() ;
+   Vector3d vtV1 = vtToolDir ;
+   Vector3d vtV2 = vtMoveOrt ;  vtV2.Normalize() ;
    Vector3d vtV3 = vtV1 ^ vtV2 ;
 
-   Frame3d GridFrame ;    GridFrame.Set( ORIG, X_AX, Y_AX, Z_AX) ;
-   Frame3d CylFrame ;     CylFrame.Set( ptI, vtV1, vtV2, vtV3) ;
-   Frame3d FCylFrame ;    FCylFrame.Set( ptF, vtV1, vtV2, vtV3) ;
-   Frame3d TCylFrame ;    TCylFrame.Set( ptIT, vtV1, vtV2, vtV3) ;
-   Frame3d FTCylFrame ;   FTCylFrame.Set( ptFT, vtV1, vtV2, vtV3) ;
 
-  // Altri punti notevoli
-   Point3d ptIPlus = ptI + dRad * vtV3 ;
-   Point3d ptIMinus = ptI - dRad * vtV3 ;
-   Point3d ptFPlus = ptIPlus + vtMove ;
-   Point3d ptFMinus = ptIMinus + vtMove ;
-
-   Point3d ptIxy( ptI.x, ptI.y, 0) ;
-   Point3d ptFxy( ptF.x, ptF.y, 0) ;
-
-  // Grandezze per la definizione dei piani        
-   Vector3d vtRI = ptI - ORIG ;           double dDotI = vtV1 * vtRI ;             
-   Vector3d vtRF = ptF - ORIG ;           double dDotF = vtV1 * vtRF ;
-
-   Vector3d vtRIT = ptIT - ORIG ;         double dDotIT = vtV1 * vtRIT ;
-   Vector3d vtRFT = ptFT - ORIG ;         double dDotFT = vtV1 * vtRFT ;
-
-   Vector3d vtRIPlus = ptIPlus - ORIG ;                                                                       
-   Vector3d vtRIMinus = ptIMinus - ORIG ;                     
-   Vector3d vtRFPlus = ptFPlus - ORIG ;                
-
-   Vector3d vtW1 = vtV1 ;  vtW1.Rotate( vtV3, - 180 * dAng / PIGRECO) ;  
-   Vector3d vtW2 = vtV2 ;  vtW2.Rotate( vtV3, - 180 * dAng / PIGRECO) ;     
-   
-   Vector3d vtRITPlus = ptIPlus - ORIG - vtV1 * dHei ;  
-
-   Frame3d RotFrame ;     RotFrame.Set( ptI, vtW1, vtW2, vtV3) ;
-   Frame3d TRotFrame ;    TRotFrame.Set( ptIT, vtW1, vtW2, vtV3) ;
+   Frame3d CylFrame ;  CylFrame.Set( ptITip, vtV1, vtV2, vtV3) ;
+ 
 
+  // Parametri geometrici di moto e cilindro
+   double dSqRad = dRad * dRad ;
+   double dLongLen = vtMoveLong.Len() ;
+   double dOrtLen = vtMoveOrt.Len() ;
+  
+  // Minima e massima quota z 
+   double dMin, dMax ;
 
    for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
-
       for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-      
-         double dX = ( i + 0.5) * m_dStep ;
-         double dY = ( j + 0.5) * m_dStep ;
 
-         Point3d ptC( dX, dY, 0) ; 
-                       
-         Vector3d vtCI = ptC - ptIxy ;          
-         Vector3d vtCF = ptC - ptFxy ;
-         Vector3d vtC = ptC - ORIG ;
-          /*
-         double dPI1 = vtCI * vtU1 ;       double dPI2 = vtCI * vtU2 ;
-         double dPF1 = vtCF * vtU1 ;       double dPF2 = vtCF * vtU2 ;
-            
-         // Forse queste parti cilindriche andrebbero fatte per 
-         // intersezione se il versoreutensile è molto verticale   
-        // Parte cilindrica I
-         double dSqRootI = sqrt( dSqRad - dPI2 * dPI2) ;
-         double dPI1_0 = dCos * dSqRootI ;
-         
-           
-         if ( dPI1 >= - dPI1_0 && dPI1 <= dL + dPI1_0 &&
-              dPI2 * dPI2 < dSqRad) {
-         
-           // Minimi
-            if ( dPI1 <= dL - dPI1_0) {
+          
+         Point3d ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ;
 
-               double dZ0 = - dSin * dSqRootI ;
-                                   // da ( dPI1 - dPI1_0) è stato cambiato in ( dPI1 + dPI1_0)
-               dMin = dZI + dZ0 + ( dPI1 + dPI1_0) * dDeltaZ / dL ;
-            }
-            else 
-
-               dMin = ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-           // Massimi
-            if ( dPI1 < dPI1_0) 
-            
-               dMax = ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            else {
-
-               double dZ0 = dSin * dSqRootI ;
-               
-               dMax = dZI + dZ0 + ( dPI1 - dPI1_0) * dDeltaZ / dL ;
-            }
-
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;     
-         }     
-
-        // Parte cilindrica F
-         double dSqRootF = sqrt( dSqRad - dPF2 * dPF2) ;
-         double dPF1_0 = dCos * dSqRootF ;
-         
-         if ( dPF1 >= - dPF1_0 && dPF1 <= dL + dPF1_0 && dPF2 * dPF2 < dSqRad) { // Baubaubau
-         
-           // Minimi
-            if ( dPF1 <= dL - dPF1_0) {
-
-               double dZ0 = - dSin * dSqRootF ;
-                                        // da ( dPI1 - dPI1_0) è stato cambiato in ( dPI1 + dPI1_0)
-               dMin = dZF + dZ0 + ( dPF1 + dPF1_0) * dDeltaZ / dL ;
-            }
-            else 
-
-               dMin = ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-           // Massimi
-            if ( dPF1 < dPF1_0) 
-            
-               dMax = ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            else {
-
-               double dZ0 = dSin * dSqRootF ;
               
-               dMax = dZF + dZ0 + ( dPF1 - dPF1_0) * dDeltaZ / dL ;
-            }
+         Point3d ptInt1, ptInt2 ;
 
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;     
-         } */       
-          
-         if ( IntersZLineCylinder( ptC, ptI, ptIT, vtToolDir, dRad, dMin, dMax)) {
-         
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;   
+        // Cilindro iniziale
+         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, ptInt1, ptInt2)) {
+
+            dMin = min( ptInt1.z, ptInt2.z) ;
+            dMax = max( ptInt1.z, ptInt2.z) ;
+
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;      
          }
-
-         if ( IntersZLineCylinder( ptC, ptF, ptFT, vtToolDir, dRad, dMin, dMax)) {
+               
+        // Cilindro finale
+         if ( IntersLineCylinder( ptC - vtMove, Z_AX, CylFrame, dHei, dRad, ptInt1, ptInt2)) {
          
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;  
-         }      
+            dMin = min( ptInt1.z + vtMove.z, ptInt2.z + vtMove.z) ;
+            dMax = max( ptInt1.z + vtMove.z, ptInt2.z + vtMove.z) ;
 
-        // Parallelepipedo     
-         Point3d ptInt1 = ptC + ( ( ( vtRIPlus - vtC) * vtV3) / ( Z_AX * vtV3)) * Z_AX ;
-         Point3d ptInt2 = ptC + ( ( ( vtRIMinus - vtC) * vtV3) / ( Z_AX * vtV3)) * Z_AX ;
-         Point3d ptInt3 = ptC + ( ( ( vtRIPlus - vtC) * vtV2) / ( Z_AX * vtV2)) * Z_AX ; 
-         Point3d ptInt4 = ptC + ( ( ( vtRIPlus - vtC) * vtW1) / ( Z_AX * vtW1)) * Z_AX ;
-         Point3d ptInt5 = ptC + ( ( ( vtRFPlus - vtC) * vtV2) / ( Z_AX * vtV2)) * Z_AX ;
-         Point3d ptInt6 = ptC + ( ( ( vtRITPlus - vtC) * vtW1) / ( Z_AX * vtW1)) * Z_AX ;
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;  
+         }    
+                 
 
+        // Poliedro interno
+         if ( IntersLineMyPolyhedron(  ptC, Z_AX, CylFrame, dHei, dOrtLen, 2 * dRad, dLongLen, ptInt1, ptInt2)) {
          
-         ptInt1.LocToLoc( GridFrame, CylFrame) ;
-         ptInt2.LocToLoc( GridFrame, CylFrame) ;
-         ptInt3.LocToLoc( GridFrame, CylFrame) ; 
-         ptInt4.LocToLoc( GridFrame, RotFrame) ;
-         ptInt5.LocToLoc( GridFrame, CylFrame) ;
-         ptInt6.LocToLoc( GridFrame, TRotFrame) ;
+            dMin = min( ptInt1.z, ptInt2.z) ;
+            dMax = max( ptInt1.z, ptInt2.z) ;
 
-         bool bFlag = false ;
-         double dLim1, dLim2 ;
-          
-         if ( ptInt1.y >= 0 && ptInt1.y <= dLOrt && 
-              ptInt1.x >= - dHei + ptInt1.y * ( dLLong / dLOrt) && 
-              ptInt1.x <= ptInt1.y * ( dLLong / dLOrt)) {
-
-            ptInt1.LocToLoc( CylFrame, GridFrame) ;
-          
-
-               dLim1 = ptInt1.z ; 
-               bFlag = true ;
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;           
          }
         
-         if ( ptInt2.y >= 0 && ptInt2.y <= dLOrt && 
-              ptInt2.x >= - dHei + ptInt2.y * ( dLLong / dLOrt) && 
-              ptInt2.x <= ptInt2.y * ( dLLong / dLOrt)) {
+        // Cilindro ellittico di punta
+         if ( IntersLineEllipticalCylinder( Z_AX, ptC, CylFrame, dSqRad, 
+                                            dLongLen, dOrtLen, ptInt1, ptInt2)) {
+         
+            dMin = min( ptInt1.z, ptInt2.z) ;
+            dMax = max( ptInt1.z, ptInt2.z) ;
 
-            ptInt2.LocToLoc( CylFrame, GridFrame) ;
-
-            if ( ! bFlag) {
-
-               dLim1 = ptInt2.z ;
-
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt2.z ;
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
          }
 
-         if ( ptInt3.z >= - dRad && ptInt3.z <= dRad &&
-              ptInt3.x >= - dHei && ptInt3.x <= 0) {
+        // 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.
+         if ( IntersLineEllipticalCylinder( Z_AX, ptC - dHei * vtV1, CylFrame, dSqRad,
+                                            dLongLen, dOrtLen, ptInt1, ptInt2)) {
 
-            ptInt3.LocToLoc( CylFrame, GridFrame) ;
+            dMin = min( ptInt1.z + dHei * vtV1.z, ptInt2.z + dHei * vtV1.z) ;
+            dMax = max( ptInt1.z + dHei * vtV1.z, ptInt2.z + dHei * vtV1.z) ;
 
-            if ( ! bFlag) {
-
-               dLim1 = ptInt3.z ;
-
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt3.z ;
-         }
-
-         if ( ptInt4.z >= - dRad && ptInt4.z <= dRad &&
-              ptInt4.y >= 0 && ptInt4.y <= dLen) {
-
-             ptInt4.LocToLoc( RotFrame, GridFrame) ;
-
-            if ( ! bFlag) {
-
-               dLim1 = ptInt4.z ;
-
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt4.z ;
-         }
-
-         if ( ptInt5.z >= - dRad && ptInt5.z <= dRad &&
-              ptInt5.x >= dLLong- dHei && ptInt5.x <= dLLong) {
-
-            ptInt5.LocToLoc( CylFrame, GridFrame) ;
-
-            if ( ! bFlag) {
-
-               dLim1 = ptInt5.z ;
-
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt5.z ;
-         }
-
-         if ( ptInt6.z >= - dRad && ptInt6.z <= dRad &&
-              ptInt6.y >= 0 && ptInt6.y <= dLen) {
-
-             ptInt6.LocToLoc( TRotFrame, GridFrame) ;
-
-            if ( ! bFlag) {
-
-               dLim1 = ptInt6.z ;
-
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt6.z ;
-         } 
-
-         
-         if ( bFlag) {    // Una linea non confinata se entra in un volume chiuso ci deve uscire
-
-            dMin = min( dLim1, dLim2) ;
-            dMax = max( dLim1, dLim2) ;
-
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ; 
-         }       
-
-        // Traslazione dell'ellisse
-         
-         Vector3d vtK = Z_AX ;
-
-         vtK.LocToLoc( GridFrame, CylFrame) ;
-         ptC.LocToLoc( GridFrame, CylFrame) ;
-
-         std::vector <double> vdCoef(3);
-         std::vector <double> vdRoots;
-
-         vdCoef[0] = dCoef * dCoef * ptC.x * ptC.x + ptC.y * ptC.y + ptC.z * ptC.z - 2 * dCoef * ptC.x * ptC.y - dSqRad ;
-         vdCoef[1] = 2 * ( dCoef * dCoef * vtK.x * ptC.x + vtK.y * ptC.y + vtK.z * ptC.z - dCoef * ( vtK.x * ptC.y + vtK.y * ptC.x)) ;
-         vdCoef[2] = dCoef * dCoef * vtK.x * vtK.x + vtK.y * vtK.y + vtK.z * vtK.z - 2 * dCoef * vtK.x * vtK.y ;
-
-
-         int nRoot = PolynomialRoots( 2, vdCoef, vdRoots) ;
-            
-         if ( nRoot == 0 || nRoot == 1) {
-
-            Point3d ptPi ;  ptPi.x = dX ;  ptPi.y = dY ;  ptPi.z = ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            Point3d ptPf ;  ptPf.x = dX ;  ptPf.y = dY ;  ptPf.z = ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            ptPi.LocToLoc( GridFrame, CylFrame) ;
-            ptPf.LocToLoc( GridFrame, FCylFrame) ;
-
-            if ( ptPi.y * ptPi.y + ptPi.z * ptPi.z < dSqRad && 
-                 ptPf.y * ptPf.y + ptPf.z * ptPf.z < dSqRad) {
-
-                ptPi.LocToLoc( CylFrame, GridFrame) ;
-                ptPf.LocToLoc( FCylFrame, GridFrame) ;
-
-                dMin = min( ptPi.z, ptPf.z) ;
-                dMax = max( ptPi.z, ptPf.z) ;
-
-                SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }        
-         }
-         else if ( nRoot == 2) {
-
-            Point3d ptInter1 = ptC + vdRoots[0] * vtK ;
-            Point3d ptInter2 = ptC + vdRoots[1] * vtK ;
-
-   
-            if ( ptInter1.x > ptInter2.x) {
-         
-               Point3d ptTemp = ptInter1 ;
-               ptInter1 = ptInter2 ;
-               ptInter2 = ptTemp ;
-            }
-
-            if ( ptInter1.x > 0 && ptInter1.x < dLLong &&
-                 ptInter2.x > dLLong) {
-
-               ptInter1.LocToLoc( CylFrame, GridFrame) ;
-
-               dMin = min( ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter1.z) ;
-               dMax = max( ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptInter1.x > 0 && ptInter2.x < dLLong) {
-
-               ptInter1.LocToLoc( CylFrame, GridFrame) ;
-               ptInter2.LocToLoc( CylFrame, GridFrame) ;
-
-               dMin = min( ptInter1.z, ptInter2.z) ;
-               dMax = max( ptInter1.z, ptInter2.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptInter1.x < 0 && ptInter2.x > dLLong) {
-
-               dMin = min( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-         
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;         
-            }
-            else if ( ptInter1.x < 0 && ptInter2.x > 0 && ptInter2.x < dLLong) {
-
-               ptInter2.LocToLoc( CylFrame, GridFrame) ;
-
-               dMin = min( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter2.z) ;
-               dMax = max( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter2.z) ;
-         
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-         }    
-
-         ptC.LocToLoc( CylFrame, TCylFrame) ; 
-         vtK.LocToLoc( CylFrame, TCylFrame) ;
-
-         std::vector <double> vdTCoef(3);
-         std::vector <double> vdTRoots;
-
-         vdTCoef[0] = dCoef * dCoef * ptC.x * ptC.x + ptC.y * ptC.y + ptC.z * ptC.z - 2 * dCoef * ptC.x * ptC.y - dSqRad ;
-         vdTCoef[1] = 2 * ( dCoef * dCoef * vtK.x * ptC.x + vtK.y * ptC.y + vtK.z * ptC.z - dCoef * ( vtK.x * ptC.y + vtK.y * ptC.x)) ;
-         vdTCoef[2] = dCoef * dCoef * vtK.x * vtK.x + vtK.y * vtK.y + vtK.z * vtK.z - 2 * dCoef * vtK.x * vtK.y ;
-
-         int nTRoot = PolynomialRoots( 2, vdTCoef, vdTRoots) ;
-               
-         if ( nTRoot == 0 || nTRoot == 1) {
-
-            Point3d ptPi ;  ptPi.x = dX ;  ptPi.y = dY ;  ptPi.z = ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            Point3d ptPf ;  ptPf.x = dX ;  ptPf.y = dY ;  ptPf.z = ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            ptPi.LocToLoc( GridFrame, TCylFrame) ;
-            ptPf.LocToLoc( GridFrame, FTCylFrame) ;
-
-            if ( ptPi.y * ptPi.y + ptPi.z * ptPi.z < dSqRad && 
-                 ptPf.y * ptPf.y + ptPf.z * ptPf.z < dSqRad) {
-
-                ptPi.LocToLoc( TCylFrame, GridFrame) ;
-                ptPf.LocToLoc( FTCylFrame, GridFrame) ;
-
-                dMin = min( ptPi.z, ptPf.z) ;
-                dMax = max( ptPi.z, ptPf.z) ;
-
-                SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }        
-         
-         }
-         else if ( nTRoot == 2) {
-
-            Point3d ptTInter1 = ptC + vdTRoots[0] * vtK ;
-            Point3d ptTInter2 = ptC + vdTRoots[1] * vtK ;
-
-            if ( ptTInter1.x > ptTInter2.x) {
-         
-               Point3d ptTemp = ptTInter1 ;
-               ptTInter1 = ptTInter2 ;
-               ptTInter2 = ptTemp ;
-            }
-
-            if ( ptTInter1.x > 0 && ptTInter1.x < dLLong &&
-                 ptTInter2.x > dLLong) {
-
-               ptTInter1.LocToLoc( TCylFrame, GridFrame) ;
-
-               dMin = min( ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter1.z) ;
-               dMax = max( ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptTInter1.x > 0 && ptTInter2.x < dLLong) {
-
-               ptTInter1.LocToLoc( TCylFrame, GridFrame) ;
-               ptTInter2.LocToLoc( TCylFrame, GridFrame) ;
-
-               dMin = min( ptTInter1.z, ptTInter2.z) ;
-               dMax = max( ptTInter1.z, ptTInter2.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptTInter1.x < 0 && ptTInter2.x > dLLong) {
-
-               dMin = min( ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptTInter1.x < 0 && ptTInter2.x > 0 && ptTInter2.x < dLLong) {
-
-               ptTInter2.LocToLoc( TCylFrame, GridFrame) ;
-
-               dMin = min( ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter2.z) ;
-               dMax = max( ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter2.z) ;
-         
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
+            SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;  
          }  
       }
    }
-
-   return true ;                                        
+   return true ;       
 }
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dMaxRad, double dMinRad)
+VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, 
+                            double dHei, double dMaxRad, double dMinRad)
 {
-   double dMin, dMax ;
    unsigned int nStartI, nStartJ, nEndI, nEndJ ;
 
-   bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir, vtToolDir, nStartI, nStartJ, nEndI, nEndJ, dMaxRad, dMinRad, dHei) ;
+   bool Control = BBoxComponent( nGrid, ptS, ptE, vtToolDir, vtToolDir, nStartI, nStartJ, nEndI, nEndJ,
+                                 dMaxRad, dMinRad, dHei) ;
 
    if ( ! Control)
       return true ;
 
+  // Geometria del cono
    double dDeltaR = dMaxRad - dMinRad ;
    double dSqMaxRad = dMaxRad * dMaxRad ;
    double dSqMinRad = dMinRad * dMinRad ;
 
+  // Studio simmetrie
    Point3d ptI = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) ;
    Point3d ptF = ( vtToolDir * ( ptE - ptS) > 0 ? ptE : ptS) ;
 
@@ -3862,866 +3434,278 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
    double dL = ( ( dMaxRad * dHei) / ( dDeltaR)) ;
    double dl = dL - dHei ;
 
-   Point3d ptIV = ptI - vtToolDir * dL ;
-   Point3d ptFV = ptF - vtToolDir * dL ;
+   Point3d ptV = ptI - vtToolDir * dL ;
 
-   Vector3d vtMove = ptF - ptI ;     double dLen = vtMove.Len() ;
-
-   Vector3d vtMLong = ( vtMove * vtToolDir) * vtToolDir ;  double dLLong = vtMLong.Len() ;
-   Vector3d vtMOrt = vtMove - vtMLong ;     double dLOrt = vtMOrt.Len() ;
+  // Vettori caratteristici del movimento
+   Vector3d vtMove = ptF - ptI ;
+   Vector3d vtMvLong = ( vtMove * vtToolDir) * vtToolDir ; 
+   Vector3d vtMvOrt = vtMove - vtMvLong ;
 
+  // Terna destrorsa e unitaria
    Vector3d vtV1 = vtToolDir ;
-   Vector3d vtV2 = vtMOrt ;       vtV2.Normalize() ;
+   Vector3d vtV2 = vtMvOrt ;  vtV2.Normalize() ;
    Vector3d vtV3 = vtV1 ^ vtV2 ;
 
-  // Apertura del cono e parametri per determinare i piani
-   double dTan = dDeltaR / dHei ;
-   double dRatio = dLLong / dLOrt ;
+  // Sistema di riferimento intrinseco del movimento
+   Frame3d ConusFrame ;  ConusFrame.Set( ptV, vtV1, vtV2, vtV3) ;
 
+  // Dimensioni lineari movimento
+   double dLongLen = vtMvLong.Len() ;
+   double dOrtLen = vtMvOrt.Len() ;
+
+  // Apertura del cono 
+   double dTan = dDeltaR / dHei ;
+   double dRatio = dLongLen / dOrtLen ;
+
+  // Per costruire piani laterali poliedro interno
    double dCos = dTan * dRatio ;
    double dSin = ( 1 - dCos * dCos > 0 ? sqrt( 1 - dCos * dCos) : 0) ;
-
    double dDen = sqrt( 1 + dTan * dTan) ;
-   double dCoef = dLOrt / dLLong ;   // Per traslazione ellissi
 
-   if ( dRatio > 1 / dTan)
+  // Dimensioni lineari descriventi il poliedro interno
+   double dLenX = dLongLen ;
+   double dLenY = dOrtLen ;
+   double dLenZ = dSin * dMinRad ;
+   double dDeltaX = dHei ;
+   double dDeltaY = dCos * dDeltaR ;
+   double dDeltaZ = dSin * dDeltaR ;
 
-      return CompConusAux_Milling( nGrid, ptI, ptF, vtV1, vtV2, vtV3, nStartI, nStartJ, nEndI, nEndJ, dHei, dMaxRad, dMinRad, dCoef) ;
+  // Sistema di riferimento poliedro
+   Point3d ptO = ptV + vtV1 * dl + vtV2 * ( dCos * dMinRad) ;
 
-  
-  // Versori normali e prodotti scalari per per determinare i piani
-  // Piani laterali:
-   Vector3d vtNs = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 + ( dSin / dDen) * vtV3 ;
-   Vector3d vtNd = - ( dTan / dDen) * vtV1 + ( dCos / dDen) * vtV2 - ( dSin / dDen) * vtV3 ;
-   Vector3d vtRIV = ptIV - ORIG ;
-  // double dDots = vtRIV * vtNs ;     // forse qui è meglio due punti ptIT + vtV3 * dMinRad e ptIT - vtV3 * dMinRad 
-  // double dDotd = vtRIV * vtNd ;
+   Frame3d PolyFrame ;  PolyFrame.Set( ptO, vtV1, vtV2, vtV3) ;
 
-   Vector3d vtS1 = vtNs ;
-   Vector3d vtS2 = vtMove ;  vtS2.Normalize() ;     // double dDotTestqs = vtS1 * vtS2 ;
-   Vector3d vtS3 = vtS1 ^ vtS2 ;
+  // Versori piani nel riferimento poliedro 
+  // (Sx, Dx, Iniziale, Finale, Up, Down sono riferiti
+  // al sistema di riferimento):
 
-   Vector3d vtD1 = vtNd ; 
-   Vector3d vtD2 = vtS2 ;    // double dDotTestD = vtD1 * vtD2 ;
-   Vector3d vtD3 = vtD1 ^ vtD2 ;
+  // Sx, Dx
+   Vector3d vtNs( - ( dTan / dDen), ( dCos / dDen), ( dSin / dDen)) ;
+   Vector3d vtNd( - ( dTan / dDen), ( dCos / dDen), - ( dSin / dDen)) ;
 
-   Point3d ptSloc = ptI + vtV2 * ( dMaxRad * dCos) + vtV3 * ( dMaxRad * dSin) ;    
-   Point3d ptD = ptI + vtV2 * ( dMaxRad * dCos) - vtV3 * ( dMaxRad * dSin) ;
-   Point3d ptST = ptIT + vtV2 * ( dMinRad * dCos) + vtV3 * ( dMinRad * dSin) ; 
+  // Iniziale e finale
+   Vector3d vtIF( - dDeltaY, dDeltaX, 0) ;
 
-   Vector3d vtLen = ptST - ptSloc ;
+  // Up e Down
+   Vector3d vtUD( - dLenY, dLenX, 0) ;
 
-   double dPLong = abs( vtLen * vtS3) ;
-   double dPOrt = abs( vtLen * vtS2) ;
-  // Vector3d vtLTr = vtLen - dPLong * vtS3 ;
+  // Punti dei piani (sempre espressi nel sistema PolyFrame)
+   Point3d ptFacet135( 0, 0, dLenZ) ;
+   Point3d ptFacet246( dLenX + dDeltaX, dLenY + dDeltaY, - dLenZ - dDeltaZ) ;
 
-  // double dPOrt = vtLTr.Len() ;
-
-  // Piani di fondo e punta:
-   Vector3d vtU1 = - dLOrt * vtV1 + dLLong * vtV2 ;   vtU1.Normalize() ;
-   Vector3d vtU2 = vtMove ;   vtU2.Normalize() ;  // double dDotTest = vtU1 * vtU2 ;
-   Vector3d vtU3 = vtU1 ^ vtU2 ;
-   
-   Point3d ptU = ptI + vtV2 * ( dMaxRad * dCos) ;
-   Point3d ptTU = ptIT + vtV2 * ( dMinRad * dCos) ;
-
-   Vector3d vtRU = ptU - ORIG ;    // double dDotB = vtRU * vtU1 ;
-   Vector3d vtRUT = ptTU - ORIG ;  // double dDotT = vtRUT * vtU1 ;
-
-  // Piani finale e iniziale:
-   Vector3d vtVAux = ptTU - ptU ;   
-   
-   double dAuxOrt = vtVAux * vtV2 ; 
-   double dAuxLong = vtVAux * vtV1 ;     // Tenere in considerazione per tronchi con dimensioni tali da poter approssimare tori
-
-   Vector3d vtW1 = - dAuxOrt * vtV1 + dAuxLong * vtV2 ;  double dLAux1 = vtW1.Len() ;  vtW1.Normalize() ;
-   Vector3d vtW2 = vtVAux ;  double dLAux2 = vtW2.Len() ;  vtW2.Normalize() ;  //  double dDottest = vtW1 * vtW2 ;
-   Vector3d vtW3 = vtW1 ^ vtW2 ;
-
-   double dPr2 = vtLen * vtW2 ;     double prova1 = vtLen * vtW3 ;  double prova2 = dSin * dDeltaR ;
-
-   Point3d ptFU = ptU + vtMove ;
-   
-   Vector3d vtRFU = ptFU - ORIG ;  // double dDotPF = vtRFU * vtW1 ;
-
-  // Piani cono:
-   Vector3d vtRCI = ptI - ORIG ;      double dDotCI = vtRCI * vtV1 ;
-   Vector3d vtRCIT = ptIT - ORIG ;    double dDotCIT = vtRCIT * vtV1 ;
-
-   Vector3d vtRCF = ptF - ORIG ;      double dDotCF = vtRCF * vtV1 ;
-   Vector3d vtRCFT = ptFT - ORIG ;    double dDotCFT = vtRCFT * vtV1 ;
-
-
-  // Sistemi di riferimento
-   Frame3d GridFrame ;         GridFrame.Set( ORIG, X_AX, Y_AX, Z_AX) ;
-   Frame3d IConeFrame ;        IConeFrame.Set( ptIV, vtV1, vtV2, vtV3) ;
-   Frame3d FConeFrame ;        FConeFrame.Set( ptFV, vtV1, vtV2, vtV3) ;
-   Frame3d PlSFrame ;          PlSFrame.Set( ptSloc, vtS1, vtS2, vtS3) ;
-   Frame3d PlDFrame ;          PlDFrame.Set( ptD, vtD1, vtD2, vtD3) ;
-   Frame3d PlBFrame ;          PlBFrame.Set( ptU, vtU1, vtU2, vtU3) ;
-   Frame3d PlTFrame ;          PlTFrame.Set( ptTU, vtU1, vtU2, vtU3) ;
-   Frame3d PlIFrame ;          PlIFrame.Set( ptU, vtW1, vtW2, vtW3) ;
-   Frame3d PlFFrame ;          PlFFrame.Set( ptFU, vtW1, vtW2, vtW3) ;
-   Frame3d LargeEllipse ;      LargeEllipse.Set( ptI, vtV1, vtV2, vtV3) ;
-   Frame3d FLargeEllipse ;     FLargeEllipse.Set( ptF, vtV1, vtV2, vtV3) ;
-   Frame3d SmallEllipse ;      SmallEllipse.Set( ptIT, vtV1, vtV2, vtV3) ;
-   Frame3d FSmallEllipse ;     FSmallEllipse.Set( ptFT, vtV1, vtV2, vtV3) ;
-
-  
-   for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
-
-      for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-      
-         double dX = ( i + 0.5) * m_dStep ;  double dY = ( j + 0.5) * m_dStep ;
-
-         Point3d ptC( dX, dY, 0) ;
-         Vector3d vtC = ptC - ORIG ;
-         Vector3d vtK = Z_AX ;
-          
-         Point3d ptIntLC1, ptIntLC2 ;
-         double dPMax, dPMin ;  
-          
-        // Cono iniziale
-         if ( IntersLineConus( ptC, vtK, IConeFrame, dTan, dl, dL, ptIntLC1, ptIntLC2)) {
-
-            dPMin = min( ptIntLC1.z, ptIntLC2.z) ;
-            dPMax = max( ptIntLC1.z, ptIntLC2.z) ;
-
-            SubtractIntervals( nGrid, i, j, dPMin, dPMax) ;
-         }
-         
-        // Cono finale
-         if ( IntersLineConus( ptC, vtK, FConeFrame, dTan, dl, dL, ptIntLC1, ptIntLC2)) {
-
-            dPMin = min( ptIntLC1.z, ptIntLC2.z) ;
-            dPMax = max( ptIntLC1.z, ptIntLC2.z) ;
-
-            SubtractIntervals( nGrid, i, j, dPMin, dPMax) ;
-         }   
-               /*
-        // Cono I
-         ptC.LocToLoc( GridFrame, IConeFrame) ;
-         vtK.LocToLoc( GridFrame, IConeFrame) ;
-
-         std::vector <double> vdIConeCoef(3);
-         std::vector <double> vdIConeRoots;
-          
-         vdIConeCoef[0] = dTan * dTan * ptC.x * ptC.x - ptC.y * ptC.y - ptC.z * ptC.z ;
-         vdIConeCoef[1] = 2 * ( dTan * dTan * ptC.x * vtK.x - ptC.y * vtK.y - ptC.z * vtK.z) ;
-         vdIConeCoef[2] = dTan * dTan * vtK.x * vtK.x - vtK.y * vtK.y - vtK.z * vtK.z ;
-
-         int nIConeRoot = PolynomialRoots( 2, vdIConeCoef, vdIConeRoots) ;
-         
-         if ( nIConeRoot == 1) {
-
-            Point3d ptR1 = ptC + vdIConeRoots[0] * vtK ;
-            
-            if ( ptR1.x >= dl && ptR1.x < dL) {
-
-               ptR1.LocToLoc( IConeFrame, GridFrame) ;
-
-               dMin = min( ptR1.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR1.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;    
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            } 
-            else if ( ptR1.x >= 0 && ptR1.x < dl) {
-
-               dMin = min( ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }    
-         }
-         else if ( nIConeRoot == 2) {
-
-            Point3d ptR1 = ptC + vdIConeRoots[0] * vtK ;
-            Point3d ptR2 = ptC + vdIConeRoots[1] * vtK ;
-
-            if ( ptR1.x > ptR2.x) {
-            
-               Point3d ptTemp = ptR1 ;
-               ptR1 = ptR2 ;
-               ptR2 = ptTemp ;
-            }
-            
-            if ( ptR1.x < 0 && ptR2.x > 0 && ptR2.x < dl) {
-
-               dMin = min( ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x < 0 && ptR2.x >= dl && ptR2.x < dL) {
-            
-               ptR2.LocToLoc( IConeFrame, GridFrame) ;
-
-               dMin = min( ptR2.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR2.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x > 0 && ptR1.x < dl && ptR2.x >= dl && ptR2.x < dL) {
-
-               ptR2.LocToLoc( IConeFrame, GridFrame) ;
-         
-               dMin = min( ptR2.z, ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR2.z, ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x > 0 && ptR1.x < dl && ptR2.x >= dL) {
-
-               dMin = min( ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;               
-            }
-            else if ( ptR1.x >= dl && ptR1.x < dL && ptR2.x < dL) {
-
-               ptR1.LocToLoc( IConeFrame, GridFrame) ;
-               ptR2.LocToLoc( IConeFrame, GridFrame) ;
-            
-               dMin = min( ptR1.z, ptR2.z) ;
-               dMax = max( ptR1.z, ptR2.z) ;
-            
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= dl && ptR1.x < dL && ptR2.x >= dL) {
-            
-               ptR1.LocToLoc( IConeFrame, GridFrame) ;
-
-               dMin = min( ptR1.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR1.z, ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }      
-         }   
-
-        // Cono F
-         ptC.LocToLoc( IConeFrame, FConeFrame) ;
-         vtK.LocToLoc( IConeFrame, FConeFrame) ;
-         
-         std::vector <double> vdFConeCoef(3);
-         std::vector <double> vdFConeRoots;
-
-         vdFConeCoef[0] = dTan * dTan * ptC.x * ptC.x - ptC.y * ptC.y - ptC.z * ptC.z ;
-         vdFConeCoef[1] = 2 * ( dTan * dTan * ptC.x * vtK.x - ptC.y * vtK.y - ptC.z * vtK.z) ;
-         vdFConeCoef[2] = dTan * dTan * vtK.x * vtK.x - vtK.y * vtK.y - vtK.z * vtK.z ;
-
-         int nFConeRoot = PolynomialRoots( 2, vdFConeCoef, vdFConeRoots) ;
-        
-         if ( nFConeRoot == 1) {
-
-            Point3d ptR1 = ptC + vdFConeRoots[0] * vtK ;
-
-            if ( ptR1.x >= dl && ptR1.x < dL) {
-
-               ptR1.LocToLoc( FConeFrame, GridFrame) ;
-
-               dMin = min( ptR1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;    
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            } 
-            else if ( ptR1.x >= 0 && ptR1.x < dl) {
-
-               dMin = min( ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;               
-            }
-         }
-         else if ( nFConeRoot == 2) {
-
-            Point3d ptR1 = ptC + vdFConeRoots[0] * vtK ;
-            Point3d ptR2 = ptC + vdFConeRoots[1] * vtK ;
-
-            if ( ptR1.x > ptR2.x) {
-            
-               Point3d ptTemp = ptR1 ;
-               ptR1 = ptR2 ;
-               ptR2 = ptTemp ;
-            }
-
-
-            if ( ptR1.x < 0 && ptR2.x > 0 && ptR2.x < dl) {
-
-               dMin = min( ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x < 0 && ptR2.x >= dl && ptR2.x < dL) {
-            
-               ptR2.LocToLoc( FConeFrame, GridFrame) ;
-
-               dMin = min( ptR2.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR2.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x > 0 && ptR1.x < dl && ptR2.x >= dl && ptR2.x < dL) {
-
-               ptR2.LocToLoc( FConeFrame, GridFrame) ;
-
-               dMin = min( ptR2.z, ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR2.z, ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x > 0 && ptR1.x < dl && ptR2.x >= dL) {
-
-               dMin = min( ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= dl && ptR1.x < dL && ptR2.x < dL) {
-
-               ptR1.LocToLoc( FConeFrame, GridFrame) ;
-               ptR2.LocToLoc( FConeFrame, GridFrame) ;
-            
-               dMin = min( ptR1.z, ptR2.z) ;
-               dMax = max( ptR1.z, ptR2.z) ;
-            
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= dl && ptR1.x < dL && ptR2.x >= dL) {
-            
-               ptR1.LocToLoc( FConeFrame, GridFrame) ;
-
-               dMin = min( ptR1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;           
-            }
-         }    */
-                
-              
-
-        // Solido interno
-           
-        // ptC.LocToLoc( FConeFrame, GridFrame) ;
-        // vtK.LocToLoc( FConeFrame, GridFrame) ;     
-          
-         Point3d ptInt1 = ptC + ( ( ( vtRIV - vtC) * vtS1) / ( vtK * vtS1)) * vtK ;
-         Point3d ptInt2 = ptC + ( ( ( vtRIV - vtC) * vtD1) / ( vtK * vtD1)) * vtK ;
-         Point3d ptInt3 = ptC + ( ( ( vtRU - vtC) * vtU1) / ( vtK * vtU1)) * vtK ;
-         Point3d ptInt4 = ptC + ( ( ( vtRUT - vtC) * vtU1) / ( vtK * vtU1)) * vtK ;
-         Point3d ptInt5 = ptC + ( ( ( vtRU - vtC) * vtW1) / ( vtK * vtW1)) * vtK ;
-         Point3d ptInt6 = ptC + ( ( ( vtRFU - vtC) * vtW1) / ( vtK * vtW1)) * vtK ;
-
-         ptInt1.LocToLoc( GridFrame, PlSFrame) ;
-         ptInt2.LocToLoc( GridFrame, PlDFrame) ;
-         ptInt3.LocToLoc( GridFrame, PlBFrame) ;
-         ptInt4.LocToLoc( GridFrame, PlTFrame) ;
-         ptInt5.LocToLoc( GridFrame, PlIFrame) ;
-         ptInt6.LocToLoc( GridFrame, PlFFrame) ;
-
-         double dLim1, dLim2 ;
-         bool bFlag = false ;
-         
-         if ( ptInt1.z >= 0 && ptInt1.z <= dPLong &&
-              ptInt1.y >= - ptInt1.z * dPOrt / dPLong && 
-              ptInt1.y <= dLen - ptInt1.z * dPOrt / dPLong ) {
-         
-            ptInt1.LocToLoc( PlSFrame, GridFrame) ;
-
-            dLim1 = ptInt1.z ;
-            bFlag = true ;
-         }   
-         
-         if ( ptInt2.z >= - dPLong && ptInt2.z <= 0 &&
-              ptInt2.y >= ptInt2.z * dPOrt / dPLong &&
-              ptInt2.y <= dLen + ptInt2.z * dPOrt / dPLong) {
-
-            ptInt2.LocToLoc( PlDFrame, GridFrame) ;
-         
-            if ( ! bFlag) {
-
-               dLim1 = ptInt2.z ;
-               bFlag = true ;
-            }
-            else 
-            
-               dLim2 = ptInt2.z ;
-         }
-         
-         if ( ptInt3.y >= 0 && ptInt3.y <= dLen &&
-              ptInt3.z > - dMaxRad * dSin && 
-              ptInt3.z < dMaxRad * dSin) {
-         
-            ptInt3.LocToLoc( PlBFrame, GridFrame) ;
-
-            if ( ! bFlag) {
-            
-               dLim1 = ptInt3.z ;
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt3.z ;
-         }
-           
-         if ( ptInt4.y >= 0 && ptInt4.y <= dLen &&
-              ptInt4.z > - dMinRad * dSin && 
-              ptInt4.z < dMinRad * dSin) {
-         
-            ptInt4.LocToLoc( PlTFrame, GridFrame) ;
-
-            if ( ! bFlag) {
-            
-               dLim1 = ptInt4.z ;
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt4.z ;
-         }  
-          
-         if ( ptInt5.y >= 0 && ptInt5.y <= dPr2 &&
-              ptInt5.z > - dSin * dMaxRad + ptInt5.y * prova1 / dPr2 &&
-              ptInt5.z < dSin * dMaxRad - ptInt5.y * prova1 / dPr2) {
-         
-            ptInt5.LocToLoc( PlIFrame, GridFrame) ;
-
-            if ( ! bFlag) {
-            
-               dLim1 = ptInt5.z ;
-               bFlag = true ;
-            }
-            else
-
-               dLim2 = ptInt5.z ;
-         } 
-
-         if ( ptInt6.y >= 0 && ptInt6.y <= dPr2 &&
-              ptInt6.z > - dSin * dMaxRad + ptInt6.y * prova1 / dPr2 &&
-              ptInt6.z < dSin * dMaxRad - ptInt6.y * prova1 / dPr2) {
-         
-            ptInt6.LocToLoc( PlFFrame, GridFrame) ;
-
-            if ( ! bFlag) {
-            
-               dLim1 = ptInt6.z ;
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt6.z ;
-         }   
-          
-         if( bFlag) {
-         
-            dMin = min( dLim1, dLim2) ;
-            dMax = max( dLim1, dLim2) ;
-
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-         }       
-                     
-         // Traslazioni ellissi     
-                          
-         ptC.LocToLoc( GridFrame, LargeEllipse) ;
-         vtK.LocToLoc( GridFrame, LargeEllipse) ;
-        
-         std::vector <double> vdLargeCoef(3);
-         std::vector <double> vdLargeRoots;
-
-         vdLargeCoef[0] = dCoef * dCoef * ptC.x * ptC.x + ptC.y * ptC.y + ptC.z * ptC.z - 2 * dCoef * ptC.x * ptC.y - dSqMaxRad ;
-         vdLargeCoef[1] = 2 * ( dCoef * dCoef * vtK.x * ptC.x + vtK.y * ptC.y + vtK.z * ptC.z - dCoef * ( vtK.x * ptC.y + vtK.y * ptC.x)) ;
-         vdLargeCoef[2] = dCoef * dCoef * vtK.x * vtK.x + vtK.y * vtK.y + vtK.z * vtK.z - 2 * dCoef * vtK.x * vtK.y ;
-
-
-         int nLRoot = PolynomialRoots( 2, vdLargeCoef, vdLargeRoots) ;
-
-         if ( nLRoot == 0) {
-
-            Point3d ptPi ;  ptPi.x = dX ;  ptPi.y = dY ;  ptPi.z = ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            Point3d ptPf ;  ptPf.x = dX ;  ptPf.y = dY ;  ptPf.z = ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            ptPi.LocToLoc( GridFrame, LargeEllipse) ;
-            ptPf.LocToLoc( GridFrame, FLargeEllipse) ;
-
-            if ( ptPi.y * ptPi.y + ptPi.z * ptPi.z < dSqMaxRad && 
-                 ptPf.y * ptPf.y + ptPf.z * ptPf.z < dSqMaxRad) {
-
-                ptPi.LocToLoc( LargeEllipse, GridFrame) ;
-                ptPf.LocToLoc( FLargeEllipse, GridFrame) ;
-
-                dMin = min( ptPi.z, ptPf.z) ;
-                dMax = max( ptPi.z, ptPf.z) ;
-
-                SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-         }
-         else if ( nLRoot == 2) {
-
-            Point3d ptInter1 = ptC + vdLargeRoots[0] * vtK ;
-            Point3d ptInter2 = ptC + vdLargeRoots[1] * vtK ;
-
-   
-            if ( ptInter1.x > ptInter2.x) {
-         
-               Point3d ptTemp = ptInter1 ;
-               ptInter1 = ptInter2 ;
-               ptInter2 = ptTemp ;
-            }
-
-            if ( ptInter1.x > 0 && ptInter1.x < dLLong &&
-                 ptInter2.x > dLLong) {
-
-               ptInter1.LocToLoc( LargeEllipse, GridFrame) ;
-
-               dMin = min( ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter1.z) ;
-               dMax = max( ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptInter1.x > 0 && ptInter2.x < dLLong) {
-
-               ptInter1.LocToLoc( LargeEllipse, GridFrame) ;
-               ptInter2.LocToLoc( LargeEllipse, GridFrame) ;
-
-               dMin = min( ptInter1.z, ptInter2.z) ;
-               dMax = max( ptInter1.z, ptInter2.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptInter1.x < 0 && ptInter2.x > dLLong) {
-
-               dMin = min( ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-         
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;         
-            }
-            else if ( ptInter1.x < 0 && ptInter2.x > 0 && ptInter2.x < dLLong) {
-
-               ptInter2.LocToLoc( LargeEllipse, GridFrame) ;
-
-               dMin = min( ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter2.z) ;
-               dMax = max( ( dDotCI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter2.z) ;
-         
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-         }   
-
-         ptC.LocToLoc( LargeEllipse, SmallEllipse) ; 
-         vtK.LocToLoc( LargeEllipse, SmallEllipse) ;
-         
-         std::vector <double> vdSmallCoef(3);
-         std::vector <double> vdSmallRoots;
-
-         vdSmallCoef[0] = dCoef * dCoef * ptC.x * ptC.x + ptC.y * ptC.y + ptC.z * ptC.z - 2 * dCoef * ptC.x * ptC.y - dSqMinRad ;
-         vdSmallCoef[1] = 2 * ( dCoef * dCoef * vtK.x * ptC.x + vtK.y * ptC.y + vtK.z * ptC.z - dCoef * ( vtK.x * ptC.y + vtK.y * ptC.x)) ;
-         vdSmallCoef[2] = dCoef * dCoef * vtK.x * vtK.x + vtK.y * vtK.y + vtK.z * vtK.z - 2 * dCoef * vtK.x * vtK.y ;
-
-         int nSRoot = PolynomialRoots( 2, vdSmallCoef, vdSmallRoots) ;
-
-         if ( nSRoot == 0) {
-
-            Point3d ptPi ;  ptPi.x = dX ;  ptPi.y = dY ;  ptPi.z = ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            Point3d ptPf ;  ptPf.x = dX ;  ptPf.y = dY ;  ptPf.z = ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            ptPi.LocToLoc( GridFrame, SmallEllipse) ;
-            ptPf.LocToLoc( GridFrame, FSmallEllipse) ;
-
-            if ( ptPi.y * ptPi.y + ptPi.z * ptPi.z < dSqMinRad && 
-                 ptPf.y * ptPf.y + ptPf.z * ptPf.z < dSqMinRad) {
-
-                ptPi.LocToLoc( SmallEllipse, GridFrame) ;
-                ptPf.LocToLoc( FSmallEllipse, GridFrame) ;
-
-                dMin = min( ptPi.z, ptPf.z) ;
-                dMax = max( ptPi.z, ptPf.z) ;
-
-                SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-         }
-         else if ( nSRoot == 2) {
-
-            Point3d ptTInter1 = ptC + vdSmallRoots[0] * vtK ;
-            Point3d ptTInter2 = ptC + vdSmallRoots[1] * vtK ;
-
-            if ( ptTInter1.x > ptTInter2.x) {
-         
-               Point3d ptTemp = ptTInter1 ;
-               ptTInter1 = ptTInter2 ;
-               ptTInter2 = ptTemp ;
-            }
-
-            if ( ptTInter1.x > 0 && ptTInter1.x < dLLong &&
-                 ptTInter2.x > dLLong) {
-
-               ptTInter1.LocToLoc( SmallEllipse, GridFrame) ;
-
-               dMin = min( ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter1.z) ;
-               dMax = max( ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptTInter1.x > 0 && ptTInter2.x < dLLong) {
-
-               ptTInter1.LocToLoc( SmallEllipse, GridFrame) ;
-               ptTInter2.LocToLoc( SmallEllipse, GridFrame) ;
-
-               dMin = min( ptTInter1.z, ptTInter2.z) ;
-               dMax = max( ptTInter1.z, ptTInter2.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptTInter1.x < 0 && ptTInter2.x > dLLong) {
-
-               dMin = min( ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotCFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptTInter1.x < 0 && ptTInter2.x > 0 && ptTInter2.x < dLLong) {
-
-               ptTInter2.LocToLoc( SmallEllipse, GridFrame) ;
-
-               dMin = min( ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter2.z) ;
-               dMax = max( ( dDotCIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter2.z) ;
-         
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }   
-         }   
-      }
-   }
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-VolZmap::CompConusAux_Milling( unsigned int nGrid, const Point3d & ptI, const Point3d & ptF, const Vector3d & vtV1, const Vector3d & vtV2, const Vector3d & vtV3, 
-                               unsigned int & nStI, unsigned int & nStJ, unsigned int & nEnI, unsigned int & nEnJ,
-                               double dHei, double dMaxRad, double dMinRad, double dCoef)
-{
-
-   double dDeltaR = dMaxRad - dMinRad ;
-   double dL = ( ( dMaxRad * dHei) / ( dDeltaR)) ;
-   double dTan = dDeltaR / dHei ;
-   double dl = dL - dHei ;
-
-   double dLLong = abs( ( ptF - ptI) * vtV1) ;
-   double dLOrt = abs( ( ptF - ptI) * vtV2) ;
-   double dSqMaxRad = dMaxRad * dMaxRad ;
-   
-
-   Point3d ptV = ptI - vtV1 * dL ;
-   Point3d ptT = ptI - vtV1 * dHei ;
-
-   Frame3d GridFrame ;         GridFrame.Set( ORIG, X_AX, Y_AX, Z_AX) ;
-   Frame3d ConeFrame ;         ConeFrame.Set( ptV, vtV1, vtV2, vtV3) ;
-   Frame3d IEllipseFrame ;     IEllipseFrame.Set( ptI, vtV1, vtV2, vtV3) ;
-   Frame3d FEllipseFrame ;     FEllipseFrame.Set( ptF, vtV1, vtV2, vtV3) ;
-
-   Vector3d vtI = ptI - ORIG ;      double dDotI = vtI * vtV1 ;
-   Vector3d vtT = ptT - ORIG ;      double dDotT = vtT * vtV1 ;
-   Vector3d vtF = ptF - ORIG ;      double dDotF = vtF * vtV1 ;
-
-   Vector3d vtK = Z_AX ;
-   Vector3d vtKC = vtK ;            vtKC.LocToLoc( GridFrame, ConeFrame) ;
-   Vector3d vtKE = vtK ;            vtKE.LocToLoc( GridFrame, IEllipseFrame) ;
+   double dSqIndet = EPS_SMALL * EPS_SMALL ; 
 
    double dMin, dMax ;
 
-   for ( unsigned int i = nStI ; i <= nEnI ; ++ i) {
+   if ( dRatio * dTan <= 1) {
 
-      for ( unsigned int j = nStJ ; j <= nEnJ ; ++ j) {
+      for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
+         for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
 
-         double dX = ( i + 0.5) * m_dStep ;  double dY = ( j + 0.5) * m_dStep ;
+            double dX = ( i + 0.5) * m_dStep ;
+            double dY = ( j + 0.5) * m_dStep ;
 
-         Point3d ptC( dX, dY, 0) ;  Vector3d vtC = ptC - ORIG ;  
+            Point3d ptC( dX, dY, 0) ;
+
+            Point3d ptInt1, ptInt2 ;
+
+           // Cono iniziale
+            if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, ptInt1, ptInt2)) {
+
+               dMin = min( ptInt1.z, ptInt2.z) ;
+               dMax = max( ptInt1.z, ptInt2.z) ;
+
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
+            }
          
-        // Cono 
-         ptC.LocToLoc( GridFrame, ConeFrame) ;
-        
-         std::vector <double> vdConeCoef(3);
-         std::vector <double> vdConeRoots;
+           // Cono finale
+            if ( IntersLineConus( ptC - vtMove, Z_AX, ConusFrame, dTan, dl, dL, ptInt1, ptInt2)) {
 
-         vdConeCoef[0] = dTan * dTan * ptC.x * ptC.x - ptC.y * ptC.y - ptC.z * ptC.z ;
-         vdConeCoef[1] = 2 * ( dTan * dTan * ptC.x * vtKC.x - ptC.y * vtKC.y - ptC.z * vtKC.z) ;
-         vdConeCoef[2] = dTan * dTan * vtKC.x * vtKC.x - vtKC.y * vtKC.y - vtKC.z * vtKC.z ;
+               dMin = min( ptInt1.z + vtMove.z, ptInt2.z + vtMove.z) ;
+               dMax = max( ptInt1.z + vtMove.z, ptInt2.z + vtMove.z) ;
 
-         int nConeRoot = PolynomialRoots( 2, vdConeCoef, vdConeRoots) ;
-
-         
-         if ( nConeRoot == 1) {
-
-            Point3d ptR1 = ptC + vdConeRoots[0] * vtKC ;
-
-            if ( ptR1.x >= dl && ptR1.x < dL) {
-
-               ptR1.LocToLoc( ConeFrame, GridFrame) ;
-
-               dMin = min( ptR1.z, ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR1.z, ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;    
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            } 
-            else if ( ptR1.x >= 0 && ptR1.x < dl) {
-
-               dMin = min( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-         }
-         else if ( nConeRoot == 2) {
-
-            Point3d ptR1 = ptC + vdConeRoots[0] * vtKC ;
-            Point3d ptR2 = ptC + vdConeRoots[1] * vtKC ;
-
-            if ( ptR1.x > ptR2.x) {
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
+            }   
             
-               Point3d ptTemp = ptR1 ;
-               ptR1 = ptR2 ;
-               ptR2 = ptTemp ;
+           // Solido interno
+            Point3d ptPoly = ptC ;
+            Vector3d vtPoly = Z_AX ;
+
+            ptPoly.ToLoc( PolyFrame) ;
+            vtPoly.ToLoc( PolyFrame) ;
+
+            Point3d ptPoly1 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtNs) / ( vtPoly * vtNs)) * vtPoly ;
+            Point3d ptPoly2 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtNd) / ( vtPoly * vtNd)) * vtPoly ;
+            Point3d ptPoly3 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtIF) / ( vtPoly * vtIF)) * vtPoly ;
+            Point3d ptPoly4 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtIF) / ( vtPoly * vtIF)) * vtPoly ;
+            Point3d ptPoly5 = ptPoly + ( ( ( ptFacet135 - ptPoly) * vtUD) / ( vtPoly * vtUD)) * vtPoly ;
+            Point3d ptPoly6 = ptPoly + ( ( ( ptFacet246 - ptPoly) * vtUD) / ( vtPoly * vtUD)) * vtPoly ;
+
+            int nIntNum = 0 ;
+
+           // Intersezione con la prima faccia
+            if ( dLenY * ptPoly1.x >= dLenX * ptPoly1.y && 
+                 dLenY * ( ptPoly1.x - dDeltaX) <= dLenX * ptPoly1.y  && 
+                 dDeltaX * ptPoly1.y >= dDeltaY * ptPoly1.x && 
+                 dDeltaX * ( ptPoly1.y - dLenY) <= dDeltaY * ( ptPoly1.x - dLenX)) {
+
+               ptInt1 = ptPoly1 ;
+               ++ nIntNum ;
+            }
+           // Intersezione con la seconda faccia
+            if ( dLenY * ptPoly2.x >= dLenX * ptPoly2.y && 
+                 dLenY * ( ptPoly2.x - dDeltaX) <= dLenX * ptPoly2.y  && 
+                 dDeltaX * ptPoly2.y >= dDeltaY * ptPoly2.x && 
+                 dDeltaX * ( ptPoly2.y - dLenY) <= dDeltaY * ( ptPoly2.x - dLenX)) {
+
+               if ( nIntNum == 0) {
+      
+                  ptInt1 = ptPoly2 ;
+                  ++ nIntNum ;
+               }         
+               else if ( ( ptInt1 - ptPoly2).SqLen() > dSqIndet) {
+      
+                  ptInt2 = ptPoly2 ;
+                  ++ nIntNum ;
+               }
+            }
+           // Intersezione con la terza faccia
+            if ( nIntNum < 2 &&
+                 ptPoly3.x >= 0 && ptPoly3.x <= dDeltaX && 
+                 dDeltaX * abs( ptPoly3.z) < dDeltaX * dLenZ + dDeltaZ * ptPoly3.x) {
+
+               if ( nIntNum == 0) {
+      
+                  ptInt1 = ptPoly3 ;
+                  ++ nIntNum ;
+               }
+               else if ( ( ptInt1 - ptPoly3).SqLen() > dSqIndet) {
+      
+                  ptInt2 = ptPoly3 ;
+                  ++ nIntNum ;
+               }
             }
 
-            if ( ptR1.x < 0 && ptR2.x > 0 && ptR2.x < dl) {
+           // Intersezione con la quarta faccia
+            if ( nIntNum < 2 &&
+                 ptPoly4.x >= dLenX && ptPoly4.x <= dLenX + dDeltaX && 
+                 dDeltaX * abs( ptPoly4.z) < dDeltaX * dLenZ + dDeltaZ * ( ptPoly4.x - dLenX)) {
 
-               dMin = min( ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+               if ( nIntNum == 0) {
+      
+                  ptInt1 = ptPoly4 ;
+                  ++ nIntNum ;
+               }
+               else if ( ( ptInt1 - ptPoly4).SqLen() > dSqIndet) {
+      
+                  ptInt2 = ptPoly4 ;
+                  ++ nIntNum ;
+               }
             }
-            else if ( ptR1.x < 0 && ptR2.x >= dl && ptR2.x < dL) {
-            
-               ptR2.LocToLoc( ConeFrame, GridFrame) ;
 
-               dMin = min( ptR2.z, ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR2.z, ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
+           // Intersezione con la quinta faccia
+            if ( nIntNum < 2 &&
+                 ptPoly5.y >= 0 && ptPoly5.y <= dLenY &&
+                 abs( ptPoly5.z) <= dLenZ) {
 
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+               if ( nIntNum == 0) {
+      
+                  ptInt1 = ptPoly5 ;
+                  ++ nIntNum ;
+               }
+               else if ( ( ptInt1 - ptPoly5).SqLen() > dSqIndet) {
+      
+                  ptInt2 = ptPoly5 ;
+                  ++ nIntNum ;
+               }  
             }
-            else if ( ptR1.x > 0 && ptR1.x < dl && ptR2.x >= dl && ptR2.x < dL) {
 
-               ptR2.LocToLoc( ConeFrame, GridFrame) ;
-         
-               dMin = min( ptR2.z, ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR2.z, ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
+           // Intersezione con la sesta faccia
+            if ( nIntNum < 2 &&
+                 ptPoly6.y >= dDeltaY && ptPoly6.y <= dLenY + dDeltaY &&
+                 abs( ptPoly6.z) <= dLenZ + dDeltaZ) {
 
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+               if ( nIntNum == 0) {
+      
+                  ptInt1 = ptPoly6;
+                  ++ nIntNum ;
+               }
+               else if ( ( ptInt1 - ptPoly6).SqLen() > dSqIndet) {
+      
+                  ptInt2 = ptPoly6;
+                  ++ nIntNum ;
+               }
             }
-            else if ( ptR1.x > 0 && ptR1.x < dl && ptR2.x >= dL) {
-
-               dMin = min( ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;               
-            }
-            else if ( ptR1.x >= dl && ptR1.x < dL && ptR2.x < dL) {
-
-               ptR1.LocToLoc( ConeFrame, GridFrame) ;
-               ptR2.LocToLoc( ConeFrame, GridFrame) ;
-            
-               dMin = min( ptR1.z, ptR2.z) ;
-               dMax = max( ptR1.z, ptR2.z) ;
-            
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= dl && ptR1.x < dL && ptR2.x >= dL) {
-            
-               ptR1.LocToLoc( ConeFrame, GridFrame) ;
-
-               dMin = min( ptR1.z, ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ptR1.z, ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }         
-         }  
-
-        // Tralsazione dell'ellisse
-
-         ptC.LocToLoc( ConeFrame, IEllipseFrame) ;
-
-         std::vector <double> vdEllipseCoef(3);
-         std::vector <double> vdEllipseRoots;
-
-         vdEllipseCoef[0] = dCoef * dCoef * ptC.x * ptC.x + ptC.y * ptC.y + ptC.z * ptC.z - 2 * dCoef * ptC.x * ptC.y - dSqMaxRad ;
-         vdEllipseCoef[1] = 2 * ( dCoef * dCoef * vtKE.x * ptC.x + vtKE.y * ptC.y + vtKE.z * ptC.z - dCoef * ( vtKE.x * ptC.y + vtKE.y * ptC.x)) ;
-         vdEllipseCoef[2] = dCoef * dCoef * vtKE.x * vtKE.x + vtKE.y * vtKE.y + vtKE.z * vtKE.z - 2 * dCoef * vtKE.x * vtKE.y ;
-
-
-         int nEllipseRoot = PolynomialRoots( 2, vdEllipseCoef, vdEllipseRoots) ;
-         
-           
-         if ( nEllipseRoot == 0 || nEllipseRoot == 1) {
-
-            Point3d ptPi ;  ptPi.x = dX ;  ptPi.y = dY ;  ptPi.z = ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            Point3d ptPf ;  ptPf.x = dX ;  ptPf.y = dY ;  ptPf.z = ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            ptPi.LocToLoc( GridFrame, IEllipseFrame) ;
-            ptPf.LocToLoc( GridFrame, FEllipseFrame) ;
-
-            if ( ptPi.y * ptPi.y + ptPi.z * ptPi.z < dSqMaxRad && 
-                 ptPf.y * ptPf.y + ptPf.z * ptPf.z < dSqMaxRad) {
-
-                ptPi.LocToLoc( IEllipseFrame, GridFrame) ;
-                ptPf.LocToLoc( FEllipseFrame, GridFrame) ;
-
-                dMin = min( ptPi.z, ptPf.z) ;
-                dMax = max( ptPi.z, ptPf.z) ;
-
-                SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-         }
-         if ( nEllipseRoot == 2) {
-
-            Point3d ptInter1 = ptC + vdEllipseRoots[0] * vtKE ;
-            Point3d ptInter2 = ptC + vdEllipseRoots[1] * vtKE ;
-
+          // Se il poliedro è attraversato taglio
+           if ( nIntNum == 2) {
    
-            if ( ptInter1.x > ptInter2.x) {
+             // Riporto le intersezioni nel sistema griglia
+              ptInt1.ToGlob( PolyFrame) ;
+              ptInt2.ToGlob( PolyFrame) ;
+
+              dMin = min( ptInt1.z, ptInt2.z) ;
+              dMax = max( ptInt1.z, ptInt2.z) ;
+
+              SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
+           }
+
+           // Traslazione ellisse di punta
+            if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dl, ConusFrame, dSqMinRad, 
+                                               dLongLen, dOrtLen, ptInt1, ptInt2)) {
          
-               Point3d ptTemp = ptInter1 ;
-               ptInter1 = ptInter2 ;
-               ptInter2 = ptTemp ;
+               dMin = min( ptInt1.z + vtV1.z * dl, ptInt2.z + vtV1.z * dl) ;
+               dMax = max( ptInt1.z + vtV1.z * dl, ptInt2.z + vtV1.z * dl) ;
+          
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
             }
 
-            if ( ptInter1.x > 0 && ptInter1.x < dLLong &&
-                 ptInter2.x > dLLong) {
-
-               ptInter1.LocToLoc( IEllipseFrame, GridFrame) ;
-
-               dMin = min( ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter1.z) ;
-               dMax = max( ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptInter1.x > 0 && ptInter2.x < dLLong) {
-
-               ptInter1.LocToLoc( IEllipseFrame, GridFrame) ;
-               ptInter2.LocToLoc( IEllipseFrame, GridFrame) ;
-
-               dMin = min( ptInter1.z, ptInter2.z) ;
-               dMax = max( ptInter1.z, ptInter2.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptInter1.x < 0 && ptInter2.x > dLLong) {
-
-               dMin = min( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
+           // Traslazione ellisse di base
+            if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dL, ConusFrame, dSqMaxRad, 
+                                               dLongLen, dOrtLen, ptInt1, ptInt2)) {
          
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;         
-            }
-            else if ( ptInter1.x < 0 && ptInter2.x > 0 && ptInter2.x < dLLong) {
+               dMin = min( ptInt1.z + vtV1.z * dL, ptInt2.z + vtV1.z * dL) ;
+               dMax = max( ptInt1.z + vtV1.z * dL, ptInt2.z + vtV1.z * dL) ;
 
-               ptInter2.LocToLoc( IEllipseFrame, GridFrame) ;
-
-               dMin = min( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter2.z) ;
-               dMax = max( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter2.z) ;
-         
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
             }
-         }  
-      }        
+         }
+      }
+      return true ;
+   }
+   else {
+
+      for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
+         for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
+
+            double dX = ( i + 0.5) * m_dStep ;
+            double dY = ( j + 0.5) * m_dStep ;
+
+            Point3d ptC( dX, dY, 0) ;
+
+           Point3d ptInt1, ptInt2 ;
+
+           // Cono 
+            if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, ptInt1, ptInt2)) {
+
+               dMin = min( ptInt1.z, ptInt2.z) ;
+               dMax = max( ptInt1.z, ptInt2.z) ;
+
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
+            }
+
+           // Traslazione ellisse 
+            if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dL, ConusFrame, dSqMaxRad, 
+                                               dLongLen, dOrtLen, ptInt1, ptInt2)) {
+         
+               dMin = min( ptInt1.z + vtV1.z * dL, ptInt2.z + vtV1.z * dL) ;
+               dMax = max( ptInt1.z + vtV1.z * dL, ptInt2.z + vtV1.z * dL) ;
+
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
+            }
+         }
+      }
+      return true ;
    }
-   return true ;
 }
 
 // ---------- SFERA ----------------------------------------------------------
@@ -4777,7 +3761,7 @@ VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point
                dMin = dZI - dH ;
                dMax = dZI + dDeltaZ + dH ;
 
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;
             }
          }
       }
@@ -4828,14 +3812,14 @@ VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point
             
                   dMin = dZI + dDeltaZ - sqrt( dSqRad - dFSqDist) ;  
 
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;  
+               SubtractIntervals( nGrid, i, j, dMin, dMax, V_NULL, V_NULL) ;  
             }
          }
       }
    }
 
    return true ;
-}
+} 
 
 // ------------------------- BOUNDING BOX --------------------------------------------------------------------------------------
 
@@ -4856,11 +3840,11 @@ VolZmap::BoundingBox( unsigned int nGrid, const Point3d & ptP1, const Point3d &
    double dMaxXValue, dMaxYValue ;
    double dMinZValue, dMaxZValue ;
 
-   nMaxNx = m_nVNx[nGrid] ;  nMaxNy = m_nVNy[nGrid] ;
+   nMaxNx = m_nNx[nGrid] ;  nMaxNy = m_nNy[nGrid] ;
 
    dMaxXValue = nMaxNx * m_dStep ;  dMaxYValue = nMaxNy * m_dStep ;
       
-   dMinZValue = m_dVMinZ[nGrid] ;  dMaxZValue = m_dVMaxZ[nGrid] ;
+   dMinZValue = m_dMinZ[nGrid] ;  dMaxZValue = m_dMaxZ[nGrid] ;
    
 
   // Determinazione del raggio massimo dell'utensile
@@ -4913,11 +3897,11 @@ VolZmap::BBoxComponent( unsigned int nGrid, const Point3d & ptP1, const Point3d
    double dMaxXValue, dMaxYValue ;
    double dMinZValue, dMaxZValue ;
 
-   nMaxNx = m_nVNx[nGrid] ;  nMaxNy = m_nVNy[nGrid] ;
+   nMaxNx = m_nNx[nGrid] ;  nMaxNy = m_nNy[nGrid] ;
 
    dMaxXValue = nMaxNx * m_dStep ;  dMaxYValue = nMaxNy * m_dStep ;
       
-   dMinZValue = m_dVMinZ[nGrid] ;  dMaxZValue = m_dVMaxZ[nGrid] ;
+   dMinZValue = m_dMinZ[nGrid] ;  dMaxZValue = m_dMaxZ[nGrid] ;
 
   // Determinazione del raggio massimo del componente
    double dMaxRad = max( dRad, dTipRad) ;
@@ -4950,1254 +3934,3 @@ VolZmap::BBoxComponent( unsigned int nGrid, const Point3d & ptP1, const Point3d
    
    return true ;
 }
-
-
-
-
-
-
-
-
- 
-
-
-
-     
-
-
-
- 
-
-
-
-
-
-/*
- /*
-
- // VERSIONE NUOVA DA TESTARE
-bool
-VolZmap::Cyl_Milling( unsigned int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir, double dHei, double dRad) 
-{
-   double dMin, dMax ;
-   unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
-   bool Control = BBoxComponent( nGrid, ptLs, ptLe, vtToolDir, vtToolDir,
-                                 nStartI, nStartJ, nEndI, nEndJ, dRad, dRad, dHei) ;
-
-   if ( ! Control)
-      return true ;
-
-
-   Point3d ptI, ptF ;
-   Vector3d vtV1, vtV2, vtV3 ;
-   // Studio delle simmetrie
-   //vtV1 = ( vtToolDir.z < 0 ? - vtToolDir : vtToolDir) ;
-   //Point3d ptI = ptLs + ( vtToolDir.z < 0 ? dHei * vtV1 : vtNUll) ;
-   //Point3d ptF + ( vtToolDir.z < 0 ? dHei * vtV1 : vtNUll) ;
-   if ( vtToolDir.z < 0) { 
-      vtV1 = - vtToolDir ;
-      ptI = ( vtV1 * ( ptLe - ptLs) > 0 ? ptLs + dHei * vtV1 : ptLe + dHei * vtV1) ;
-      ptF = ( vtV1 * ( ptLe - ptLs) > 0 ? ptLe + dHei * vtV1 : ptLs + dHei * vtV1) ;
-   }
-   else {
-      vtV1 = vtToolDir ;
-      ptI = ( vtV1 * ( ptLe - ptLs) > 0 ? ptLs : ptLe) ;
-      ptF = ( vtV1 * ( ptLe - ptLs) > 0 ? ptLe : ptLs) ;
-   }
-
-   Point3d ptIT = ptI - vtV1 * dHei ;
-   Point3d ptFT = ptF - vtV1 * dHei ;
-
-   // Definizione di un sintema di riferimento nel piano
-   Vector3d vtU1( - vtV1.x, - vtV1.y, 0) ;
-   double dCos = vtV1.z ;
-   double dSin = vtU1.LenXY() ;
-   double dSemiAxMin = m_dRadius * dCos ;
-   double dSqRad = m_dRadius * m_dRadius ;
-   double dSqSemiAxMin = dSemiAxMin * dSemiAxMin ;
-   vtU1.Normalize() ; // Ocio che la sua lunghezza sia maggiore di EPS_SMALL
-   Vector3d vtU2 = vtU1 ;  vtU2.Rotate( Z_AX, 90) ;
-
-   double dZI = ptI.z ;
-   double dZF = ptF.z ;
-   double dDeltaZ = ptIT.z - ptI.z ;
-
-   double dL = dSin * dHei ;
-
-   Vector3d vtMove = ptF - ptI ;                   
-   double dLen = vtMove.Len() ;
-   Vector3d vtMLong = ( vtMove * vtV1) * vtV1 ;     
-   double dLLong = vtMLong.Len() ;
-   Vector3d vtMOrt = vtMove - vtMLong ;   
-   double dLOrt = vtMOrt.Len() ;
-
-   double dCoef = dLOrt / dLLong ;
-   double dAng = atan( 1 / dCoef) ;
-
-   // vtV1, vtV2 e vtV3 definiscono gli assi dei sistemi di riferimento intrinseci
-   vtV2 = vtMOrt ;  vtV2.Normalize() ;
-   vtV3 = vtV1 ^ vtV2 ;
-
-   Frame3d CylFrame ;    CylFrame.Set( ptI, vtV1, vtV2, vtV3) ;
-   Frame3d FCylFrame ;   FCylFrame.Set( ptF, vtV1, vtV2, vtV3) ;
-   Frame3d TCylFrame ;   TCylFrame.Set( ptIT, vtV1, vtV2, vtV3) ;
-   Frame3d FTCylFrame ;  FTCylFrame.Set( ptFT, vtV1, vtV2, vtV3) ;
-
-   // Altri punti notevoli
-   Point3d ptIPlus = ptI + dRad * vtV3 ;
-   Point3d ptIMinus = ptI - dRad * vtV3 ;
-
-   Point3d ptIxy( ptI.x, ptI.y, 0) ;
-   Point3d ptFxy( ptF.x, ptF.y, 0) ;
-
-   // Grandezze per la definizione dei piani        
-   Vector3d vtRI = ptI - ORIG ;                    
-   double dDotI = vtV1 * vtRI ;   
-   Vector3d vtRIT = ptIT - ORIG ;
-   double dDotIT = vtV1 * vtRIT ;
-   Vector3d vtRF = ptF - ORIG ;                     
-   double dDotF = vtV1 * vtRF ;
-   Vector3d vtRFT = ptFT - ORIG ;
-   double dDotFT = vtV1 * vtRFT ;
-
-   Vector3d vtW1 = vtV1 ;  vtW1.Rotate( vtV3, - 180 * dAng / PIGRECO) ;  
-   Vector3d vtW2 = vtV2 ;  vtW2.Rotate( vtV3, - 180 * dAng / PIGRECO) ; 
-
-   double dFrCos = cos( dAng) ;
-   double dFrSin = sin( dAng) ;
-
-   Frame3d RotFrame ;     RotFrame.Set( ptI, vtW1, vtW2, vtV3) ;
-   Frame3d TRotFrame ;    TRotFrame.Set( ptIT, vtW1, vtW2, vtV3) ;
-
-   // Versore Z nel sistema di riferimento CylFrame
-   Vector3d vtKCyl = Z_AX ;  vtKCyl.LocToLoc( m_LocalFrame, CylFrame) ;
-   // Versore Z nel sistema di riferimento RotFrame
-   Vector3d vtKRot = Z_AX ;  vtKRot.LocToLoc( m_LocalFrame, RotFrame) ;
-   
-
-   // Ciclo sui dexel 
-   for( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
-      for( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-      
-         double dX = ( i + 0.5) * m_dStep ;
-         double dY = ( j + 0.5) * m_dStep ;
-
-         Point3d ptC( dX, dY, 0) ; 
-         Point3d ptCCyl( dX, dY, 0) ;
-         Point3d ptCRot( dX, dY, 0) ;
-         Point3d ptCTCyl( dX, dY, 0) ;
-         ptCCyl.LocToLoc( m_LocalFrame, CylFrame) ;
-         ptCRot.LocToLoc( m_LocalFrame, RotFrame) ;
-         ptCTCyl.LocToLoc( m_LocalFrame, TCylFrame) ;
-         
-                     
-         Vector3d vtCI = ptC - ptIxy ;          
-         Vector3d vtCF = ptC - ptFxy ;
-         //Vector3d vtC = ptC - ORIG ;
-
-         double dPI1 = vtCI * vtU1 ;  double dPI2 = vtCI * vtU2 ;
-         double dPF1 = vtCF * vtU1 ;  double dPF2 = vtCF * vtU2 ;
-
-         // Cilindro iniziale
-         if (  dPI1 * dPI1 / dSqSemiAxMin + dPI2 * dPI2 / dSqRad < 1 || 
-             ( dPI1 - dL) * ( dPI1 - dL) / dSqSemiAxMin + dPI2 * dPI2 / dSqRad < 1 || 
-             ( dPI1 > 0 && dPI1 < dL && abs( dPI2) < m_dRadius)) {
-
-            double dSqRoot = sqrt( dSqRad - dPI2 * dPI2) ;
-            double dPI1_0 = dCos * dSqRoot ;
-            double dH = dSin * dSqRoot ;
-
-            // Massimo
-            if ( dPI1 < dPI1_0)
-              // Se vtV1.z -> 0 allora dCos -> 0 e con essi l'area ove vi 
-              // è la proiezione su XY del piano, quindi la divisione non da
-              // problemi, data la dimensione del passo della griglia
-               dMax = ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            else 
-              // Se vtV1.z -> 1 dCos -> 1 3 dSin -> 0 e con esso dL -> 0,
-              // ma anche l'area della regione interessata tende a zero, 
-              // quindi la divisione non da problemi, data la dimensione del passo della griglia
-               dMax = dZI + dH + dDeltaZ * ( dPI1 - dPI1_0) / dL ; 
-
-            // Minimo
-            if ( dPI1 < - dPI1_0)
-              // Analoga osservazione
-               dMin = dZI - dH + dDeltaZ * ( dPI1 + dPI1_0) / dL ;
-            else 
-              // Analoga osservazione
-               dMin = ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-         }
-
-         // Cilindro finale
-         if (  dPF1 * dPF1 + dPF2 * dPF2 < 1 || 
-             ( dPF1 - dL) * ( dPF1 - dL) + dPF2 * dPF2 < 1 || 
-             ( dPF1 > 0 && dPF1 < dL && abs( dPF2) < EPS_SMALL)) {
-
-            double dSqRoot = sqrt( dSqRad - ( dPF2 - dL) * ( dPF2 - dL)) ;
-            double dPF1_0 = dCos * dSqRoot ;
-            double dH = dSin * dSqRoot ;
-
-            // Massimo
-            if ( dPF1 < dPF1_0)
-              // Se vtV1.z -> 0 allora dCos -> 0 e con essi l'area ove vi 
-              // è la proiezione su XY del piano, quindi la divisione non da
-              // problemi, data la dimensione del passo della griglia
-               dMax = ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            else 
-              // Se vtV1.z -> 1 dCos -> 1 3 dSin -> 0 e con esso dL -> 0,
-              // ma anche l'area della regione interessata tende a zero, 
-              // quindi la divisione non da problemi, data la dimensione del passo della griglia
-               dMax = dZF + dH + dDeltaZ * ( dPF1 - dPF1_0) / dL ; 
-
-            // Minimo
-            if ( dPF1 < - dPF1_0)
-              // Analoga osservazione
-               dMin = dZF - dH + dDeltaZ * ( dPF1 + dPF1_0) / dL ;
-            else 
-              // Analoga osservazione
-               dMin = ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-         }
-
-         // Parallelepipedo
-         unsigned int nInt = 0 ;
-         double dt ;
-
-         Point3d ptInt1, ptInt2 ;
-        // Piani paralleli a XY nel sistema CylFrame
-         if ( abs( vtKCyl.z) > EPS_ZERO || 
-              abs( ptCCyl.z - m_dRadius) < EPS_SMALL ||
-              abs( ptCCyl.z + m_dRadius) < EPS_SMALL) {
-
-            dt = ( m_dRadius - ptCCyl.z) / vtKCyl.z ;
-            Point3d ptInt = ptCCyl + dt * vtKCyl ;
-
-            if ( ptInt.y > 0 && ptInt.y < dLOrt && 
-                 dLOrt * ptCCyl.x - dLLong * ptCCyl.y < 0 && 
-                 dLOrt * ptCCyl.x + dLOrt * dHei - dLLong * ptCCyl.y > 0) {
-
-               ptInt.LocToLoc( CylFrame, m_LocalFrame) ;
-
-               ptInt1 = ptInt ;
-               nInt = 1 ;
-            }
-
-            dt = ( - m_dRadius - ptCCyl.z) / vtKCyl.z ;
-            ptInt = ptCCyl + dt * vtKCyl ;
-
-            if ( ptInt.y > 0 && ptInt.y < dLOrt && 
-                 dLOrt * ptCCyl.x - dLLong * ptCCyl.y < 0 && 
-                 dLOrt * ptCCyl.x + dLOrt * dHei - dLLong * ptCCyl.y > 0) {
-
-                ptInt.LocToLoc( CylFrame, m_LocalFrame) ;
-
-               if ( nInt == 0) {
-                  ptInt1 = ptInt ;
-                  nInt = 1 ;
-               }
-               else if ( nInt == 1) {
-                  ptInt2 = ptInt ;
-                  nInt = 2 ;
-               }        
-            }
-         }
-        // Piani paralleli a XZ nel sistema CylFrame
-         if ( abs( vtKCyl.y) > EPS_ZERO ||
-              abs( ptCCyl.y) < EPS_SMALL ||
-              abs( ptCCyl.y - dLOrt) < EPS_SMALL) {
-
-            dt = - ptCCyl.y / vtKCyl.y ;
-            Point3d ptInt = ptCCyl + dt * vtKCyl ;
-
-            if ( ptInt.x > - dHei && ptInt.x < 0 && 
-                 ptInt.z > - m_dRadius && ptInt.z < m_dRadius) {
-
-                ptInt.LocToLoc( CylFrame, m_LocalFrame) ;
-
-               if ( nInt == 0) {
-                  ptInt1 = ptInt ;
-                  nInt = 1 ;
-               }
-               else if ( nInt == 1) {
-                  ptInt2 = ptInt ;
-                  nInt = 2 ;
-               }     
-            }
-
-            dt = ( dLOrt - ptCCyl.y) / vtKCyl.y ;
-            ptInt = ptCCyl + dt * vtKCyl ;
-
-            if ( ptInt.x > - dHei && ptInt.x < 0 && 
-                 ptInt.z > - m_dRadius && ptInt.z < m_dRadius) {
-
-                ptInt.LocToLoc( CylFrame, m_LocalFrame) ;
-
-               if ( nInt == 0) {
-                  ptInt1 = ptInt ;
-                  nInt = 1 ;
-               }
-               else if ( nInt == 1) {
-                  ptInt2 = ptInt ;
-                  nInt = 2 ;
-               }     
-            }         
-         }
-        // Piani paralleli a YZ nel sistema RotFrame
-         if ( abs( vtKRot.x) > EPS_ZERO || 
-              abs( ptCRot.x) < EPS_SMALL ||
-              abs( ptCRot.x + dHei * dFrCos) < EPS_SMALL) {
-
-            dt = - ptCRot.x / vtKRot.x ;
-            Point3d ptInt = ptCCyl + dt * vtKRot ;
-
-            if ( ptInt.y > 0 && ptInt.y < dLen &&
-                 ptInt.z > - m_dRadius && ptInt.z < m_dRadius) {
-
-                ptInt.LocToLoc( RotFrame, m_LocalFrame) ;
-            
-               if ( nInt == 0) {
-                  ptInt1 = ptInt ;
-                  nInt = 1 ;
-               }
-               else if ( nInt == 1) {
-                  ptInt2 = ptInt ;
-                  nInt = 2 ;
-               }
-            }
-
-            dt = ( - dHei * dFrSin - ptCRot.x) / vtKRot.x ;
-            ptInt = ptCCyl + dt * vtKRot ;
-
-            if ( ptInt.y > - dHei * dFrSin && ptInt.y < dLen - dHei * dFrSin &&
-                 ptInt.z > - m_dRadius && ptInt.z < m_dRadius) {
-
-               ptInt.LocToLoc( RotFrame, m_LocalFrame) ;
-            
-               if ( nInt == 0) {
-                  ptInt1 = ptInt ;
-                  nInt = 1 ;
-               }
-               else if ( nInt == 1) {
-                  ptInt2 = ptInt ;
-                  nInt = 2 ;
-               }
-            }    
-         }
-
-         if ( nInt == 2) {
-
-            dMin = min( ptInt1.z, ptInt2.z) ;
-            dMax = max( ptInt1.z, ptInt2.z) ;
-
-            SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-         }
-
-         // Traslazione ellisse di fondo
-         std::vector <double> vdCoef(3);
-         std::vector <double> vdRoots;
-
-         vdCoef[0] = dCoef * dCoef * ptCCyl.x * ptCCyl.x + ptCCyl.y * ptCCyl.y + ptCCyl.z * ptCCyl.z - 2 * dCoef * ptCCyl.x * ptCCyl.y - dRad * dRad ;
-         vdCoef[1] = 2 * ( dCoef * dCoef * vtKCyl.x * ptCCyl.x + vtKCyl.y * ptCCyl.y + vtKCyl.z * ptCCyl.z - dCoef * ( vtKCyl.x * ptCCyl.y + vtKCyl.y * ptCCyl.x)) ;
-         vdCoef[2] = dCoef * dCoef * vtKCyl.x * vtKCyl.x + vtKCyl.y * vtKCyl.y + vtKCyl.z * vtKCyl.z - 2 * dCoef * vtKCyl.x * vtKCyl.y ;
-
-
-         int nRoot = PolynomialRoots( 2, vdCoef, vdRoots) ;
-
-         if ( nRoot == 0 || nRoot == 1) {
-
-            Point3d ptPi ;  ptPi.x = dX ;  ptPi.y = dY ;  ptPi.z = ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            Point3d ptPf ;  ptPf.x = dX ;  ptPf.y = dY ;  ptPf.z = ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            ptPi.LocToLoc( m_LocalFrame, CylFrame) ;
-            ptPf.LocToLoc( m_LocalFrame, FCylFrame) ;
-
-            if ( ptPi.y * ptPi.y + ptPi.z * ptPi.z < dRad * dRad && 
-                 ptPf.y * ptPf.y + ptPf.z * ptPf.z < dRad * dRad) {
-
-                ptPi.LocToLoc( CylFrame, m_LocalFrame) ;
-                ptPf.LocToLoc( FCylFrame, m_LocalFrame) ;
-
-                dMin = min( ptPi.z, ptPf.z) ;
-                dMax = max( ptPi.z, ptPf.z) ;
-
-                SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }        
-         }
-         else if ( nRoot == 2) {
-
-            Point3d ptInter1 = ptCCyl + vdRoots[0] * vtKCyl ;
-            Point3d ptInter2 = ptCCyl + vdRoots[1] * vtKCyl ;
-
-   
-            if ( ptInter1.x > ptInter2.x) {
-         
-               Point3d ptTemp = ptInter1 ;
-               ptInter1 = ptInter2 ;
-               ptInter2 = ptTemp ;
-            }
-
-            if ( ptInter1.x > 0 && ptInter1.x < dLLong &&
-                 ptInter2.x > dLLong) {
-
-               ptInter1.LocToLoc( CylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter1.z) ;
-               dMax = max( ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptInter1.x > 0 && ptInter2.x < dLLong) {
-
-               ptInter1.LocToLoc( CylFrame, m_LocalFrame) ;
-               ptInter2.LocToLoc( CylFrame, m_LocalFrame) ;
-
-               dMin = min( ptInter1.z, ptInter2.z) ;
-               dMax = max( ptInter1.z, ptInter2.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptInter1.x < 0 && ptInter2.x > dLLong) {
-
-               dMin = min( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-         
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;         
-            }
-            else if ( ptInter1.x < 0 && ptInter2.x > 0 && ptInter2.x < dLLong) {
-
-               ptInter2.LocToLoc( CylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter2.z) ;
-               dMax = max( ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptInter2.z) ;
-         
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-         }
-
-         // Traslazione ellisse di punta
-         std::vector <double> vdTCoef(3);
-         std::vector <double> vdTRoots;
-
-         vdTCoef[0] = dCoef * dCoef * ptCTCyl.x * ptCTCyl.x + ptCTCyl.y * ptCTCyl.y + ptCTCyl.z * ptCTCyl.z - 2 * dCoef * ptCTCyl.x * ptCTCyl.y - dRad * dRad ;
-         vdTCoef[1] = 2 * ( dCoef * dCoef * vtKCyl.x * ptCTCyl.x + vtKCyl.y * ptCTCyl.y + vtKCyl.z * ptCTCyl.z - dCoef * ( vtKCyl.x * ptCTCyl.y + vtKCyl.y * ptCTCyl.x)) ;
-         vdTCoef[2] = dCoef * dCoef * vtKCyl.x * vtKCyl.x + vtKCyl.y * vtKCyl.y + vtKCyl.z * vtKCyl.z - 2 * dCoef * vtKCyl.x * vtKCyl.y ;
-
-         int nTRoot = PolynomialRoots( 2, vdTCoef, vdTRoots) ;
-
-         if ( nTRoot == 0 || nTRoot == 1) {
-
-            Point3d ptPi ;  ptPi.x = dX ;  ptPi.y = dY ;  ptPi.z = ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            Point3d ptPf ;  ptPf.x = dX ;  ptPf.y = dY ;  ptPf.z = ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            ptPi.LocToLoc( m_LocalFrame, TCylFrame) ;
-            ptPf.LocToLoc( m_LocalFrame, FTCylFrame) ;
-
-            if ( ptPi.y * ptPi.y + ptPi.z * ptPi.z < dRad * dRad && 
-                 ptPf.y * ptPf.y + ptPf.z * ptPf.z < dRad * dRad) {
-
-                ptPi.LocToLoc( TCylFrame, m_LocalFrame) ;
-                ptPf.LocToLoc( FTCylFrame, m_LocalFrame) ;
-
-                dMin = min( ptPi.z, ptPf.z) ;
-                dMax = max( ptPi.z, ptPf.z) ;
-
-                SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }        
-         
-         }
-         else if ( nTRoot == 2) {
-
-            Point3d ptTInter1 = ptCTCyl + vdTRoots[0] * vtKCyl ;
-            Point3d ptTInter2 = ptCTCyl + vdTRoots[1] * vtKCyl ;
-
-            if ( ptTInter1.x > ptTInter2.x) {
-         
-               Point3d ptTemp = ptTInter1 ;
-               ptTInter1 = ptTInter2 ;
-               ptTInter2 = ptTemp ;
-            }
-
-            if ( ptTInter1.x > 0 && ptTInter1.x < dLLong &&
-                 ptTInter2.x > dLLong) {
-
-               ptTInter1.LocToLoc( TCylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter1.z) ;
-               dMax = max( ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptTInter1.x > 0 && ptTInter2.x < dLLong) {
-
-               ptTInter1.LocToLoc( TCylFrame, m_LocalFrame) ;
-               ptTInter2.LocToLoc( TCylFrame, m_LocalFrame) ;
-
-               dMin = min( ptTInter1.z, ptTInter2.z) ;
-               dMax = max( ptTInter1.z, ptTInter2.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptTInter1.x < 0 && ptTInter2.x > dLLong) {
-
-               dMin = min( ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-               dMax = max( ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-            else if ( ptTInter1.x < 0 && ptTInter2.x > 0 && ptTInter2.x < dLLong) {
-
-               ptTInter2.LocToLoc( TCylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter2.z) ;
-               dMax = max( ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z, ptTInter2.z) ;
-         
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-         }        
-      }
-   }
-   return true ;
-} */
-
-
-/*
-//----------------------------------------------------------------------------
-bool
-VolZmap::MillCyl2( const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir, double dHei, double dRad)
-{
-   double dMin, dMax ;
-   unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
-   bool Control = BBoxComponent( ptLs, ptLe, vtToolDir, vtToolDir, nStartI, nStartJ, nEndI, nEndJ, dRad, dRad, dHei) ;
-
-   if ( ! Control)
-      return true ;
-
-  // Punti notevoli
-   Point3d ptI = ptLs ;
-   Point3d ptF = ptLe ;
-
-   Point3d ptIT = ptI - vtToolDir * dHei ;
-   Point3d ptFT = ptF - vtToolDir * dHei ;
-
-  // Vettori notevoli
-   Vector3d vtMove = ptF - ptI ;  double dLen = vtMove.Len() ;
-   Vector3d vtLong = ( vtMove * vtToolDir) * vtToolDir ;  double dLong = vtLong.Len() ;
-   Vector3d vtOrt = vtMove - vtLong ;  double dOrt = vtOrt.Len() ;
-
-   double dCoef = dOrt / dLong ;
-   double dAng = atan( 1 / dCoef) ;
-
-   Vector3d vtV1 = vtToolDir ;  
-   Vector3d vtV2 = vtOrt ;  vtV2.Normalize() ;
-   Vector3d vtV3 = vtV1 ^ vtV2 ;
-
-  // Definizione dei sistemi di riferimento
-   Frame3d ICylFrame ;  ICylFrame.Set( ptI, vtV1, vtV2, vtV3) ;
-   Frame3d FCylFrame ;  FCylFrame.Set( ptF, vtV1, vtV2, vtV3) ;
-   Frame3d ITCylFrame ; ITCylFrame.Set( ptIT, vtV1, vtV2, vtV3) ;
-   Frame3d FTCylFrame ; FTCylFrame.Set( ptFT, vtV1, vtV2, vtV3) ;
-
-   Vector3d vtW1 = vtV1 ;  vtW1.Rotate( vtV3, - 180 * dAng / PIGRECO) ;  
-   Vector3d vtW2 = vtV2 ;  vtW2.Rotate( vtV3, - 180 * dAng / PIGRECO) ;   
-   Vector3d vtW3 = vtV3 ;
-
-   Frame3d RotFrame ;     RotFrame.Set( ptI, vtW1, vtW2, vtW3) ;
-   Frame3d TRotFrame ;    TRotFrame.Set( ptIT, vtW1, vtW2, vtW3) ;
-
-  // Altri vettori notevoi
-   Vector3d vtKC = Z_AX ;  vtKC.LocToLoc( m_LocalFrame, ICylFrame) ;
-
-   Vector3d vtRI = ptI - ORIG ;        double dDotI = vtRI * vtV1 ;
-   Vector3d vtRF = ptF - ORIG ;        double dDotF = vtRF * vtV1 ;
-   Vector3d vtRIT = ptIT - ORIG ;      double dDotIT = vtRIT * vtV1 ;
-   Vector3d vtRFT = ptFT - ORIG ;      double dDotFT = vtRFT * vtV1 ;
-
-   Vector3d vtRIPlus = vtRI + dRad * vtW3 ;
-   Vector3d vtRIMinus = vtRI - dRad * vtW3 ;
-
-
-   for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
-
-      for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-      
-         double dX = ( i + 0.5) * m_dStep ;  double dY = ( j + 0.5) * m_dStep ;
-
-         Point3d ptC( dX, dY, 0) ;  Vector3d vtC = ptC - ORIG ;
-
-        // Cilindro iniziale
-         ptC.LocToLoc( m_LocalFrame, ICylFrame) ;
-
-         std::vector <double> vdICylCoef(3);
-         std::vector <double> vdICylRoots;
-
-         vdICylCoef[0] = ptC.y * ptC.y + ptC.z * ptC.z - dRad * dRad ;   
-         vdICylCoef[1] = 2 * ( ptC.y * vtKC.y + ptC.z * vtKC.z) ;
-         vdICylCoef[2] = vtKC.y * vtKC.y + vtKC.z * vtKC.z ;
-
-
-         int nICylRoot = PolynomialRoots( 2, vdICylCoef, vdICylRoots) ;
-
-         if ( nICylRoot == 0 || nICylRoot == 1) {
-
-            Point3d ptPb ;  ptPb.x = dX ;  ptPb.y = dY ;  ptPb.z = ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            Point3d ptPt ;  ptPt.x = dX ;  ptPt.y = dY ;  ptPt.z = ( dDotIT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            ptPb.LocToLoc( m_LocalFrame, ICylFrame) ;
-            ptPt.LocToLoc( m_LocalFrame, ITCylFrame) ;
-
-            if ( ptPb.y * ptPb.y + ptPb.z * ptPb.z < dRad * dRad && 
-                 ptPt.y * ptPt.y + ptPt.z * ptPt.z < dRad * dRad) {
-
-                ptPb.LocToLoc( ICylFrame, m_LocalFrame) ;
-                ptPt.LocToLoc( ITCylFrame, m_LocalFrame) ;
-
-                dMin = min( ptPb.z, ptPt.z) ;
-                dMax = max( ptPb.z, ptPt.z) ;
-
-                SubtractIntervals( i, j, dMin, dMax) ;
-            }         
-         } 
-         else if ( nICylRoot == 2) {
-
-            Point3d ptR1 = ptC + vdICylRoots[0] * vtKC ;
-            Point3d ptR2 = ptC + vdICylRoots[1] * vtKC ;
-
-             if ( ptR1.x > ptR2.x) {
-         
-               Point3d ptTemp = ptR1 ;
-               ptR1 = ptR2 ;
-               ptR2 = ptTemp ;
-            }
-
-            if ( ptR1.x < - dHei && ptR2.x >= - dHei &&
-                 ptR2.x < 0) {
-
-               ptR2.LocToLoc( ICylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotIT - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR2.z) ;
-               dMax = max( ( dDotIT - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR2.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x < - dHei && ptR2.x >= 0) {
-            
-               dMin = min( ( dDotI - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ( dDotIT - dX * vtV1.x - dY * vtV1.y) / vtV1.z) ;
-               dMax = max( ( dDotI - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ( dDotIT - dX * vtV1.x - dY * vtV1.y) / vtV1.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= - dHei && ptR1.x < 0 && ptR2.x < 0) {
-
-               ptR1.LocToLoc( ICylFrame, m_LocalFrame) ;
-               ptR2.LocToLoc( ICylFrame, m_LocalFrame) ;
-
-               dMin = min( ptR1.z, ptR2.z) ;
-               dMax = max( ptR1.z, ptR2.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= - dHei && ptR1.x < 0 && ptR2.x >= 0) {
-
-               ptR1.LocToLoc( ICylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotI - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR1.z) ;
-               dMax = max( ( dDotI - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR1.z) ;
-         
-               SubtractIntervals( i, j, dMin, dMax) ;         
-            }       
-         }
-
-        // Cilindro finale
-         ptC.LocToLoc( ICylFrame, FCylFrame) ;
-
-         std::vector <double> vdFCylCoef(3);
-         std::vector <double> vdFCylRoots;
-
-         vdFCylCoef[0] = ptC.y * ptC.y + ptC.z * ptC.z - dRad * dRad ;   
-         vdFCylCoef[1] = 2 * ( ptC.y * vtKC.y + ptC.z * vtKC.z) ;
-         vdFCylCoef[2] = vtKC.y * vtKC.y + vtKC.z * vtKC.z ;
-
-
-         int nFCylRoot = PolynomialRoots( 2, vdFCylCoef, vdFCylRoots) ;
-
-         if ( nFCylRoot == 0 || nFCylRoot == 1) {
-         
-            Point3d ptPb ;  ptPb.x = dX ;  ptPb.y = dY ;  ptPb.z = ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            Point3d ptPt ;  ptPt.x = dX ;  ptPt.y = dY ;  ptPt.z = ( dDotFT - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            ptPb.LocToLoc( m_LocalFrame, FCylFrame) ;
-            ptPt.LocToLoc( m_LocalFrame, FTCylFrame) ;
-
-            if ( ptPb.y * ptPb.y + ptPb.z * ptPb.z < dRad * dRad && 
-                 ptPt.y * ptPt.y + ptPt.z * ptPt.z < dRad * dRad) {
-
-                ptPb.LocToLoc( FCylFrame, m_LocalFrame) ;
-                ptPt.LocToLoc( FTCylFrame, m_LocalFrame) ;
-
-                dMin = min( ptPb.z, ptPt.z) ;
-                dMax = max( ptPb.z, ptPt.z) ;
-
-                SubtractIntervals( i, j, dMin, dMax) ;
-            }         
-         } 
-         else if ( nFCylRoot == 2) {
-
-            Point3d ptR1 = ptC + vdFCylRoots[0] * vtKC ;
-            Point3d ptR2 = ptC + vdFCylRoots[1] * vtKC ;
-
-             if ( ptR1.x > ptR2.x) {
-         
-               Point3d ptTemp = ptR1 ;
-               ptR1 = ptR2 ;
-               ptR2 = ptTemp ;
-            }
-
-            if ( ptR1.x < - dHei && ptR2.x >= - dHei &&
-                 ptR2.x < 0) {
-
-               ptR2.LocToLoc( FCylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotFT - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR2.z) ;
-               dMax = max( ( dDotFT - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR2.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x < - dHei && ptR2.x >= 0) {
-            
-               dMin = min( ( dDotF - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ( dDotFT - dX * vtV1.x - dY * vtV1.y) / vtV1.z) ;
-               dMax = max( ( dDotF - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ( dDotFT - dX * vtV1.x - dY * vtV1.y) / vtV1.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= - dHei && ptR1.x < 0 && ptR2.x < 0) {
-
-               ptR1.LocToLoc( FCylFrame, m_LocalFrame) ;
-               ptR2.LocToLoc( FCylFrame, m_LocalFrame) ;
-
-               dMin = min( ptR1.z, ptR2.z) ;
-               dMax = max( ptR1.z, ptR2.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= - dHei && ptR1.x < 0 && ptR2.x >= 0) {
-
-               ptR1.LocToLoc( FCylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotF - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR1.z) ;
-               dMax = max( ( dDotF - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR1.z) ;
-         
-               SubtractIntervals( i, j, dMin, dMax) ;         
-            }        
-         }
-
-        // Traslazione ellisse fondo 
-
-         ptC.LocToLoc( FCylFrame, ICylFrame) ;
-
-         std::vector <double> vdEllipseCoef(3);
-         std::vector <double> vdEllipseRoots;
-
-         vdEllipseCoef[0] = dCoef * dCoef * ptC.x * ptC.x + ptC.y * ptC.y + ptC.z * ptC.z - 2 * dCoef * ptC.x * ptC.y - dRad * dRad ;   
-         vdEllipseCoef[1] = 2 * ( dCoef * dCoef * vtKC.x * ptC.x + vtKC.y * ptC.y + vtKC.z * ptC.z - dCoef * ( vtKC.x * ptC.y + vtKC.y * ptC.x)) ; 
-         vdEllipseCoef[2] = dCoef * dCoef * vtKC.x * vtKC.x + vtKC.y * vtKC.y + vtKC.z * vtKC.z - 2 * dCoef * vtKC.x * vtKC.y ;
-
-
-         int nEllipseRoot = PolynomialRoots( 2, vdEllipseCoef, vdEllipseRoots) ;
-
-         if ( nEllipseRoot == 0 || nEllipseRoot == 1) {
-
-            Point3d ptPi ;  ptPi.x = dX ;  ptPi.y = dY ;  ptPi.z = ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            Point3d ptPf ;  ptPf.x = dX ;  ptPf.y = dY ;  ptPf.z = ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            ptPi.LocToLoc( m_LocalFrame, ICylFrame) ;
-            ptPf.LocToLoc( m_LocalFrame, FCylFrame) ;
-
-            if ( ptPi.y * ptPi.y + ptPi.z * ptPi.z < dRad * dRad && 
-                 ptPf.y * ptPf.y + ptPf.z * ptPf.z < dRad * dRad) {
-
-                ptPi.LocToLoc( ICylFrame, m_LocalFrame) ;
-                ptPf.LocToLoc( FCylFrame, m_LocalFrame) ;
-
-                dMin = min( ptPi.z, ptPf.z) ;
-                dMax = max( ptPi.z, ptPf.z) ;
-
-                SubtractIntervals( i, j, dMin, dMax) ;
-            }         
-         }
-         else if ( nEllipseRoot == 2) {
-         
-            Point3d ptR1 = ptC + vdEllipseRoots[0] * vtKC ;
-            Point3d ptR2 = ptC + vdEllipseRoots[1] * vtKC ;
-
-            if ( ptR1.x > ptR2.x) {
-         
-               Point3d ptTemp = ptR1 ;
-               ptR1 = ptR2 ;
-               ptR2 = ptTemp ;
-            }
-
-            if ( ptR1.x < 0 && ptR2.x >= 0 &&
-                 ptR2.x < dLong) {
-
-               ptR2.LocToLoc( ICylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotI - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR2.z) ;
-               dMax = max( ( dDotI - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR2.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x < 0 && ptR2.x >= dLong) {
-            
-               dMin = min( ( dDotI - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ( dDotF - dX * vtV1.x - dY * vtV1.y) / vtV1.z) ;
-               dMax = max( ( dDotI - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ( dDotF - dX * vtV1.x - dY * vtV1.y) / vtV1.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= 0 && ptR1.x < dLong && ptR2.x < dLong) {
-
-               ptR1.LocToLoc( ICylFrame, m_LocalFrame) ;
-               ptR2.LocToLoc( ICylFrame, m_LocalFrame) ;
-
-               dMin = min( ptR1.z, ptR2.z) ;
-               dMax = max( ptR1.z, ptR2.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= 0 && ptR1.x < dLong && ptR2.x >= dLong) {
-
-               ptR1.LocToLoc( ICylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotF - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR1.z) ;
-               dMax = max( ( dDotF - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR1.z) ;
-         
-               SubtractIntervals( i, j, dMin, dMax) ;         
-            }        
-         }
-
-        // Traslazione ellisse punta
-
-         ptC.LocToLoc( ICylFrame, ITCylFrame) ;
-
-         std::vector <double> vdTEllipseCoef(3);
-         std::vector <double> vdTEllipseRoots;
-
-         vdTEllipseCoef[0] = dCoef * dCoef * ptC.x * ptC.x + ptC.y * ptC.y + ptC.z * ptC.z - 2 * dCoef * ptC.x * ptC.y - dRad * dRad ;   
-         vdTEllipseCoef[1] = 2 * ( dCoef * dCoef * vtKC.x * ptC.x + vtKC.y * ptC.y + vtKC.z * ptC.z - dCoef * ( vtKC.x * ptC.y + vtKC.y * ptC.x)) ; 
-         vdTEllipseCoef[2] = dCoef * dCoef * vtKC.x * vtKC.x + vtKC.y * vtKC.y + vtKC.z * vtKC.z - 2 * dCoef * vtKC.x * vtKC.y ;
-
-
-         int nTEllipseRoot = PolynomialRoots( 2, vdTEllipseCoef, vdTEllipseRoots) ;
-
-         if ( nTEllipseRoot == 0 || nTEllipseRoot == 1) {
-
-            Point3d ptPi ;  ptPi.x = dX ;  ptPi.y = dY ;  ptPi.z = ( dDotI - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-            Point3d ptPf ;  ptPf.x = dX ;  ptPf.y = dY ;  ptPf.z = ( dDotF - vtV1.x * dX - vtV1.y * dY) / vtV1.z ;
-
-            ptPi.LocToLoc( m_LocalFrame, ITCylFrame) ;
-            ptPf.LocToLoc( m_LocalFrame, FTCylFrame) ;
-
-            if ( ptPi.y * ptPi.y + ptPi.z * ptPi.z < dRad * dRad && 
-                 ptPf.y * ptPf.y + ptPf.z * ptPf.z < dRad * dRad) {
-
-                ptPi.LocToLoc( ITCylFrame, m_LocalFrame) ;
-                ptPf.LocToLoc( FTCylFrame, m_LocalFrame) ;
-
-                dMin = min( ptPi.z, ptPf.z) ;
-                dMax = max( ptPi.z, ptPf.z) ;
-
-                SubtractIntervals( i, j, dMin, dMax) ;
-            }              
-         }
-         else if ( nTEllipseRoot == 2) {
-
-            Point3d ptR1 = ptC + vdTEllipseRoots[0] * vtKC ;
-            Point3d ptR2 = ptC + vdTEllipseRoots[1] * vtKC ;
-
-            if ( ptR1.x > ptR2.x) {
-         
-               Point3d ptTemp = ptR1 ;
-               ptR1 = ptR2 ;
-               ptR2 = ptTemp ;
-            }
-
-            if ( ptR1.x < 0 && ptR2.x >= 0 &&
-                 ptR2.x < dLong) {
-
-               ptR2.LocToLoc( ITCylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotIT - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR2.z) ;
-               dMax = max( ( dDotIT - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR2.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x < 0 && ptR2.x >= dLong) {
-            
-               dMin = min( ( dDotIT - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ( dDotFT - dX * vtV1.x - dY * vtV1.y) / vtV1.z) ;
-               dMax = max( ( dDotIT - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ( dDotFT - dX * vtV1.x - dY * vtV1.y) / vtV1.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= 0 && ptR1.x < dLong && ptR2.x < dLong) {
-
-               ptR1.LocToLoc( ITCylFrame, m_LocalFrame) ;
-               ptR2.LocToLoc( ITCylFrame, m_LocalFrame) ;
-
-               dMin = min( ptR1.z, ptR2.z) ;
-               dMax = max( ptR1.z, ptR2.z) ;
-
-               SubtractIntervals( i, j, dMin, dMax) ;
-            }
-            else if ( ptR1.x >= 0 && ptR1.x < dLong && ptR2.x >= dLong) {
-
-               ptR1.LocToLoc( ITCylFrame, m_LocalFrame) ;
-
-               dMin = min( ( dDotFT - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR1.z) ;
-               dMax = max( ( dDotFT - dX * vtV1.x - dY * vtV1.y) / vtV1.z, ptR1.z) ;
-         
-               SubtractIntervals( i, j, dMin, dMax) ;         
-            }        
-         }
-
-
-        // Parallelepipedo     
-         Point3d ptInt1 = ptC + ( ( ( vtRI - vtC) * vtV2) / ( Z_AX * vtV2)) * Z_AX ;
-         Point3d ptInt2 = ptC + ( ( ( vtRI - vtC) * vtW1) / ( Z_AX * vtW1)) * Z_AX ;
-         Point3d ptInt3 = ptC + ( ( ( vtRF - vtC) * vtV2) / ( Z_AX * vtV2)) * Z_AX ; 
-         Point3d ptInt4 = ptC + ( ( ( vtRIT - vtC) * vtW1) / ( Z_AX * vtW1)) * Z_AX ;
-         Point3d ptInt5 = ptC + ( ( ( vtRIPlus - vtC) * vtV3) / ( Z_AX * vtV3)) * Z_AX ;
-         Point3d ptInt6 = ptC + ( ( ( vtRIMinus - vtC) * vtV3) / ( Z_AX * vtV3)) * Z_AX ;
-
-         
-         ptInt1.LocToLoc( m_LocalFrame, ICylFrame) ;
-         ptInt2.LocToLoc( m_LocalFrame, RotFrame) ;
-         ptInt3.LocToLoc( m_LocalFrame, FCylFrame) ; 
-         ptInt4.LocToLoc( m_LocalFrame, TRotFrame) ;
-         ptInt5.LocToLoc( m_LocalFrame, ICylFrame) ;
-         ptInt6.LocToLoc( m_LocalFrame, ICylFrame) ;
-
-         bool bFlag = false ;
-         double dLim1, dLim2 ;
-
-          
-         if ( ptInt1.x >= - dHei && ptInt1.x <= 0 && 
-              ptInt1.z >= - dRad && ptInt1.z <= dRad) {
-
-            ptInt1.LocToLoc( ICylFrame, m_LocalFrame) ;
-         
-            dLim1 = ptInt1.z ; 
-            bFlag = true ;
-         }
-        
-         if ( ptInt2.y >= 0 && ptInt2.y <= dLen && 
-              ptInt2.z >= - dRad && ptInt2.z <= dRad) {
-
-            ptInt2.LocToLoc( RotFrame, m_LocalFrame) ;
-
-            if ( bFlag == false) {
-
-               dLim1 = ptInt2.z ;
-
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt2.z ;
-         }
-
-         if ( ptInt3.z >= - dRad && ptInt3.z <= dRad &&
-              ptInt3.x >= - dHei && ptInt3.x <= 0) {
-
-            ptInt3.LocToLoc( FCylFrame, m_LocalFrame) ;
-
-            if ( bFlag == false) {
-
-               dLim1 = ptInt3.z ;
-
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt3.z ;
-         }
-
-         if ( ptInt4.z >= - dRad && ptInt4.z <= dRad &&
-              ptInt4.y >= 0 && ptInt4.y <= dLen) {
-
-             ptInt4.LocToLoc( TRotFrame, m_LocalFrame) ;
-
-            if ( bFlag == false) {
-
-               dLim1 = ptInt4.z ;
-
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt4.z ;
-         }
-
-         if ( ptInt5.y >= 0 && ptInt5.y <= dOrt &&
-              ptInt5.x >= - dHei + dCoef * ptInt5.y &&
-              ptInt5.x <= dCoef * ptInt5.y) {
-
-            ptInt5.LocToLoc( ICylFrame, m_LocalFrame) ;
-
-            if ( bFlag == false) {
-
-               dLim1 = ptInt5.z ;
-
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt5.z ;
-         }
-
-         if ( ptInt6.y >= 0 && ptInt6.y <= dOrt &&
-              ptInt6.x >= - dHei + dCoef * ptInt6.y &&
-              ptInt6.x <= dCoef * ptInt6.y) {
-
-             ptInt6.LocToLoc( ICylFrame, m_LocalFrame) ;
-
-            if ( bFlag == false) {
-
-               dLim1 = ptInt6.z ;
-
-               bFlag = true ;
-            }
-            else 
-
-               dLim2 = ptInt6.z ;
-         } 
-
-
-         if ( bFlag == true) {    // Una linea non confinata se entra in un volume chiuso ci deve uscire
-
-            dMin = min( dLim1, dLim2) ;
-            dMax = max( dLim1, dLim2) ;
-
-            SubtractIntervals( i, j, dMin, dMax) ; 
-         }  
-      }
-   }
-
-   return true ;
-}
-*/
-
-/*  
-//----------------------------------------------------------------------------
-bool
-VolZmap::Conus_XYPerp( unsigned int nGrid, const Point3d ptS, const Point3d ptE, const Vector3d vtToolDir) 
-{
-    unsigned int nStartI, nStartJ, nEndI, nEndJ ;
-
-   // Verifica sull'interferenza utensile Zmap
-    bool bTest = BoundingBox( nGrid, ptS, ptE, vtToolDir, vtToolDir, nStartI, nStartJ, nEndI, nEndJ) ;
-
-    if ( ! bTest)
-       return true ;
-
-   // Parametri geometrici dell'utensile
-    double dStemHeigth = m_dHeight - m_dTipHeight  ;
-    double dMinRad = min( m_dRadius, m_dTipRadius) ;
-    double dMaxRad = max( m_dRadius, m_dTipRadius) ;
-    double dSqTipRad = m_dTipRadius * m_dTipRadius ;
-    double dSqRad = m_dRadius * m_dRadius ;
-    double dDeltaRad = dMaxRad - dMinRad ;
-    double dSqMinRad = dMinRad * dMinRad ;
-    double dSqMaxRad = dMaxRad * dMaxRad ;
-
-   // Studio delle simmetrie
-    Point3d ptI = ( ptS.z < ptE.z ? ptS : ptE) ;
-    Point3d ptF = ( ptS.z < ptE.z ? ptE : ptS) ;
-
-   // Vettori caratterizzanti il moto
-    Vector3d vtMove = ptF - ptI ;
-    Vector3d vtMoveXY( vtMove.x, vtMove.y, 0) ;
-    double dLen = vtMove.Len() ;
-    double dLenXY = vtMoveXY.LenXY() ;
-
-   // Quote iniziale e finale
-    double dZI = ptI.z ;
-    double dZF = ptF.z ;
-
-   // Sistema di riferimento sul piano
-    Point3d ptIxy( ptI.x, ptI.y, 0) ;
-    Point3d ptFxy( ptF.x, ptF.y, 0) ;
-   // Primo vettore del riferimento
-    Vector3d vtV1( - vtToolDir.x, - vtToolDir.y, 0) ;
-    vtV1.Normalize() ;
-    Vector3d vtV2 ; 
-                
-   // Movimento verticale
-    if ( dLenXY / dLen < EPS_SMALL) {
-      // Secondo vettore del riferimento
-       vtV2 = vtV1 ;
-       vtV2.Rotate( Z_AX, 90) ;
-         
-      // Ciclo sui punti
-       for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {  
-          for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {      
-          
-             double dX = ( i + 0.5) * m_dStep ;
-             double dY = ( j + 0.5) * m_dStep ;
-
-             Point3d ptC( dX, dY, 0) ;
-             Vector3d vtC = ptC - ptIxy ;
-
-             double dX1 = vtC * vtV1 ;
-             double dX2 = vtC * vtV2 ;
-             
-             double dr = m_dRadius + ( m_dTipRadius - m_dRadius) * ( dX1 - dStemHeigth) / m_dTipHeight ;    
-            // Parte cilindrica
-             if ( dX1 > 0 && dX1 < dStemHeigth && abs( dX2) < m_dRadius) {    
-
-                double dH = sqrt( dSqRad - dX2 * dX2) ;
-                SubtractIntervals( nGrid, i, j, dZI - dH, dZF + dH) ;             
-             } 
-            // Parte conica
-             else if ( dX1 >= dStemHeigth && dX1 < m_dHeight &&  abs( dX2) < dr) {
-
-                double dH = sqrt( dr * dr - dX2 * dX2) ;
-                SubtractIntervals ( nGrid, i, j, dZI - dH, dZF + dH) ;
-             }  
-          }  
-       }  
-    }   
-    else {         
-      // Secondo vettore del riferimento
-       Vector3d vtV2 = vtMoveXY ;   
-       vtV2.Normalize() ;
-      
-      // Sistema di riferimento per determinare i piani
-       Vector3d vtW1 = ( m_dHeight > m_dTipHeight ? vtV1 : - vtV1) ; 
-       Vector3d vtW2 = vtMove ; 
-       vtW2.Normalize() ;// Se vtMove non è suff ort a vtW1 vtMove = vtMoveOrt + vtMoveLong e via
-       Vector3d vtW3 = vtW1 ^ vtW2 ;
-
-      // Altezza cono 
-       double dL = dMaxRad * m_dTipHeight / dDeltaRad ;
-
-      // Vertice del cono iniziale
-       Point3d ptV = ptI - ( m_dHeight > m_dTipHeight ? ( dStemHeigth + dL) * vtW1 : ( dL - m_dHeight) * vtW1) ; 
-
-      // 
-       double dCos = vtW2.z ;
-       double dSin = ( dCos < 1 ? sqrt( 1 - dCos * dCos) : 0) ;
-
-       double dLimXY = dCos * m_dRadius ;
-       double dLimH = dSin * m_dRadius ;
-       double dDeltaZ = ptF.z - ptI.z ;
-
-       double dMin, dMax ;
-         
-         
-     // Ciclo sui punti
-       for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
-         for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
-         
-            double dX = ( i + 0.5) * m_dStep ;
-            double dY = ( j + 0.5) * m_dStep ;
-
-            Point3d ptC( dX, dY, 0) ;
-            Vector3d vtC = ptC - ptIxy ;
-
-            double dX1 = vtC * vtV1 ; 
-            double dX2 = vtC * vtV2 ;
-
-            double dr = m_dRadius + ( m_dTipRadius - m_dRadius) * ( dX1 - dStemHeigth) / m_dTipHeight ;
-
-           // Parte cilindrica
-            if ( dX1 > 0 && dX1 < dStemHeigth && 
-                 dX2 > - m_dRadius && dX2 < dLenXY + m_dRadius) 
-            {
-              // Massimi
-               if ( dX2 < - dLimXY) 
-                  dMax = dZI + sqrt( dSqRad - dX2 * dX2) ;
-               else if ( dX2 < dLenXY - dLimXY) 
-                  dMax = dZI + dLimH + dDeltaZ * ( dX2 + dLimXY) / dLenXY ;
-               else 
-                  dMax = dZF + sqrt( dSqRad - ( dX2 - dLenXY) * ( dX2 - dLenXY)) ;
-
-              // Minimi
-               if ( dX2 <  dLimXY) 
-                  dMin = dZI + sqrt( dSqRad - dX2 * dX2) ;
-               else if ( dX2 < dLenXY + dLimXY) 
-                  dMin = dZI + dLimH + dDeltaZ * ( dX2 + dLimXY) / dLenXY ;
-               else
-                  dMin = dZF + sqrt( dSqRad - ( dX2 - dLenXY) * ( dX2 - dLenXY)) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-           // Parte conica
-            else if ( dX1 >= dStemHeigth && dX1 < m_dHeight && 
-                      dX2 > - dr && dX2 < dLenXY + dr) {
-
-               double dRadLimXY = dr * dCos ;
-               double dRadLimH = dr * dSin ;
-
-              // Massimi
-               if ( dX2 < - dRadLimXY) 
-                  dMax = dZI + sqrt( dr * dr - dX2 * dX2) ;
-               else if ( dX2 < dLenXY - dRadLimXY) 
-                  dMax = dZI + dRadLimH + dDeltaZ * ( dX2 + dRadLimXY) / dLenXY ;
-               else 
-                  dMax = dZF + sqrt( dr * dr - ( dX2 - dLenXY) * ( dX2 - dLenXY)) ;
-
-              // Minimi
-               if ( dX2 < dRadLimXY) 
-                  dMin = dZI + sqrt( dr * dr - dX2 * dX2) ;
-               else if ( dX2 < dLenXY + dRadLimXY) 
-                  dMin = dZI - dRadLimH + dDeltaZ * ( dX2 - dRadLimXY) / dLenXY ;
-               else
-                  dMin = dZF + sqrt( dr * dr - ( dX2 - dLenXY) * ( dX2 - dLenXY)) ;
-
-               SubtractIntervals( nGrid, i, j, dMin, dMax) ;
-            }
-         }
-       }   
-    }  
-    return true ;
-}*/
-
-
-// Massimi
-               //if ( dX1 < - dRad * dR1 * sqrt( 1 - ( dX2 * dX2) / ( dSqRad * dR2 * dR2)))/* && 
-                 //   dISqDist < dRad * dRad)  */
-                  
-                  //dMax = dZI + sqrt( dSqRad - dISqDist) ;
-
-               //else if ( /*dX1 >= - dRad * dR1 * sqrt( 1 - ( dX2 * dX2) / ( dRad * dRad)) &&  */
-                 //        dX1 < dPLen - dRad * dR1 * sqrt( 1 - ( dX2 * dX2) / dSqRad))
-
-                  //dMax = dZI + dR2 * sqrt( dSqRad - dX2 * dX2) + ( dX1 + dRad * dR1 * sqrt( 1 - ( dX2 * dX2) / dSqRad)) * dVLen / dPLen ;
-               
-               //else /*if ( dX1 >= dPLen - dRad * dR1 * sqrt( 1 - ( dX2 * dX2) / ( dRad * dRad)) &&
-                 //        dFSqDist < dRad * dRad)*/
-
-                  //dMax = dZI + dDeltaZ + sqrt( dSqRad - dFSqDist) ;
-          
-              // Minimi
-           //    if ( dX1 < dRad * dR1 * sqrt( 1 - ( dX2 * dX2) / dSqRad))/* && 
-             //       dISqDist < dRad * dRad) */
-
-               //   dMin = dZI - sqrt( dSqRad - dISqDist) ;
-            
-               //else if ( /*dX1 >= dRad * dR1 * sqrt( 1 - ( dX2 * dX2) / ( dRad * dRad)) &&  */
-                 //        dX1 < dPLen + dRad * dR1 * sqrt( 1 - ( dX2 * dX2) / dSqRad))
-           
-                 // dMin = dZI - dR2 * sqrt( dSqRad - dX2 * dX2) + ( dX1 - dRad * dR1 * sqrt( 1 - ( dX2 * dX2) / dSqRad)) * dVLen / dPLen ;
-
-               //else /*if ( dX1 >= dPLen + dRad * dR1 * sqrt( 1 - ( dX2 * dX2) / ( dRad * dRad)) &&
-                 //        dFSqDist < dRad * dRad)        */
-            
-                  //dMin = dZI + dDeltaZ - sqrt( dSqRad - dFSqDist) ;   
-
-
- 
\ No newline at end of file
diff --git a/VolZmap.cpp b/VolZmap.cpp
index e8bec1b..5feb9c8 100644
--- a/VolZmap.cpp
+++ b/VolZmap.cpp
@@ -28,15 +28,18 @@ GEOOBJ_REGISTER( VOL_ZMAP, NGE_V_ZMP, VolZmap) ;
 
 //----------------------------------------------------------------------------
 VolZmap::VolZmap(void)
-   : m_nStatus( TO_VERIFY), m_dStep( EPS_SMALL), m_nTempProp( 0), m_dLinTol( LIN_TOL_STD), m_dAngTolDeg( ANG_TOL_APPROX_DEG)
+   : m_nStatus( TO_VERIFY), m_dStep( EPS_SMALL), m_nTempProp( 0), m_dLinTol( LIN_TOL_STD), m_dAngTolDeg( ANG_TOL_APPROX_DEG),
+     m_nDexNumPBlock( N_DEXBLOCK)
 {
    m_nMapNum = 0 ;
+   m_nNumBlock = 0 ;
    for ( int i = 0 ; i < N_MAPS ; ++ i) {
-      m_nVNx[i] = 0 ;
-      m_nVNy[i] = 0 ;
-      m_nVDim[i] = 0 ;
-      m_dVMinZ[i] = 0 ;
-      m_dVMaxZ[i] = 0 ;
+      m_nNx[i] = 0 ;
+      m_nNy[i] = 0 ;
+      m_nDim[i] = 0 ;
+      m_dMinZ[i] = 0 ;
+      m_dMaxZ[i] = 0 ;
+      m_nFracLin[i] = 0 ;
    }
 }
 
@@ -53,12 +56,12 @@ VolZmap::Clear( void)
    m_nMapNum = 0 ;
    for ( int i = 0 ; i < N_MAPS ; ++ i) {
       m_MapFrame[i].Reset() ;
-      m_nVNx[i] = 0 ;
-      m_nVNy[i] = 0 ;
-      m_nVDim[i] = 0 ;
-      m_dVMinZ[i] = 0 ;
-      m_dVMaxZ[i] = 0 ;
-      m_TriZValues[i].clear() ;
+      m_nNx[i] = 0 ;
+      m_nNy[i] = 0 ;
+      m_nDim[i] = 0 ;
+      m_dMinZ[i] = 0 ;
+      m_dMaxZ[i] = 0 ;
+      m_Values[i].clear() ;
    }
    m_dStep = EPS_SMALL ;
    m_dLinTol = LIN_TOL_STD ;
@@ -112,14 +115,14 @@ VolZmap::CopyFrom( const VolZmap& vzmSrc)
 
       m_MapFrame[i] = vzmSrc.m_MapFrame[i]  ;
 
-      m_nVNx[i] = vzmSrc.m_nVNx[i] ; 
-      m_nVNy[i] = vzmSrc.m_nVNy[i] ;
-      m_nVDim[i] = vzmSrc.m_nVDim[i] ;
+      m_nNx[i] = vzmSrc.m_nNx[i] ; 
+      m_nNy[i] = vzmSrc.m_nNy[i] ;
+      m_nDim[i] = vzmSrc.m_nDim[i] ;
 
-      m_dVMinZ[i] = vzmSrc.m_dVMinZ[i] ;
-      m_dVMaxZ[i] = vzmSrc.m_dVMaxZ[i] ;
+      m_dMinZ[i] = vzmSrc.m_dMinZ[i] ;
+      m_dMaxZ[i] = vzmSrc.m_dMaxZ[i] ;
 
-      m_TriZValues[i] = vzmSrc.m_TriZValues[i] ; 
+      m_Values[i] = vzmSrc.m_Values[i] ; 
    }
 
    m_dStep = vzmSrc.m_dStep ;
@@ -168,9 +171,9 @@ VolZmap::Save( NgeWriter& ngeOut) const
    for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) {
       if ( ! ngeOut.WriteFrame( m_MapFrame[i], ";", true))
          return false ;   
-      if ( ! ngeOut.WriteInt( m_nVNx[i], ",", false))
+      if ( ! ngeOut.WriteInt( m_nNx[i], ",", false))
          return false ;
-      if ( ! ngeOut.WriteInt( m_nVNy[i], ";", true))
+      if ( ! ngeOut.WriteInt( m_nNy[i], ";", true))
          return false ;
    }
   // passo di campionamento (distanza tra spilloni) 
@@ -179,9 +182,9 @@ VolZmap::Save( NgeWriter& ngeOut) const
   // ciclo sulle mappe
    for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) {
      // ciclo sui dexel 
-      for ( unsigned int j = 0 ; j < m_nVDim[i] ; ++ j) {
+      for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j) {
         // numero di estremi
-         unsigned int nDim = unsigned int( m_TriZValues[i][j].size()) ;
+         unsigned int nDim = unsigned int( m_Values[i][j].size()) ;
          if ( ! ngeOut.WriteInt( nDim, ",", false))
             return false ;
         // se dexel nullo
@@ -194,7 +197,7 @@ VolZmap::Save( NgeWriter& ngeOut) const
          else {
             for ( unsigned int k = 0 ; k < nDim ; ++ k) {
                bool bEndL = ( k == nDim - 1) ;
-               if ( ! ngeOut.WriteDouble( m_TriZValues[i][j][k], ( bEndL ? ";" : ","), bEndL))
+               if ( ! ngeOut.WriteDouble( m_Values[i][j][k].dZVal, ( bEndL ? ";" : ","), bEndL))
                   return false ;
             }
          }
@@ -215,11 +218,11 @@ VolZmap::Load( NgeReader& ngeIn)
    for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) {
       if ( ! ngeIn.ReadFrame( m_MapFrame[i], ";", true))
          return false ;
-      if ( ! ngeIn.ReadInt( m_nVNx[i], ",", false))
+      if ( ! ngeIn.ReadInt( m_nNx[i], ",", false))
          return false ;
-      if ( ! ngeIn.ReadInt( m_nVNy[i], ";", true))
+      if ( ! ngeIn.ReadInt( m_nNy[i], ";", true))
          return false ;
-      m_nVDim[i] = m_nVNx[i] * m_nVNy[i] ;
+      m_nDim[i] = m_nNx[i] * m_nNy[i] ;
    }
   // passo di campionamento (distanza tra spilloni) 
    if ( ! ngeIn.ReadDouble( m_dStep, ";", true))
@@ -227,9 +230,9 @@ VolZmap::Load( NgeReader& ngeIn)
   // ciclo sulle mappe
    for ( unsigned int i = 0 ; i < m_nMapNum ; ++ i) {
      // dimensiono i vettori
-      m_TriZValues[i].resize( m_nVDim[i]) ;   
+      m_Values[i].resize( m_nDim[i]) ;   
      // ciclo sui dexel
-      for ( unsigned int j = 0 ; j < m_nVDim[i] ; ++ j)  {
+      for ( unsigned int j = 0 ; j < m_nDim[i] ; ++ j)  {
         // leggo il numero di estremi nel dexel
          unsigned int nDim ;
          if ( ! ngeIn.ReadInt( nDim, ",", false))
@@ -247,11 +250,11 @@ VolZmap::Load( NgeReader& ngeIn)
         // altrimenti 
          else {
            // dimensiono l'array
-            m_TriZValues[i][j].resize( nDim) ;
+            m_Values[i][j].resize( nDim) ;
            // leggo i valori
             for ( unsigned int k = 0 ; k < nDim ; ++ k) {
                bool bEndL = ( k == nDim - 1) ;
-               if ( ! ngeIn.ReadDouble( m_TriZValues[i][j][k], ( bEndL ? ";" : ","), bEndL))
+               if ( ! ngeIn.ReadDouble( m_Values[i][j][k].dZVal, ( bEndL ? ";" : ","), bEndL))
                   return false ;
             }
          }
@@ -274,24 +277,24 @@ VolZmap::GetLocalBBox( BBox3d& b3Loc, int nFlag) const
   // se richiesto approssimato
    if ( ( nFlag & BBF_EXACT) == 0) {
       b3Loc.Add( ORIG) ;
-      b3Loc.Add( Point3d( m_nVNx[0] * m_dStep, m_nVNy[0] * m_dStep, m_dVMaxZ[0])) ;
+      b3Loc.Add( Point3d( m_nNx[0] * m_dStep, m_nNy[0] * m_dStep, m_dMaxZ[0])) ;
       b3Loc.ToGlob( m_MapFrame[0]) ;
       return true ;
    }
   // calcolo preciso
    // ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga)
    double dY = 0 ;
-   for ( size_t j = 0 ; j <= m_nVNy[0] ; ++ j) {
-      size_t jc = ( ( j != m_nVNy[0]) ? j : m_nVNy[0] -1) ;
+   for ( size_t j = 0 ; j <= m_nNy[0] ; ++ j) {
+      size_t jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] -1) ;
       double dX = 0 ;
      // punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo)
-      for ( size_t i = 0 ; i <= m_nVNx[0] ; ++ i) {
-         size_t ic = ( ( i != m_nVNx[0]) ? i : m_nVNx[0] -1) ;
-         size_t nPos = ic + jc * m_nVNx[0] ;
-         if ( m_TriZValues[0][nPos].size() > 0) {
+      for ( size_t i = 0 ; i <= m_nNx[0] ; ++ i) {
+         size_t ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] -1) ;
+         size_t nPos = ic + jc * m_nNx[0] ;
+         if ( m_Values[0][nPos].size() > 0) {
             Point3d ptP = m_MapFrame[0].Orig() + dX * m_MapFrame[0].VersX() + dY * m_MapFrame[0].VersY() ;
-            b3Loc.Add( ptP + m_TriZValues[0][nPos][0] * m_MapFrame[0].VersZ()) ;
-            b3Loc.Add( ptP + m_TriZValues[0][nPos][m_TriZValues[0][nPos].size()-1] * m_MapFrame[0].VersZ()) ;
+            b3Loc.Add( ptP + m_Values[0][nPos][0].dZVal * m_MapFrame[0].VersZ()) ;
+            b3Loc.Add( ptP + m_Values[0][nPos][m_Values[0][nPos].size()-1].dZVal * m_MapFrame[0].VersZ()) ;
          }
         // passo al punto successivo
          dX += m_dStep ;
@@ -318,24 +321,24 @@ VolZmap::GetBBox( const Frame3d& frRef, BBox3d& b3Ref, int nFlag) const
   // se richiesto approssimato
    if ( ( nFlag & BBF_EXACT) == 0) {
       b3Ref.Add( ORIG) ;
-      b3Ref.Add( Point3d( m_nVNx[0] * m_dStep, m_nVNy[0] * m_dStep, m_dVMaxZ[0])) ;
+      b3Ref.Add( Point3d( m_nNx[0] * m_dStep, m_nNy[0] * m_dStep, m_dMaxZ[0])) ;
       b3Ref.ToGlob( frUse) ;
       return true ;
    }
   // calcolo preciso
    // ciclo sui dexel (punti in basso con ciclo aggiunto per punti in alto di ultima riga)
    double dY = 0 ;
-   for ( size_t j = 0 ; j <= m_nVNy[0] ; ++ j) {
-      size_t jc = ( ( j != m_nVNy[0]) ? j : m_nVNy[0] -1) ;
+   for ( size_t j = 0 ; j <= m_nNy[0] ; ++ j) {
+      size_t jc = ( ( j != m_nNy[0]) ? j : m_nNy[0] -1) ;
       double dX = 0 ;
      // punto a sinistra di ogni dexel (aggiungo un ciclo per fare punto a destra di ultimo)
-      for ( size_t i = 0 ; i <= m_nVNx[0] ; ++ i) {
-         size_t ic = ( ( i != m_nVNx[0]) ? i : m_nVNx[0] -1) ;
-         size_t nPos = ic + jc * m_nVNx[0] ;
-         if ( m_TriZValues[0][nPos].size() > 0) {
+      for ( size_t i = 0 ; i <= m_nNx[0] ; ++ i) {
+         size_t ic = ( ( i != m_nNx[0]) ? i : m_nNx[0] -1) ;
+         size_t nPos = ic + jc * m_nNx[0] ;
+         if ( m_Values[0][nPos].size() > 0) {
             Point3d ptP = frUse.Orig() + dX * frUse.VersX() + dY * frUse.VersY() ;
-            b3Ref.Add( ptP + m_TriZValues[0][nPos][0] * frUse.VersZ()) ;
-            b3Ref.Add( ptP + m_TriZValues[0][nPos][m_TriZValues[0][nPos].size()-1] * frUse.VersZ()) ;
+            b3Ref.Add( ptP + m_Values[0][nPos][0].dZVal * frUse.VersZ()) ;
+            b3Ref.Add( ptP + m_Values[0][nPos][m_Values[0][nPos].size()-1].dZVal * frUse.VersZ()) ;
          }
         // passo al punto successivo
          dX += m_dStep ;
diff --git a/VolZmap.h b/VolZmap.h
index 69711a1..246e6d4 100644
--- a/VolZmap.h
+++ b/VolZmap.h
@@ -16,12 +16,20 @@
 #include "ObjGraphicsMgr.h"
 #include "GeoObjRW.h"
 #include "CurveComposite.h"
+#include "SurfFlatRegion.h"
 #include "/EgtDev/Include/EGkVolZmap.h"
 #include "/EgtDev/Include/EGkPoint3d.h"
 #include "/EgtDev/Include/EGkVector3d.h"
 #include "/EgtDev/Include/ENkPolynomialRoots.h"
 #include "/EgtDev/Include/EgkIntersLinesurfTm.h"
-#include "SurfFlatRegion.h"
+      
+//----------------------------------------------------------------------------
+struct TriaStruct {
+   int i, j, k ;
+   Point3d ptVert ;
+   TRIA3DVECTOR vecTria ;
+} ;
+typedef std::vector <TriaStruct> TriHolder ;
 
 //----------------------------------------------------------------------------
 class VolZmap : public IVolZmap, public IGeoObjRW
@@ -65,6 +73,8 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool CreateFromFlatRegion( const ISurfFlatRegion& Surf, double dDimZ, double dPrec, bool bTriDex) override ;
       bool CreateFromTriMesh( const ISurfTriMesh& Surf, double dPrec, bool bTriDex) override ;
       bool GetAllTriangles( TRIA3DLIST& lstTria) const override ;
+      bool GetBlockTriangles( int nBlock, TRIA3DLIST& lstTria) const override ;
+      bool GetBlockInfo( std::vector<bool> & bModified) const override ;
       bool GetDexelLines( int nDir, int nPos1, int nPos2, POLYLINELIST& lstPL) const override ;
       bool SetTolerances( double dLinTol, double dAngTolDeg = 90) override ;
       bool SetStdTool( const std::string& pToolName, double dH, double dR, double dCornR) override ;
@@ -105,78 +115,85 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       bool AddDexelSideFace( int nPos, int nPosAdj, const Point3d& ptP, const Point3d& ptQ,
                              const Vector3d& vtZ, const Vector3d& vtNorm, TRIA3DLIST& lstTria) const ;
       bool MarchingCubes( TRIA3DLIST& lstTria) const ;
+      bool MarchingCubes( int nBlock, TRIA3DLIST& lstTria) const ;
+      bool ExtMarchingCubes( int nBlock, TRIA3DLIST& lstTria, TriHolder& triHold) const ; 
+      bool FlipEdges( TriHolder& triHold) const ;
+      bool FlipEdges( int nBlock, TriHolder& triHold) ;
+      bool FlipEdges( int nNumBlocks, int nBlocks[], TriHolder triHold []) ;
       bool IsThereMat( int nI, int nJ, int nK) const ;
       bool IsThereMat( const int nMatr[][3], int nNum, double & dHx, double & dHy, double & dHz) const ;
       bool IntersPos( int nVec1[], int nVec2[], Point3d & ptInt) const ;
+      bool IntersPos( int nVec1[], int nVec2[], Point3d & ptInt, Vector3d & vtNormal) const ;
       
      // OPERAZIONI SU INTERVALLI
-      bool SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, double dMin, double dMax) ;
-      bool SubtractIntervals( unsigned int nGrid, const Point3d& ptP, double dMin, double dMax) ;
-      bool AddIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ, double dMin, double dMax) ;
-      bool AddIntervals( unsigned int nGrid, const Point3d& ptP, double dMin, double dMax) ;         
+      bool SubtractIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ,
+                              double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) ;
+      bool SubtractIntervals( unsigned int nGrid, const Point3d& ptP,
+                              double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) ;
+      bool AddIntervals( unsigned int nGrid, unsigned int nI, unsigned int nJ,
+                         double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) ;
+      bool AddIntervals( unsigned int nGrid, const Point3d& ptP,
+                         double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) ;         
 
     // SOTTRAZIONI 
     // UTENSILI
      // Asse di simmetria parallelo a Z
-      bool CylBall_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool CylBall_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ; 
+      bool CylBall_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool CylBall_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool CylBall_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d& vtToolDir) ; 
       
-      bool Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool Conus_ZPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool Conus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
+      bool Conus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool Conus_ZPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool Conus_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
 
-      bool Dr_ZMilling( unsigned int nGrid, const Point3d & ptLs, const Point3d & ptLe, const Vector3d & vtToolDir) ;
-      bool Sw_ZMilling( unsigned int nGrid, const Point3d & ptLs, const Point3d & ptLe, const Vector3d & vtToolDir) ;
+      bool Dr_ZMilling( unsigned int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d & vtToolDir) ;
+      bool Sw_ZMilling( unsigned int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d & vtToolDir) ;
 
-      bool GenTool_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool GenTool_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
+      bool GenTool_ZDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool GenTool_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
 
      // Asse di simmetria nel piano
-      bool CylBall_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool CylBall_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool CylBall_XYMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
+      bool CylBall_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool CylBall_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool CylBall_XYMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
 
-      bool Conus_XYDrilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool Conus_XYPerp( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool Conus_XYMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
+      bool Conus_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool Conus_XYPerp( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool Conus_XYMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
 
      // Asse di simmetria con orientazione generica 
-      bool CylBall_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool CylBall_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
+      bool CylBall_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool CylBall_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
 
-      bool Conus_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool Conus_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
+      bool Conus_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool Conus_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
 
-      bool GenTool_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
-      bool GenTool_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir) ;
+      bool GenTool_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
+      bool GenTool_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir) ;
 
     // COMPONENTI
      // Asse di simmetria diretto come l'asse Z 
 
      // Drilling
-      bool CompCyl_ZDrilling( unsigned int nGrid, const Point3d & ptLs, const Point3d & ptLe, const Vector3d & vtToolDir, double dHei, double dRad) ;
-      bool CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptLs, const Point3d & ptLe, const Vector3d & vtToolDir, double dHei, double dMaxRad, double dMinRad) ;
+      bool CompCyl_ZDrilling( unsigned int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir, double dHei, double dRad) ;
+      bool CompConus_ZDrilling( unsigned int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad) ;
 
      // Milling
-      bool CompCyl_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dRad) ;
-      bool CompConus_ZMilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dMaxRad, double dMinRad) ;
+      bool CompCyl_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad) ;
+      bool CompConus_ZMilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad) ;
 
      // Asse di simmetria con orientazione generica
 
      // Drilling
-      bool CompCyl_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dRad) ;
-      bool CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dMaxRad, double dMinRad) ;
+      bool CompCyl_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad) ;
+      bool CompConus_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad) ;
 
      // Milling      
-      bool CompCyl_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dRad) ;
-      bool CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, double dHei, double dMaxRad, double dMinRad) ;
-      bool CompConusAux_Milling( unsigned int nGrid, const Point3d & ptI, const Point3d & ptF, const Vector3d & vtV1, const Vector3d & vtV2, const Vector3d & vtV3, 
-                                 unsigned int & nStI, unsigned int & nStJ, unsigned int & nEnI, unsigned int & nEnJ,
-                                 double dHei, double dMaxRad, double dMinRad, double dCoef) ;
+      bool CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dRad) ;
+      bool CompConus_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, double dHei, double dMaxRad, double dMinRad) ;
 
      // Generica traslazione sfera
-      bool CompBall_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, double dRad) ;
+      bool CompBall_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, double dRad) ;
    
     // BBox per utensili e solidi semplici
       inline bool BoundingBox( unsigned int nGrid, const Point3d& ptP1, const Point3d& ptP2, const Vector3d& vtV1, const Vector3d& vtV2,
@@ -198,20 +215,25 @@ class VolZmap : public IVolZmap, public IGeoObjRW
                                const Frame3d& CylFrame, double dL, double dR,
                                Point3d& ptInt1, Point3d& ptInt2) ;
       bool IntersZLineCylinder( const Point3d& ptLine,
-                                const Point3d& ptBase, const Point3d& ptTop, const Vector3d& vtDir, double dCylR,
+                                const Point3d& ptBase, const Point3d& ptTop, double dCylR,
                                 double& dInfZ, double& dSupZ) ;
-      bool IntersLineEllipticalCylinder( const Frame3d& CircFrame, const Vector3d& vtLineDir, const Point3d& ptLineSt,
-                                         PNTVECTOR& ptInters, double dObCoef, double dSqRad, double dL) ;
+      bool IntersLineEllipticalCylinder( const Vector3d& vtLineDir, const Point3d& ptLineSt,
+                                         const Frame3d& CircFrame, double dSqRad, double dLongMvLen, double dOrtMvLen,
+                                         Point3d& ptInt1, Point3d& ptInt2) ;
       bool IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
                             const Frame3d& ConusFrame, double dTan, double dl, double dL,
                             Point3d& ptInt1, Point3d& ptInt2) ;
       bool IntersLineSphere( const Point3d& ptLineSt, const Vector3d& vtLineDir,
                              const Point3d& ptCenter, double dRad,
                              Point3d& ptInt1, Point3d& ptInt2) ;
+      bool IntersLineMyPolyhedron( const Point3d& ptLineSt, const Vector3d& vtLineDir,
+                                        const Frame3d& PolyFrame, double dLenX, double dLenY, double dLenZ, double dDeltaX,
+                                        Point3d& ptInt1, Point3d& ptInt2) ;
 
    private :
       enum Status { ERR = 0, OK = 1, TO_VERIFY = 2} ;
       static const int N_MAPS = 3 ;
+      static const int N_DEXBLOCK = 10000 ;
 
    private :
       ObjGraphicsMgr m_OGrMgr ;             // gestore grafica dell'oggetto
@@ -220,13 +242,26 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       double         m_dStep ;              // passo delle griglie
       unsigned int   m_nMapNum ;            // numero di griglie ( 1 o 3)
       Frame3d        m_MapFrame[N_MAPS] ;   // riferimenti delle griglie
-      unsigned int   m_nVNx[N_MAPS] ;       // dimensione di ciascuna griglia in X
-      unsigned int   m_nVNy[N_MAPS] ;       // dimensione di ciascuna griglia in Y
-      unsigned int   m_nVDim[N_MAPS] ;      // dimensione di ciascuna griglia ( X * Y)
-      double         m_dVMinZ[N_MAPS] ;     // minimo in Zlocale di ciascuna griglia
-      double         m_dVMaxZ[N_MAPS] ;     // massimo in Zlocale di ciascuna griglia
-      std::vector<std::vector<double>> m_TriZValues[N_MAPS] ;  // dexel delle 3 griglie
-      double         m_dLinTol ;            // dati per utensile
+      unsigned int   m_nNx[N_MAPS] ;        // dimensione di ciascuna griglia in X
+      unsigned int   m_nNy[N_MAPS] ;        // dimensione di ciascuna griglia in Y
+      unsigned int   m_nDim[N_MAPS] ;       // dimensione di ciascuna griglia ( X * Y)
+      double         m_dMinZ[N_MAPS] ;      // minimo in Zlocale di ciascuna griglia
+      double         m_dMaxZ[N_MAPS] ;      // massimo in Zlocale di ciascuna griglia
+
+      struct Data {                         // Struttura dati: estremi del dexel e versori normali
+         double dZVal ;
+         Vector3d vtN ;
+      } ;
+
+      std::vector<std::vector<Data>> m_Values[N_MAPS] ;  // dexel delle 3 griglie
+
+      unsigned int m_nDexNumPBlock ;        // Numero di dexel per blocco
+      unsigned int m_nFracLin[3] ;          // Numero di blocchi per per ogni asse           
+      unsigned int m_nNumBlock ;            // Numero totale di blocchi
+
+      mutable std::vector<bool> m_BlockToUpdate ;
+               
+      double         m_dLinTol ;            // Dati per utensile
       double         m_dAngTolDeg ;
       std::string    m_sToolName ;
       unsigned int   m_nToolType ; 
@@ -239,6 +274,7 @@ class VolZmap : public IVolZmap, public IGeoObjRW
       double         m_dTipRadius ;
 } ;
 
+
 //-----------------------------------------------------------------------------
 inline VolZmap* CreateBasicVolZmap( void)
                { return (static_cast<VolZmap*>( CreateGeoObj( VOL_ZMAP))) ; }