From 21a1f9e35d6ad216d445b81e2bd35ff3e8751b60 Mon Sep 17 00:00:00 2001
From: Dario Sassi <dario.s@egaltech.com>
Date: Fri, 9 Feb 2018 07:41:15 +0000
Subject: [PATCH] EgtGeomKernel : - modifiche a calcolo spilloni di Zmap e
 varie altre.

---
 VolZmapCalculus.cpp | 356 +++++++++++++++++++++-----------------------
 VolZmapGraphics.cpp |   2 +-
 VolZmapVolume.cpp   | 333 ++++++++++++++++++-----------------------
 3 files changed, 321 insertions(+), 370 deletions(-)

diff --git a/VolZmapCalculus.cpp b/VolZmapCalculus.cpp
index 48ec91c..0768267 100644
--- a/VolZmapCalculus.cpp
+++ b/VolZmapCalculus.cpp
@@ -694,56 +694,53 @@ VolZmap::AvoidCylinder( const Frame3d& frCyl, double dL, double dR) const
 }
 
 //----------------------------------------------------------------------------
+// NB: L'origine del sistema di riferimento è nel centro della circonferenza di base
+// e l'asse di simmetria coincide con l'asse z. 
+// La funzione restituisce true in caso di intersezione, false altrimenti.
 bool
 VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
-                             const Frame3d& CylFrame, double dL, double dR, bool bTapO, bool bTapL,
+                             const Frame3d& CylFrame, double dH, double dR, bool bTapO, bool bTapL,
                              Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2) 
 {  
-  // NB: L'origine del sistema di riferimento è nel centro della circonferenza di base
-  // e l'asse di simmetria coincide con l'asse x. 
-  // La funzione restituisce true in caso di intersezione, false altrimenti.
-
    Point3d ptP = ptLineSt ;
    Vector3d vtV = vtLineDir ; 
 
   // Trasformazione delle coordinate:
   // l'asse del cilindro corrisponde con
-  // l'asse x del sistema di riferimento
+  // l'asse z del sistema di riferimento
    ptP.ToLoc( CylFrame) ;
    vtV.ToLoc( CylFrame) ;
 
    DBLVECTOR vdCoef(3) ;
    DBLVECTOR vdRoots ;
+  // Non vogliamo che i dexel a filo vengano tagliati
+   double dSqRad = dR * dR ;
+   double dSqRadSafe = dSqRad - 2 * dR * EPS_SMALL ;
 
-   double dSqRad = dR * dR - 2 * dR * EPS_SMALL ;
-
-   vdCoef[0] = ptP.y * ptP.y + ptP.z * ptP.z - dSqRad ;
-   vdCoef[1] = 2 * ( ptP.y * vtV.y + ptP.z * vtV.z) ;
-   vdCoef[2] = vtV.y * vtV.y + vtV.z * vtV.z ;
+   vdCoef[0] = ptP.x * ptP.x + ptP.y * ptP.y - dSqRad ;
+   vdCoef[1] = 2 * ( ptP.x * vtV.x + ptP.y * vtV.y) ;
+   vdCoef[2] = vtV.x * vtV.x + vtV.y * vtV.y ;
 
   // Computo radici
    int nRoot = PolynomialRoots( 2, vdCoef, vdRoots) ;
 
   // Nessuna soluzione 
    if ( nRoot == 0 || nRoot == 1) {
-
-      if ( abs( vtV.x) > EPS_ZERO) {
-      
-         ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;
-         ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
-
-         vtN1 = X_AX ;
-         vtN2 = - X_AX ;
-
-         if ( ptInt1.y * ptInt1.y + ptInt1.z * ptInt1.z <= dSqRad  &&
-              ptInt2.y * ptInt2.y + ptInt2.z * ptInt2.z <= dSqRad) {
-
+      if ( abs( vtV.z) > EPS_ZERO) {
+        // Intersezioni con i piani che limitano il cilindro in altezza
+         ptInt1 = ptP - ( ptP.z / vtV.z) * vtV ;
+         ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ;
+        // Normali nei punti di interseione
+         vtN1 = Z_AX ;
+         vtN2 = - Z_AX ;
+        // Se le soluzioni sono all'interno delle circonferenze
+         if ( ptInt1.x * ptInt1.x + ptInt1.y * ptInt1.y <= dSqRadSafe  &&
+              ptInt2.x * ptInt2.x + ptInt2.y * ptInt2.y <= dSqRadSafe) {
+           // Trasformiamo le coordinate nel sistema Zmap e abbiamo finito 
             ptInt1.ToGlob( CylFrame) ;
             ptInt2.ToGlob( CylFrame) ;
-
             vtN1.ToGlob( CylFrame) ;
-            vtN2.ToGlob( CylFrame) ;
-           
+            vtN2.ToGlob( CylFrame) ;    
             return true ;
          }
         // Nessuna intersezione
@@ -760,43 +757,40 @@ VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
   // appartiene alla superficie
 
    if ( nRoot == 2) {
-
+     // Tolleranze per tagliare o meno i dexel a filo sulle 
+     // circonferenze di base e di top.
       double dEpsO = ( bTapO ? - EPS_SMALL : EPS_SMALL) ;
       double dEpsL = ( bTapL ? EPS_SMALL : - EPS_SMALL) ;
-
+     // Punti d'intersezione trovati
       ptInt1 = ptP + vdRoots[0] * vtV ;
       ptInt2 = ptP + vdRoots[1] * vtV ;
 
-      if ( ptInt1.x > ptInt2.x)
+      if ( ptInt1.z > ptInt2.z)
          swap( ptInt1, ptInt2) ; 
 
-      vtN1.Set( 0, ( ORIG - ptInt1).y, ( ORIG - ptInt1).z) ;
-      vtN2.Set( 0, ( ORIG - ptInt2).y, ( ORIG - ptInt2).z) ;
-      
-
-      if ( ptInt1.x < dL + dEpsL) {
-      
-         if (  ptInt1.x > dEpsO) {
-
-            if ( ptInt2.x > dL + dEpsL) {
-
-               ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;  
-               vtN2.Set( -1, 0, 0) ;
+     // Setto le normali
+      vtN1.Set( ( ORIG - ptInt1).x, ( ORIG - ptInt1).y, 0) ;
+      vtN2.Set( ( ORIG - ptInt2).x, ( ORIG - ptInt2).y, 0) ;
+      vtN1.Normalize() ;
+      vtN2.Normalize() ;
+     // Studio le soluzioni 
+      if ( ptInt1.z < dH + dEpsL) {     
+         if (  ptInt1.z > dEpsO) {
+            if ( ptInt2.z > dH + dEpsL) {
+               ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ;  
+               vtN2.Set( 0, 0, -1) ;
             }
          }
          else {
-
-            if ( ptInt2.x > dL + dEpsL) {
-            
-               ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;
-               ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
-               vtN1.Set( 1, 0, 0) ;
-               vtN2.Set( -1, 0, 0) ;
+            if ( ptInt2.z > dH + dEpsL) {          
+               ptInt1 = ptP - ( ptP.z / vtV.z) * vtV ;
+               ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ;
+               vtN1.Set( 0, 0, 1) ;
+               vtN2.Set( 0, 0, -1) ;
             }
-            else if ( ptInt2.x > dEpsO) {
-            
-               ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;                 
-               vtN1.Set( 1, 0, 0) ;
+            else if ( ptInt2.z > dEpsO) {          
+               ptInt1 = ptP - ( ptP.z / vtV.z) * vtV ;                 
+               vtN1.Set( 0, 0, 1) ;
             }
             else 
                return false ;
@@ -809,12 +803,8 @@ VolZmap::IntersLineCylinder( const Point3d& ptLineSt, const Vector3d& vtLineDir,
       ptInt1.ToGlob( CylFrame) ;
       ptInt2.ToGlob( CylFrame) ;
       vtN1.ToGlob( CylFrame) ;
-      vtN2.ToGlob( CylFrame) ;
-
-      vtN1.Normalize() ;
-      vtN2.Normalize() ;
+      vtN2.ToGlob( CylFrame) ;      
    }                  
-
    return true ;
 }
 
@@ -926,7 +916,7 @@ VolZmap::IntersZLineCylinder( const Point3d& ptLine,
 //----------------------------------------------------------------------------
 bool
 VolZmap::IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
-                          const Frame3d& ConusFrame, double dTan, double dl, double dL, bool bTapLow, bool bTapUp,
+                          const Frame3d& ConusFrame, double dTan, double dh, double dH, bool bTapLow, bool bTapUp,
                           Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2) 
 {
   // NB: L'origine del sistema di riferimento deve essere 
@@ -944,14 +934,14 @@ VolZmap::IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
    DBLVECTOR vdRoots ;
 
    double dSqTan = dTan * dTan ;
-   double dMinRad = dTan * dl ;
-   double dMaxRad = dTan * dL ;
+   double dMinRad = dTan * dh ;
+   double dMaxRad = dTan * dH ;
    double dDeltaR = dMaxRad - dMinRad ;
-   double dHei = dL - dl ;
+   double dHei = dH - dh ;
           
-   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) ;
-   vdCoef[2] = dSqTan * vtV.x * vtV.x - vtV.y * vtV.y - vtV.z * vtV.z ;
+   vdCoef[0] = dSqTan * ptP.z * ptP.z - ptP.x * ptP.x - ptP.y * ptP.y ;
+   vdCoef[1] = 2 * ( dSqTan * ptP.z * vtV.z - ptP.x * vtV.x - ptP.y * vtV.y) ;
+   vdCoef[2] = dSqTan * vtV.z * vtV.z - vtV.x * vtV.x - vtV.y * vtV.y ;
 
   // Computo radici
    int nRoot = PolynomialRoots( 2, vdCoef, vdRoots) ;
@@ -969,32 +959,32 @@ VolZmap::IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
 
       ptInt1 = ptP + vdRoots[0] * vtV ;
       
-      Vector3d vtU = ( ptInt1 - ORIG) - ( ptInt1 - ORIG).x * X_AX ;
+      Vector3d vtU = ( ptInt1 - ORIG) - ( ptInt1 - ORIG).z * Z_AX ;
 
       vtU.Normalize() ;
 
-      vtN1 = dDeltaR * X_AX - dHei * vtU ;
+      vtN1 = dDeltaR * Z_AX - dHei * vtU ;
 
       vtN1.Normalize() ;
 
-      if ( ptInt1.x < dL + dEpsUp) {
+      if ( ptInt1.z < dH + dEpsUp) {
 
-         if ( ptInt1.x > dl + dEpsLow) {
+         if ( ptInt1.z > dh + dEpsLow) {
       
-            ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
+            ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ;
 
-            vtN2 = - X_AX ;
+            vtN2 = - Z_AX ;
 
          }
-         else if ( ptInt1.x > - EPS_SMALL) {
+         else if ( ptInt1.z > - EPS_SMALL) {
 
-            ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
-            ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;  
+            ptInt1 = ptP + ( ( dh - ptP.z) / vtV.z) * vtV ;
+            ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ;  
 
-            vtN1 = X_AX ;
-            vtN2 = - X_AX ;
+            vtN1 = Z_AX ;
+            vtN2 = - Z_AX ;
 
-            if ( ptInt2.y * ptInt2.y + ptInt2.z * ptInt2.z > dMaxRad * dMaxRad)
+            if ( ptInt2.x * ptInt2.x + ptInt2.y * ptInt2.y > dMaxRad * dMaxRad)
 
                  return false ;
          }
@@ -1020,24 +1010,24 @@ 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.z > ptInt2.z) 
          swap( ptInt1, ptInt2) ;
 
-      Vector3d vtU1 = ( ptInt1 - ORIG) - ( ptInt1 - ORIG).x * X_AX ;
-      Vector3d vtU2 = ( ptInt2 - ORIG) - ( ptInt2 - ORIG).x * X_AX ;
+      Vector3d vtU1 = ( ptInt1 - ORIG) - ( ptInt1 - ORIG).z * Z_AX ;
+      Vector3d vtU2 = ( ptInt2 - ORIG) - ( ptInt2 - ORIG).z * Z_AX ;
 
       vtU1.Normalize() ;
       vtU2.Normalize() ;
 
-      vtN1 = dDeltaR * X_AX - dHei * vtU1 ;
-      vtN2 = dDeltaR * X_AX - dHei * vtU2 ;
+      vtN1 = dDeltaR * Z_AX - dHei * vtU1 ;
+      vtN2 = dDeltaR * Z_AX - dHei * vtU2 ;
 
       vtN1.Normalize() ;
       vtN2.Normalize() ;
 
-      if ( abs( vtV.x) < EPS_ZERO) {
+      if ( abs( vtV.z) < EPS_ZERO) {
 
-         if ( ptInt1.x > dl + dEpsLow && ptInt1.x < dL + dEpsUp) {
+         if ( ptInt1.z > dh + dEpsLow && ptInt1.z < dH + dEpsUp) {
          
             ptInt1.ToGlob( ConusFrame) ;
             ptInt2.ToGlob( ConusFrame) ;
@@ -1055,53 +1045,53 @@ VolZmap::IntersLineConus( const Point3d& ptLineSt, const Vector3d& vtLineDir,
       }
      
 
-      if ( ptInt1.x < dL + dEpsUp) {
+      if ( ptInt1.z < dH + dEpsUp) {
       
-         if ( ptInt1.x > dl + dEpsLow) {
+         if ( ptInt1.z > dh + dEpsLow) {
 
-            if ( ptInt2.x > dL + dEpsUp) { 
+            if ( ptInt2.z > dH + dEpsUp) { 
 
-               ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ; 
+               ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ; 
 
-               vtN2 = - X_AX ;
+               vtN2 = - Z_AX ;
             }
          }
-         else if ( ptInt1.x > - EPS_SMALL) {
+         else if ( ptInt1.z > - EPS_SMALL) {
 
-            if ( ptInt2.x > dL + dEpsUp) {
+            if ( ptInt2.z > dH + dEpsUp) {
 
-               ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
-               ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;  
+               ptInt1 = ptP + ( ( dh - ptP.z) / vtV.z) * vtV ;
+               ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ;  
 
-               vtN1 = X_AX ;
-               vtN2 = - X_AX ;
+               vtN1 = Z_AX ;
+               vtN2 = - Z_AX ;
             }
-            else if ( ptInt2.x > dl + dEpsLow) { 
+            else if ( ptInt2.z > dh + dEpsLow) { 
 
-               ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
-               vtN1 = X_AX ;
+               ptInt1 = ptP + ( ( dh - ptP.z) / vtV.z) * vtV ;
+               vtN1 = Z_AX ;
             }
             else 
                return false ;
          }
          else {
 
-            if ( ptInt2.x < 0) 
+            if ( ptInt2.z < 0) 
 
                return false ;
 
-            else if ( ptInt2.x < dl + dEpsLow) {
+            else if ( ptInt2.z < dh + dEpsLow) {
 
-               ptInt1 = ptP + ( ( dl - ptP.x) / vtV.x) * vtV ;
-               ptInt2 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ; 
+               ptInt1 = ptP + ( ( dh - ptP.z) / vtV.z) * vtV ;
+               ptInt2 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ; 
 
-               vtN1 = X_AX ;
-               vtN2 = - X_AX ;
+               vtN1 = Z_AX ;
+               vtN2 = - Z_AX ;
             }          
-            else if ( ptInt2.x < dL + dEpsUp) { 
+            else if ( ptInt2.z < dH + dEpsUp) { 
 
-               ptInt1 = ptP + ( ( dL - ptP.x) / vtV.x) * vtV ;
-               vtN1 = - X_AX ;
+               ptInt1 = ptP + ( ( dH - ptP.z) / vtV.z) * vtV ;
+               vtN1 = - Z_AX ;
             }
             else 
                return false ;
@@ -1133,13 +1123,13 @@ VolZmap::IntersLineEllipticalCylinder( const Vector3d& vtLineDir, const Point3d&
 {
   // NB: L'origine del sistema di riferimento deve essere 
   // nel centro della circonferenza di base, la cui traslazione obliqua
-  // genera il cilindro ellittico, e l'asse x deve essere l'asse 
+  // genera il cilindro ellittico, e l'asse z deve essere l'asse 
   // di simmetria di tale circonferenza.
   // La funzione restituisce true in caso di intersezione, false altrimenti.
   // 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. 
+  // movimento su z e x del sistema di riferimento CircFrame. 
 
    double dObCoef = dOrtMvLen / dLongMvLen ;
    double dSqCoef = dObCoef * dObCoef ;
@@ -1148,7 +1138,7 @@ VolZmap::IntersLineEllipticalCylinder( const Vector3d& vtLineDir, const Point3d&
    Vector3d vtV = vtLineDir ; 
 
   // Asse cilindro ellittico
-   Vector3d vtAx( dLongMvLen, dOrtMvLen, 0) ;
+   Vector3d vtAx( dOrtMvLen, 0, dLongMvLen) ;
    vtAx.Normalize() ;
 
   // Trasformazione delle coordinate
@@ -1158,9 +1148,9 @@ VolZmap::IntersLineEllipticalCylinder( const Vector3d& vtLineDir, const Point3d&
    vector <double> vdCoef(3) ;
    vector <double> vdRoots ;
 
-   vdCoef[0] = dSqCoef * ptP.x * ptP.x + ptP.y * ptP.y + ptP.z * ptP.z - 2 * dObCoef * ptP.x * ptP.y - dSqRad ;
-   vdCoef[1] = 2 * ( dSqCoef * vtV.x * ptP.x + vtV.y * ptP.y + vtV.z * ptP.z - dObCoef * ( vtV.x * ptP.y + vtV.y * ptP.x)) ;
-   vdCoef[2] = dSqCoef * vtV.x * vtV.x + vtV.y * vtV.y + vtV.z * vtV.z - 2 * dObCoef * vtV.x * vtV.y ;
+   vdCoef[0] = dSqCoef * ptP.z * ptP.z + ptP.x * ptP.x + ptP.y * ptP.y - 2 * dObCoef * ptP.z * ptP.x - dSqRad ;
+   vdCoef[1] = 2 * ( dSqCoef * vtV.z * ptP.z + vtV.x * ptP.x + vtV.y * ptP.y - dObCoef * ( vtV.z * ptP.x + vtV.x * ptP.z)) ;
+   vdCoef[2] = dSqCoef * vtV.z * vtV.z + vtV.x * vtV.x + vtV.y * vtV.y - 2 * dObCoef * vtV.z * vtV.x ;
 
    int nRoot = PolynomialRoots( 2, vdCoef, vdRoots) ;
 
@@ -1168,19 +1158,19 @@ VolZmap::IntersLineEllipticalCylinder( const Vector3d& vtLineDir, const Point3d&
    // Nessuna soluzione 
    if ( nRoot == 0 || nRoot == 1) {
 
-      if ( abs( vtV.x) > EPS_ZERO) {
+      if ( abs( vtV.z) > EPS_ZERO) {
       
-         ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;
-         ptInt2 = ptP + ( ( dLongMvLen - ptP.x) / vtV.x) * vtV ;
+         ptInt1 = ptP - ( ptP.z / vtV.z) * vtV ;
+         ptInt2 = ptP + ( ( dLongMvLen - ptP.z) / vtV.z) * vtV ;
 
-         if ( ptInt1.y * ptInt1.y + ptInt1.z * ptInt1.z < dSqRad &&
-            ( ptInt2.y - dOrtMvLen) * ( ptInt2.y - dOrtMvLen) + ptInt2.z * ptInt2.z < dSqRad) {
+         if ( ptInt1.x * ptInt1.x + ptInt1.y * ptInt1.y < dSqRad &&
+            ( ptInt2.x - dOrtMvLen) * ( ptInt2.x - dOrtMvLen) + ptInt2.y * ptInt2.y < dSqRad) {
 
             ptInt1.ToGlob( CircFrame) ;
             ptInt2.ToGlob( CircFrame) ;
 
-            vtN1 = X_AX ;
-            vtN2 = - X_AX ;
+            vtN1 = Z_AX ;
+            vtN2 = - Z_AX ;
 
             vtN1.ToGlob( CircFrame) ;
             vtN2.ToGlob( CircFrame) ;
@@ -1203,7 +1193,7 @@ VolZmap::IntersLineEllipticalCylinder( const Vector3d& vtLineDir, const Point3d&
   // coincidenti) oppure nessuna o infinite se la la retta
   // appartiene alla superficie
 
-   Vector3d vtMv( dLongMvLen, dOrtMvLen, 0) ;
+   Vector3d vtMv( dOrtMvLen, 0, dLongMvLen) ;
 
    if ( nRoot == 2) {
 
@@ -1211,76 +1201,76 @@ VolZmap::IntersLineEllipticalCylinder( const Vector3d& vtLineDir, const Point3d&
       ptInt2 = ptP + vdRoots[1] * vtV ;
 
    
-      if ( ptInt1.x > ptInt2.x) 
+      if ( ptInt1.z > ptInt2.z) 
          
          swap( ptInt1, ptInt2) ;
 
       Vector3d vtTest1 = ( ptInt1 - ORIG) - ( ptInt1 - ORIG) * vtAx * vtAx ;
       Vector3d vtTest2 = ( ptInt2 - ORIG) - ( ptInt2 - ORIG) * vtAx * vtAx ;
 
-      double dY0_1, dY0_2 ;
+      double dX0_1, dX0_2 ;
       
-      if ( vtTest1.y > 0) {
+      if ( vtTest1.x > 0) {
 
-         dY0_1 = ( dSqRad - ptInt1.z * ptInt1.z > 0 ? sqrt( dSqRad - ptInt1.z * ptInt1.z) : 0) ;  
+         dX0_1 = ( dSqRad - ptInt1.y * ptInt1.y > 0 ? sqrt( dSqRad - ptInt1.y * ptInt1.y) : 0) ;  
       }
       else {
       
-         dY0_1 = ( dSqRad - ptInt1.z * ptInt1.z > 0 ? - sqrt( dSqRad - ptInt1.z * ptInt1.z) : 0) ;  
+         dX0_1 = ( dSqRad - ptInt1.y * ptInt1.y > 0 ? - sqrt( dSqRad - ptInt1.y * ptInt1.y) : 0) ;  
       }
 
-      Vector3d vtCirc1( 0, - dY0_1, - ptInt1.z) ;
-      Vector3d vtTan1( 0, - vtCirc1.z, vtCirc1.y) ;
+      Vector3d vtCirc1( - dX0_1, - ptInt1.y, 0) ;
+      Vector3d vtTan1( vtCirc1.y, - vtCirc1.x, 0) ;
       Vector3d vtCross1 = vtTan1 ^ vtMv ;
 
       vtN1 = ( vtCross1 * vtCirc1 > - EPS_ZERO ? vtCross1 : - vtCross1) ;
 
-      if ( vtTest2.y > 0) {
+      if ( vtTest2.x > 0) {
 
-         dY0_2 = ( dSqRad - ptInt2.z * ptInt2.z > 0 ? sqrt( dSqRad - ptInt2.z * ptInt2.z) : 0) ;  
+         dX0_2 = ( dSqRad - ptInt2.y * ptInt2.y > 0 ? sqrt( dSqRad - ptInt2.y * ptInt2.y) : 0) ;  
       }
       else {
       
-         dY0_2 = ( dSqRad - ptInt2.z * ptInt2.z > 0 ? - sqrt( dSqRad - ptInt2.z * ptInt2.z) : 0) ;  
+         dX0_2 = ( dSqRad - ptInt2.y * ptInt2.y > 0 ? - sqrt( dSqRad - ptInt2.y * ptInt2.y) : 0) ;  
       }
 
-      Vector3d vtCirc2( 0, - dY0_2, - ptInt2.z) ;
-      Vector3d vtTan2( 0, - vtCirc2.z, vtCirc2.y) ;
+      Vector3d vtCirc2( - dX0_2, - ptInt2.y, 0) ;
+      Vector3d vtTan2( vtCirc2.y, - vtCirc2.x, 0) ;
       Vector3d vtCross2 = vtTan2 ^ vtMv ;
 
       vtN2 = ( vtCross2 * vtCirc2 > - EPS_ZERO ? vtCross2 : - vtCross2) ;
 
 
 
-      if ( ptInt1.x < dLongMvLen + dEpsUp) {
+      if ( ptInt1.z < dLongMvLen + dEpsUp) {
       
-         if (  ptInt1.x > + dEpsLow) {
+         if (  ptInt1.z > + dEpsLow) {
 
-            if ( ptInt2.x > dLongMvLen + dEpsUp) {
+            if ( ptInt2.z > dLongMvLen + dEpsUp) {
 
-               ptInt2 = ptP + ( ( dLongMvLen - ptP.x) / vtV.x) * vtV ;  
-               vtN2 = - X_AX ;
+               ptInt2 = ptP + ( ( dLongMvLen - ptP.z) / vtV.z) * vtV ;  
+               vtN2 = - Z_AX ;
             }
          }
          else {
 
-            if ( ptInt2.x > dLongMvLen + dEpsUp) {
+            if ( ptInt2.z > dLongMvLen + dEpsUp) {
             
-               ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;
-               ptInt2 = ptP + ( ( dLongMvLen - ptP.x) / vtV.x) * vtV ;
+               ptInt1 = ptP - ( ptP.z / vtV.z) * vtV ;
+               ptInt2 = ptP + ( ( dLongMvLen - ptP.z) / vtV.z) * vtV ;
 
-               vtN1.Set( 1, 0, 0) ;
-               vtN2.Set( -1, 0, 0) ;
+               vtN1.Set( 0, 0, 1)  ;
+               vtN2.Set( 0, 0, -1) ;
 
-               if ( ptInt1.y * ptInt1.y + ptInt1.z * ptInt1.z > dSqRad &&
-                    ptInt2.y * ptInt2.y + ptInt2.z * ptInt2.z > dSqRad)
+               if ( ptInt1.x * ptInt1.x + ptInt1.y * ptInt1.y > dSqRad &&
+                    ptInt2.x * ptInt2.x + ptInt2.y * ptInt2.y > dSqRad)
 
                     return false ;
             }
-            else if ( ptInt2.x > dEpsLow) { 
+            else if ( ptInt2.z > dEpsLow) { 
             
-               ptInt1 = ptP - ( ptP.x / vtV.x) * vtV ;
-               vtN1.Set( 1, 0, 0) ;
+               ptInt1 = ptP - ( ptP.z / vtV.z) * vtV ;
+               vtN1.Set( 0, 0, 1) ;
             }
             else 
                return false ;
@@ -1307,7 +1297,7 @@ VolZmap::IntersLineEllipticalCylinder( const Vector3d& vtLineDir, const Point3d&
 //----------------------------------------------------------------------------
 bool 
 VolZmap::IntersLineMyPolyhedron( const Point3d& ptLineSt, const Vector3d& vtLineDir,
-                                 const Frame3d& PolyFrame, double dLenX, double dLenY, double dLenZ, double dDeltaX,
+                                 const Frame3d& PolyFrame, double dLenX, double dLenY, double dLenZ, double dDeltaZ,
                                  Point3d& ptInt1, Point3d& ptInt2, Vector3d& vtN1, Vector3d& vtN2) 
 {
    Point3d ptP = ptLineSt ;
@@ -1320,107 +1310,107 @@ VolZmap::IntersLineMyPolyhedron( const Point3d& ptLineSt, const Vector3d& vtLine
   // 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) ;
+   Point3d ptFacet135( 0, dLenY / 2, 0) ;
+   Point3d ptFacet246( dLenX , - dLenY / 2, dLenZ + dDeltaZ) ;
 
   // Servono per descrivere i piani obliqui
    Vector3d vtFacet5 = ptFacet135 - ptP ;
    Vector3d vtFacet6 = ptFacet246 - ptP ;
 
-   Vector3d vtOb( dLenY, - dDeltaX, 0) ;
+   Vector3d vtOb( - dDeltaZ, 0, dLenX) ;
 
    vtOb.Normalize() ;
 
-   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 ptI1 = ptP + ( ( ptFacet135.y - ptP.y) / vtV.y) * vtV ;
+   Point3d ptI2 = ptP + ( ( ptFacet246.y - ptP.y) / vtV.y) * vtV ;
+   Point3d ptI3 = ptP + ( ( ptFacet135.x - ptP.x) / vtV.x) * vtV ;
+   Point3d ptI4 = ptP + ( ( ptFacet246.x - ptP.x) / vtV.x) * vtV ;
    Point3d ptI5 = ptP + ( ( vtFacet5 * vtOb) / ( vtV * vtOb)) * vtV ;
    Point3d ptI6 = ptP + ( ( vtFacet6 * vtOb) / ( vtV * vtOb)) * vtV ;
 
   // Controlli affinché non vengano tagliati dexel a filo
   // con il passaggio dell'utensile:
   // Controllo sulle facce 1 e 2
-   if ( abs( vtV.z) < EPS_ZERO  && 
-        abs( ptP.z) > dLenZ / 2 - EPS_SMALL)   
+   if ( abs( vtV.y) < EPS_ZERO  && 
+        abs( ptP.y) > dLenY / 2 - EPS_SMALL)   
         return false ;
   // Controllo sulle facce 3 e 4
-   if ( abs( vtV.y) < EPS_ZERO  && 
-       ( ptP.y < EPS_SMALL  || 
-        ptP.y > dLenY - EPS_SMALL))
+   if ( abs( vtV.x) < EPS_ZERO  && 
+       ( ptP.x < EPS_SMALL  || 
+        ptP.x > dLenX - EPS_SMALL))
         return false ;
   // Controllo sulle facce 5 e 6 
-   Vector3d vtW( dDeltaX, dLenY, 0) ;
+   Vector3d vtW( 0, dLenX, dDeltaZ) ;
    vtW.Normalize() ;
-   Vector3d vtU = vtV - vtV.z * Z_AX - vtV * vtW * vtW ;
+   Vector3d vtU = vtV - vtV.y * Y_AX - vtV * vtW * vtW ;
    if ( vtU.Len() < EPS_ZERO  && 
-       ( ptP.x * dLenY < dDeltaX * ptP.y + dLenY * EPS_SMALL  ||
-         ptP.x * dLenY > dDeltaX * ptP.y + dLenY * ( dLenX - EPS_SMALL))) 
+       ( ptP.z * dLenX < dDeltaZ * ptP.x + dLenX * EPS_SMALL  ||
+         ptP.z * dLenX > dDeltaZ * ptP.x + dLenX * ( dLenY - EPS_SMALL))) 
         return false ;
 
   // Ricerca intersezioni con le facce 
    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) {
+   if ( ptI1.x >= 0 && ptI1.x <= dLenX && 
+        ptI1.z * dLenX >= dDeltaZ * ptI1.x && ( ptI1.z - dLenZ) * dLenX <= dDeltaZ * ptI1.x) {
 
       ptInt1 = ptI1 ;
-      vtN1 = - Z_AX ;
+      vtN1 = - Y_AX ;
       ++ 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 ( ptI2.x >= 0 && ptI2.x <= dLenX && 
+        ptI2.z * dLenX >= dDeltaZ * ptI2.x && ( ptI2.z - dLenZ) * dLenX <= dDeltaZ * ptI2.x) {
       if ( nIntNum == 0) {
          ptInt1 = ptI2 ;
-         vtN1 = Z_AX ;
+         vtN1 = Y_AX ;
          ++ nIntNum ;
       }
       else if ( ( ptInt1 - ptI2).SqLen() > SQ_EPS_SMALL) {
          ptInt2 = ptI2 ;
-         vtN2 = Z_AX ;
+         vtN2 = Y_AX ;
          ++ nIntNum ;
       }
    }
 
   // Intersezione con la terza faccia
    if ( nIntNum < 2 &&
-        ptI3.x >= 0 && ptI3.x <= dLenX && 
-        ptI3.z >= - ptFacet135.z && ptI3.z <= ptFacet135.z) {
+        ptI3.z >= 0 && ptI3.z <= dLenZ && 
+        ptI3.y >= - ptFacet135.y && ptI3.y <= ptFacet135.y) {
       if ( nIntNum == 0) {
          ptInt1 = ptI3 ;
-         vtN1 = Y_AX ;
+         vtN1 = X_AX ;
          ++ nIntNum ;
       }
       else if ( ( ptInt1 - ptI3).SqLen() > SQ_EPS_SMALL) {
          ptInt2 = ptI3 ;
-         vtN2 = Y_AX ;
+         vtN2 = X_AX ;
          ++ nIntNum ;
       }
    }
 
   // Intersezione con la quarta faccia
    if ( nIntNum < 2 &&
-        ptI4.x >= dDeltaX && ptI4.x <= dLenX + dDeltaX && 
-        ptI4.z >= - ptFacet135.z && ptI4.z <= ptFacet135.z) {
+        ptI4.z >= dDeltaZ && ptI4.z <= dLenZ + dDeltaZ && 
+        ptI4.y >= - ptFacet135.y && ptI4.y <= ptFacet135.y) {
       if ( nIntNum == 0) {
          ptInt1 = ptI4 ;
-         vtN1 = - Y_AX ;
+         vtN1 = - X_AX ;
          ++ nIntNum ;
       }
       else if ( ( ptInt1 - ptI4).SqLen() > SQ_EPS_SMALL) {
          ptInt2 = ptI4 ;
-         vtN2 = - Y_AX ;
+         vtN2 = - X_AX ;
          ++ nIntNum ;
       }
    }
 
   // Intersezione con la quinta faccia
    if ( nIntNum < 2 &&
-        ptI5.y >= 0 && ptI5.y <= dLenY && 
-        ptI5.z >= - ptFacet135.z && ptI5.z <= ptFacet135.z) {
+        ptI5.x >= 0 && ptI5.x <= dLenX && 
+        ptI5.y >= - ptFacet135.y && ptI5.y <= ptFacet135.y) {
       if ( nIntNum == 0) {
          ptInt1 = ptI5 ;
          vtN1 = vtOb ;
@@ -1435,8 +1425,8 @@ VolZmap::IntersLineMyPolyhedron( const Point3d& ptLineSt, const Vector3d& vtLine
 
   // Intersezione con la sesta faccia
    if ( nIntNum < 2 &&
-        ptI6.y >= 0 && ptI6.y <= dLenY && 
-        ptI6.z >= - ptFacet135.z && ptI6.z <= ptFacet135.z) {
+        ptI6.x >= 0 && ptI6.x <= dLenX && 
+        ptI6.y >= - ptFacet135.y && ptI6.y <= ptFacet135.y) {
       if ( nIntNum == 0) {
          ptInt1 = ptI6;
          vtN1 = - vtOb ;
diff --git a/VolZmapGraphics.cpp b/VolZmapGraphics.cpp
index 1048726..f28743b 100644
--- a/VolZmapGraphics.cpp
+++ b/VolZmapGraphics.cpp
@@ -64,7 +64,7 @@ TestOnNormal( const VectorField CompoVert[], int nCompoElem)
    } 
   
   // Se la massima deviazione non supera il limite non è feature
-   const double SHARP_COS = 0.9 ;
+   const double SHARP_COS = 0.866 ;
    if ( dMinCosTheta >= SHARP_COS)
       return NO_FEATURE ;
 
diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp
index 3bee515..0f85b95 100644
--- a/VolZmapVolume.cpp
+++ b/VolZmapVolume.cpp
@@ -566,7 +566,7 @@ VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Point3d&
 bool
 VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs, const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) 
 {
-  // Controllo sull'effettiva esisenza del movimento
+  // Controllo sull'effettiva esistenza del movimento
    if ( AreSamePointApprox( ptPs, ptPe)  &&  AreSameVectorApprox( vtDs, vtDe)) 
       return true ;
 
@@ -587,15 +587,7 @@ VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d&
       ptLe[1].x = ptLe[0].y ;  ptLe[1].y = ptLe[0].z ;  ptLe[1].z = ptLe[0].x ;
       ptLe[2].x = ptLe[0].z ;  ptLe[2].y = ptLe[0].x ;  ptLe[2].z = ptLe[0].y ;    
    }
-
-   else {
-      ptLs[1].x = 0 ;  ptLs[1].y = 0 ;  ptLs[1].z = 0 ;
-      ptLs[2].x = 0 ;  ptLs[2].y = 0 ;  ptLs[2].z = 0 ;
-
-      ptLe[1].x = 0 ;  ptLe[1].y = 0 ;  ptLe[1].z = 0 ;
-      ptLe[2].x = 0 ;  ptLe[2].y = 0 ;  ptLe[2].z = 0 ;      
-   }
-  
+ 
   // Vettori nei sistemi di riferimento intrinseci dello Zmap 
    Vector3d vtLs[3] ;
    Vector3d vtLe[3] ;
@@ -2385,6 +2377,9 @@ VolZmap::Conus_XYDrilling( unsigned int nGrid, const Point3d& ptS, const Point3d
             Vector3d vtUmin = ( ptIntMin - ptV) - ( ptIntMin - ptV) * vtV * vtV ;
             Vector3d vtUmax = ( ptIntMax - ptV) - ( ptIntMax - ptV) * vtV * vtV ;
 
+            vtUmin.Normalize() ; 
+            vtUmax.Normalize() ; 
+
             Vector3d vtNmin = dDeltaRad * vtV - m_Tool.GetTipHeigth() * vtUmin ;
             Vector3d vtNmax = dDeltaRad * vtV - m_Tool.GetTipHeigth() * vtUmax ;
 
@@ -2772,49 +2767,41 @@ VolZmap::Conus_XYMilling( unsigned int nGrid, const Point3d & ptS, const Point3d
 // ---------- Cilindro e sfera -----------------------------------------------
 //----------------------------------------------------------------------------
 bool
-VolZmap::CylBall_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
+VolZmap::CylBall_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir)
 {
-   double dStemHeigth = m_Tool.GetHeigth() ;
-  // Sfera
-   if ( m_Tool.GetType() == Tool::BALLMILL)
-      dStemHeigth -= m_Tool.GetRadius() ;
-
+  // Altezza cilindro
+   double dStemHeigth = m_Tool.GetHeigth() - m_Tool.GetTipHeigth() ; 
+  // Sottraggo cilindro
    CompCyl_Drilling( nGrid, ptS, ptE, vtToolDir, dStemHeigth, m_Tool.GetRadius(), false, false) ;
-
-  // Sfera
+  // Se è sfera la sottraggo 
    if ( m_Tool.GetType() == Tool::BALLMILL) {
       Point3d ptSBall = ptS - dStemHeigth * vtToolDir ;
       Point3d ptEBall = ptE - dStemHeigth * vtToolDir ;
       CompBall_Milling( nGrid, ptSBall, ptEBall, m_Tool.GetRadius()) ;  
    }
-
    return true ;
 }
 //----------------------------------------------------------------------------
 bool
-VolZmap::CylBall_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
+VolZmap::CylBall_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir)
 {
-   double dStemHeigth = m_Tool.GetHeigth() ;
-  // Sfera
-   if ( m_Tool.GetType() == Tool::BALLMILL)
-      dStemHeigth -= m_Tool.GetRadius() ;
- 
+  // Altezza cilindro
+   double dStemHeigth = m_Tool.GetHeigth() - m_Tool.GetTipHeigth() ; 
+  // Sottraggo cilindro
    CompCyl_Milling( nGrid, ptS, ptE, vtToolDir, dStemHeigth, m_Tool.GetRadius(), false, false) ;
-
-  // Sfera
+  // Se è sfera la sottraggo
    if ( m_Tool.GetType() == Tool::BALLMILL) {
       Point3d ptSBall = ptS - dStemHeigth * vtToolDir ;
       Point3d ptEBall = ptE - dStemHeigth * vtToolDir ;
       CompBall_Milling( nGrid, ptSBall, ptEBall, m_Tool.GetRadius()) ;  
    }
-
    return true ;
 }
 
 // ---------- Coni -----------------------------------------------------------
 //----------------------------------------------------------------------------
 bool
-VolZmap::Conus_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
+VolZmap::Conus_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir)
 {
    double dStemHeigth = m_Tool.GetHeigth() - m_Tool.GetTipHeigth() ;
  
@@ -2838,7 +2825,7 @@ VolZmap::Conus_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d
 
 //----------------------------------------------------------------------------
 bool
-VolZmap::Conus_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir)
+VolZmap::Conus_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir)
 {
    double dStemHeigth = m_Tool.GetHeigth() - m_Tool.GetTipHeigth() ;
  
@@ -2848,13 +2835,15 @@ VolZmap::Conus_Milling( unsigned int nGrid, const Point3d & ptS, const Point3d &
    if ( m_Tool.GetTipRadius() < m_Tool.GetRadius()) {
       Point3d ptSBall = ptS - dStemHeigth * vtToolDir ;
       Point3d ptEBall = ptE - dStemHeigth * vtToolDir ;
-      CompConus_Milling( nGrid, ptSBall, ptEBall, vtToolDir, m_Tool.GetTipHeigth(), m_Tool.GetRadius(), m_Tool.GetTipRadius(), true, false) ;  
+      CompConus_Milling( nGrid, ptSBall, ptEBall, vtToolDir, m_Tool.GetTipHeigth(),
+                         m_Tool.GetRadius(), m_Tool.GetTipRadius(), true, false) ;  
    }
 
    else {
       Point3d ptSBall = ptS - m_Tool.GetHeigth() * vtToolDir ;
       Point3d ptEBall = ptE - m_Tool.GetHeigth() * vtToolDir ;
-      CompConus_Milling( nGrid, ptSBall, ptEBall, - vtToolDir, m_Tool.GetTipHeigth(), m_Tool.GetTipRadius(), m_Tool.GetRadius(), false, true) ;
+      CompConus_Milling( nGrid, ptSBall, ptEBall, - vtToolDir, m_Tool.GetTipHeigth(),
+                         m_Tool.GetTipRadius(), m_Tool.GetRadius(), false, true) ;
    }
 
    return true ;
@@ -3227,7 +3216,7 @@ VolZmap::CompCyl_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Point
 
   // Quote estreme del gambo
    double dMinStemZ = min( min( ptS.z, ptTStemS.z), min( ptE.z, ptTStemE.z)) ;
-   double dMaxStemZ = max( max( ptS.z, ptTStemS.z), max( ptS.z, ptTStemS.z)) ;
+   double dMaxStemZ = max( max( ptS.z, ptTStemS.z), max( ptE.z, ptTStemE.z)) ;
 
   // Ciclo sui punti
    for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
@@ -3287,7 +3276,7 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Poi
    Vector3d vtMin, vtMax ;
 
   // Ciclo sui punti
-   for ( unsigned int i = nStartI ; i <= nEndI ; ++ i)
+   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 ;
@@ -3296,8 +3285,9 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Poi
 
          double dSqDist = vtC * vtC ;
 
-         if ( dSqDist < dSqMinRad) 
-            SubtractIntervals( nGrid, i, j, dZMin, dZMax, Z_AX, -Z_AX) ;
+         if ( dSqDist < dSqMinRad)  {
+            SubtractIntervals( nGrid, i, j, dZMin, dZMax, Z_AX, -Z_AX) ;          
+         }
 
          else if ( dSqDist < dSafeSqMaxRad) {             // dSafeSqMaxRad è sperimentale 
 
@@ -3319,7 +3309,7 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Poi
 
                vtMin.Normalize() ;
 
-               SubtractIntervals( nGrid, i, j, dMin, dMax, vtMin, vtMax) ;
+               SubtractIntervals( nGrid, i, j, dMin, dMax, vtMin, vtMax) ;              
             }
 
             else {
@@ -3338,11 +3328,12 @@ VolZmap::CompConus_ZDrilling( unsigned int nGrid, const Point3d & ptS, const Poi
 
                vtMax.Normalize() ;
 
-               SubtractIntervals( nGrid, i, j, dMin, dMax, vtMin, vtMax) ;
+               SubtractIntervals( nGrid, i, j, dMin, dMax, vtMin, vtMax) ;             
             }
          }        
       }
-
+   }
+     
    return true ;
 }
 
@@ -3904,6 +3895,7 @@ bool
 VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir,
                            double dHei, double dRad, bool bTapB, bool bTapT) 
 {
+  // Verifico che il cilindro con il suo movimento intersechi la griglia
    unsigned int nStartI, nEndI, nStartJ, nEndJ ;
    bool bInterf = BBoxComponent( nGrid, ptS, ptE, vtToolDir, nStartI, nStartJ, nEndI, nEndJ,
                                  dRad, dRad, dHei) ; 
@@ -3914,40 +3906,20 @@ VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d
    Point3d ptI = ( ( ptE - ptS) * vtToolDir > 0 ? ptE : ptS) ;
    Point3d ptF = ( ( ptE - ptS) * vtToolDir > 0 ? ptS - vtToolDir * dHei : ptE - vtToolDir * dHei) ;
 
-  // Sistema di riferimento cilindro
-   Vector3d vtV1 = - vtToolDir ;
+  // Altezza cilindro totale altezza + moto
+   double dH = ( ptF - ptI).Len() ;
 
-   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) ;
+  // Sistema di riferimento del cilindro
+   Frame3d CylFrame ; CylFrame.Set( ptF, vtToolDir) ;
 
-   Vector3d vtV2 = ptP - ptI + ( ( ( ptI - ptP) * vtV1) / ( vtV * vtV1)) * vtV ;
-
-   vtV2.Normalize() ;
-
-   Vector3d vtV3 = vtV1 ^ vtV2 ;
-
-   Frame3d CylFrame ;  CylFrame.Set( ptI, vtV1, vtV2, vtV3) ;
-
-   double dMin, dMax;
-   Vector3d vtNmin, vtNmax ;
-
-  // Lunghezzza cilindro totale altezza + moto
-   double dLen = ( ptF - ptI).Len() ;
-
-   for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
-   
+   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 ptC( ( i + 0.5) * m_dStep, ( j + 0.5) * m_dStep, 0) ;
          Point3d ptInt1, ptInt2 ;
          Vector3d vtN1, vtN2 ;
-      
-         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dLen, dRad, bTapB, bTapT, ptInt1, ptInt2,vtN1, vtN2)) {
-
+         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dH, dRad, bTapB, bTapT, ptInt1, ptInt2, vtN1, vtN2)) {
+            double dMin, dMax ;
+            Vector3d vtNmin, vtNmax ;
             if ( ptInt1.z < ptInt2.z) {
                dMin = ptInt1.z ;
                dMax = ptInt2.z ;
@@ -3960,7 +3932,6 @@ VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d
                vtNmin = vtN2 ;
                vtNmax = vtN1 ;
             }
-
             SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
          }
       }
@@ -3970,7 +3941,7 @@ VolZmap::CompCyl_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d
 
 //----------------------------------------------------------------------------
 bool 
-VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Point3d & ptE, const Vector3d & vtToolDir, 
+VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtToolDir, 
                              double dHei, double dMaxRad, double dMinRad, bool bTapB, bool bTapT)
 {
    unsigned int nStartI, nStartJ, nEndI, nEndJ ;
@@ -3982,39 +3953,23 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Poin
   // Apertura del cono
    double dDeltaR = dMaxRad - dMinRad ;
    double dTan = dDeltaR / dHei ;
-   double dL = ( ( dMaxRad * dHei) / dDeltaR) ;
-   double dl = dL - dHei ;
+   double dConeMaxH = ( ( dMaxRad * dHei) / dDeltaR) ;
+   double dConeMinH = dConeMaxH - dHei ;
 
    bool bTapCylEn = bTapB ;
 
-   Point3d ptVertex = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) - vtToolDir * dL ;
+   Point3d ptVertex = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) - vtToolDir * dConeMaxH ;
 
-  // Sistema di riferimento del cono
-   Vector3d vtV1 = vtToolDir ;
+  // Sistemi di riferimento del cono e del cilindro
+   Frame3d ConusFrame ; ConusFrame.Set( ptVertex, vtToolDir) ;
+   Frame3d CylFrame = ConusFrame ; CylFrame.Translate( vtToolDir * dConeMaxH) ;
 
-   Point3d ptP = ( abs( vtV1.z) < EPS_SMALL ? Point3d( ptVertex.x, ptVertex.y, ptVertex.z + 1) : 
-                                              Point3d( ptVertex.x + 1, ptVertex.y, ptVertex.z)) ;
+  // L'altezza del cilindro è il movimento
+   double dH = ( ptE - ptS).Len() ;
 
-   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() ;
-
-   double dMin, dMax ;
-   Vector3d vtNmin, vtNmax ;
-
-   for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
-   
+   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 ;
 
@@ -4024,40 +3979,42 @@ VolZmap::CompConus_Drilling( unsigned int nGrid, const Point3d & ptS, const Poin
          Vector3d vtN1, vtN2 ;
 
         // Cilindro
-         if ( IntersLineCylinder( ptC - vtV1 * dL, Z_AX, ConusFrame, dLen, dMaxRad, true, bTapCylEn,
+         if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dH, dMaxRad, true, bTapCylEn,
                                   ptInt1, ptInt2, vtN1, vtN2)) {
+            double dMin, dMax ;
+            Vector3d vtNmin, vtNmax ;
             if ( ptInt1.z < ptInt2.z) {
-               dMin = ptInt1.z + vtV1.z * dL ;
-               dMax = ptInt2.z + vtV1.z * dL ;
+               dMin = ptInt1.z ;
+               dMax = ptInt2.z ;
                vtNmin = vtN1 ;
                vtNmax = vtN2 ;          
             }
             else {
-               dMin = ptInt2.z + vtV1.z * dL ;
-               dMax = ptInt1.z + vtV1.z * dL ;
+               dMin = ptInt2.z ;
+               dMax = ptInt1.z ;
                vtNmin = vtN2 ;
                vtNmax = vtN1 ;        
             }
-
             SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
          }
 
         // Cono
-         if ( IntersLineConus( ptC , Z_AX, ConusFrame, dTan, dl, dL, bTapT, true,
+         if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dConeMinH, dConeMaxH, bTapT, true,
                                ptInt1, ptInt2, vtN1, vtN2)) {
+            double dMin, dMax ;
+            Vector3d vtNmin, vtNmax ;
             if ( ptInt1.z < ptInt2.z) {
-               dMin = ptInt1.z /*+ vtV1.z * dL*/ ;
-               dMax = ptInt2.z /*+ vtV1.z * dL*/ ;
+               dMin = ptInt1.z ;
+               dMax = ptInt2.z ;
                vtNmin = vtN1 ;
                vtNmax = vtN2 ;          
             }
             else {
-               dMin = ptInt2.z /*+ vtV1.z * dL*/ ;
-               dMax = ptInt1.z /*+ vtV1.z * dL*/ ;
+               dMin = ptInt2.z ;
+               dMax = ptInt1.z ;
                vtNmin = vtN2 ;
                vtNmax = vtN1 ;        
             }
-
             SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
          }
       }
@@ -4078,14 +4035,14 @@ VolZmap::CompPar_Drilling( unsigned int nGrid, double dLenX, double dLenY, doubl
       return true ;
 
   // Costruzione di un sistema di riferimento per il volume 
-  // asportato dal solido nelle psoizioni iniziale e finale.    
+  // asportato dal solido nelle posizioni iniziale e finale.    
    Vector3d vtV1 = vtToolDir ;
    Vector3d vtV2 = vtAux ^ vtV1 ;
    Vector3d vtV3 = vtAux ;
 
    double dLenMove = ( ptE - ptS).Len() ;
    Point3d ptO = ptS - ( ( ptE - ptS) * vtV1 > 0 ? dLenZ : dLenZ + dLenMove) * vtV1 - ( 0.5 * dLenX) * vtV2 ;
-   Frame3d ParaFrame ; ParaFrame.Set( ptO, vtV1, vtV2, vtV3) ;
+   Frame3d ParaFrame ; ParaFrame.Set( ptO, vtV2, vtV3, vtV1) ;
 
    for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
       for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
@@ -4098,7 +4055,7 @@ VolZmap::CompPar_Drilling( unsigned int nGrid, double dLenX, double dLenY, doubl
          Point3d ptInt1, ptInt2 ;
          Vector3d vtN1, vtN2 ;
 
-         if ( IntersLineMyPolyhedron(  ptC, Z_AX, ParaFrame, dLenZ + dLenMove, dLenX, dLenY, 0, ptInt1, ptInt2, vtN1, vtN2)) {
+         if ( IntersLineMyPolyhedron(  ptC, Z_AX, ParaFrame, dLenX, dLenY, dLenZ + dLenMove, 0, ptInt1, ptInt2, vtN1, vtN2)) {
         
             double dMin, dMax ;
             Vector3d vtNmin, vtNmax ;
@@ -4141,7 +4098,6 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
   // Studio delle simmetrie
    Point3d ptI = ( vtToolDir * ( ptE - ptS) > 0 ? ptS : ptE) ;
    Point3d ptF = ( vtToolDir * ( ptE - ptS) > 0 ? ptE : ptS) ;
-
    Point3d ptITip = ptI - vtToolDir * dHei ;
    Point3d ptFTip = ptF - vtToolDir * dHei ;
 
@@ -4153,8 +4109,10 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
    Vector3d vtV1 = vtToolDir ;
    Vector3d vtV2 = vtMoveOrt ;  vtV2.Normalize() ;
    Vector3d vtV3 = vtV1 ^ vtV2 ;
+   Frame3d CylFrame ;  CylFrame.Set( ptITip, vtV2, vtV3, vtV1) ;
 
-   Frame3d CylFrame ;  CylFrame.Set( ptITip, vtV1, vtV2, vtV3) ;
+  // Verifica se movimento lungo Z
+   bool bMoveOnZ = ( vtMove.IsZplus() ||  vtMove.IsZminus()) ;
 
   // Parametri geometrici di moto e cilindro
    double dSqRad = dRad * dRad ;
@@ -4167,10 +4125,6 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
    bool bCylEn = ( abs( vtToolDir * vtUmv) > EPS_SMALL ? true : bTapB) ;
    bool bElpsB = ( abs( vtToolDir * vtUmv) > EPS_SMALL ? true : bTapB) ;
    bool bElpsT = ( abs( vtToolDir * vtUmv) > EPS_SMALL ? true : bTapT) ;
-  
-  // Minima e massima quota z 
-   double dMin, dMax ;
-   Vector3d vtNmin, vtNmax ;
 
    for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
       for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
@@ -4182,6 +4136,8 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
 
         // Cilindro iniziale
          if ( IntersLineCylinder( ptC, Z_AX, CylFrame, dHei, dRad, bCylSt, bCylEn, ptInt1, ptInt2, vtN1, vtN2)) {
+            double dMin, dMax ;
+            Vector3d vtNmin, vtNmax ;
             if ( ptInt1.z < ptInt2.z) {
                dMin = ptInt1.z ;
                dMax = ptInt2.z ;
@@ -4194,7 +4150,6 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
                vtNmin = vtN2 ;
                vtNmax = vtN1 ;   
             }
-          
             SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;      
          }
                
@@ -4202,6 +4157,8 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
         // del sistema di riferimento, quindi usiamo lo stesso sistema sommando a ptC
         // il vettore che congiunge le due origini.
          if ( IntersLineCylinder( ptC - vtMove, Z_AX, CylFrame, dHei, dRad, bCylSt, bCylEn, ptInt1, ptInt2, vtN1, vtN2)) {
+            double dMin, dMax ;
+            Vector3d vtNmin, vtNmax ;
             if ( ptInt1.z < ptInt2.z) {
                dMin = ptInt1.z + vtMove.z ;
                dMax = ptInt2.z + vtMove.z ;
@@ -4214,12 +4171,13 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
                vtNmin = vtN2 ;
                vtNmax = vtN1 ;   
             }
-
             SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;  
          }    
                  
         // Poliedro interno
-         if ( IntersLineMyPolyhedron(  ptC, Z_AX, CylFrame, dHei, dOrtLen, 2 * dRad, dLongLen, ptInt1, ptInt2, vtN1, vtN2)) {
+         if ( ! bMoveOnZ  &&  IntersLineMyPolyhedron(  ptC, Z_AX, CylFrame, dOrtLen, 2 * dRad, dHei, dLongLen, ptInt1, ptInt2, vtN1, vtN2)) {
+            double dMin, dMax ;
+            Vector3d vtNmin, vtNmax ;
             if ( ptInt1.z < ptInt2.z) {
                dMin = ptInt1.z ;
                dMax = ptInt2.z ;
@@ -4232,13 +4190,14 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
                vtNmin = vtN2 ;
                vtNmax = vtN1 ;   
             }
-
             SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;           
          }
         
         // Cilindro ellittico di punta
-         if ( IntersLineEllipticalCylinder( Z_AX, ptC, CylFrame, dSqRad, 
-                                            dLongLen, dOrtLen, bElpsT, bElpsT, ptInt1, ptInt2, vtN1, vtN2)) {
+         if ( ! bMoveOnZ  &&  IntersLineEllipticalCylinder( Z_AX, ptC, CylFrame, dSqRad, 
+                                             dLongLen, dOrtLen, bElpsT, bElpsT, ptInt1, ptInt2, vtN1, vtN2)) {
+            double dMin, dMax ;
+            Vector3d vtNmin, vtNmax ;
             if ( ptInt1.z < ptInt2.z) {
                dMin = ptInt1.z ;
                dMax = ptInt2.z ;
@@ -4251,15 +4210,16 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
                vtNmin = vtN2 ;
                vtNmax = vtN1 ;   
             }
-
             SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
          }
 
         // 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,
+         if ( ! bMoveOnZ  &&  IntersLineEllipticalCylinder( Z_AX, ptC - dHei * vtV1, CylFrame, dSqRad,
                                             dLongLen, dOrtLen, bElpsB, bElpsB, ptInt1, ptInt2, vtN1, vtN2)) {
+            double dMin, dMax ;
+            Vector3d vtNmin, vtNmax ;
             if ( ptInt1.z < ptInt2.z) {
                dMin = ptInt1.z + dHei * vtV1.z ;
                dMax = ptInt2.z + dHei * vtV1.z ;
@@ -4272,7 +4232,6 @@ VolZmap::CompCyl_Milling( unsigned int nGrid, const Point3d& ptS, const Point3d&
                vtNmin = vtN2 ;
                vtNmax = vtN1 ;   
             }
-
             SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;  
          }  
       }
@@ -4313,13 +4272,16 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
    Vector3d vtMvLong = ( vtMove * vtToolDir) * vtToolDir ; 
    Vector3d vtMvOrt = vtMove - vtMvLong ;
 
+  // Verifica se movimento lungo Z
+   bool bMoveOnZ = ( vtMove.IsZplus() ||  vtMove.IsZminus()) ;
+
   // Terna destrorsa e unitaria
    Vector3d vtV1 = vtToolDir ;
    Vector3d vtV2 = vtMvOrt ;  vtV2.Normalize() ;
    Vector3d vtV3 = vtV1 ^ vtV2 ;
 
   // Sistema di riferimento intrinseco del movimento
-   Frame3d ConusFrame ;  ConusFrame.Set( ptV, vtV1, vtV2, vtV3) ;
+   Frame3d ConusFrame ;  ConusFrame.Set( ptV, vtV2, vtV3, vtV1) ;
 
   // Dimensioni lineari movimento
    double dLongLen = vtMvLong.Len() ;
@@ -4380,9 +4342,6 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
    bool bElpsB = ( abs( vtToolDir * vtUmv) > EPS_SMALL ? true : bTapB) ;
    bool bElpsT = ( abs( vtToolDir * vtUmv) > EPS_SMALL ? true : bTapT) ;
 
-   double dMin, dMax ;
-   Vector3d vtNmin, vtNmax ;
-
    if ( dRatio * dTan <= 1) {
     
       for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
@@ -4398,7 +4357,8 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
 
            // Cono iniziale
             if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, bConeT, bConeB, ptInt1, ptInt2, vtN1, vtN2)) {
-
+               double dMin, dMax ;
+               Vector3d vtNmin, vtNmax ;
                if ( ptInt1.z < ptInt2.z) {
                   dMin = ptInt1.z ;
                   dMax = ptInt2.z ;
@@ -4411,13 +4371,13 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
                   vtNmin = vtN2 ;
                   vtNmax = vtN1 ;              
                }
-
                SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
             }
          
            // Cono finale
             if ( IntersLineConus( ptC - vtMove, Z_AX, ConusFrame, dTan, dl, dL, bConeT, bConeB, ptInt1, ptInt2, vtN1, vtN2)) {
-             
+               double dMin, dMax ;
+               Vector3d vtNmin, vtNmax ;
                if ( ptInt1.z < ptInt2.z) {
                   dMin = ptInt1.z + vtMove.z ;
                   dMax = ptInt2.z + vtMove.z ;
@@ -4430,7 +4390,6 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
                   vtNmin = vtN2 ;
                   vtNmax = vtN1 ;              
                }
-
                SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
             }   
             
@@ -4488,12 +4447,12 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
 
                   if ( nIntNum == 0) {
                      ptInt1 = ptPoly3 ;
-                     vtN1 = - vtIF ; 
+                     vtN1 = vtIF ; 
                      ++ nIntNum ;
                   }
                   else if ( ( ptInt1 - ptPoly3).SqLen() > dSqIndet) {
                      ptInt2 = ptPoly3 ;
-                     vtN2 = - vtIF ;
+                     vtN2 = vtIF ;
                      ++ nIntNum ;
                   }
                }
@@ -4507,12 +4466,12 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
 
                   if ( nIntNum == 0) {
                      ptInt1 = ptPoly4 ;
-                     vtN1 = vtIF ; 
+                     vtN1 = - vtIF ; 
                      ++ nIntNum ;
                   }
                   else if ( ( ptInt1 - ptPoly4).SqLen() > dSqIndet) {
                      ptInt2 = ptPoly4 ;
-                     vtN2 = vtIF ;
+                     vtN2 = - vtIF ;
                      ++ nIntNum ;
                   }
                }
@@ -4555,35 +4514,38 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
                   }
                }
             }
-          // Se il poliedro è attraversato taglio
-           if ( nIntNum == 2) {
+           // Se il poliedro è attraversato taglio
+            if ( nIntNum == 2) {
    
-             // Riporto le intersezioni nel sistema griglia
-              ptInt1.ToGlob( PolyFrame) ;
-              ptInt2.ToGlob( PolyFrame) ;
+              // Riporto le intersezioni nel sistema griglia
+               ptInt1.ToGlob( PolyFrame) ;
+               ptInt2.ToGlob( PolyFrame) ;
 
-              vtN1.ToGlob( PolyFrame) ;
-              vtN2.ToGlob( PolyFrame) ;
+               vtN1.ToGlob( PolyFrame) ;
+               vtN2.ToGlob( PolyFrame) ;
 
-              if ( ptInt1.z < ptInt2.z) {
-                 dMin = ptInt1.z ;
-                 dMax = ptInt2.z ;
-                 vtNmin = vtN1 ;
-                 vtNmax = vtN2 ;
-              }
-              else {
-                 dMin = ptInt2.z ;
-                 dMax = ptInt1.z ;
-                 vtNmin = vtN2 ;  
-                 vtNmax = vtN1 ;  
-              }
-           
-              SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
-           }
+               double dMin, dMax ;
+               Vector3d vtNmin, vtNmax ;
+               if ( ptInt1.z < ptInt2.z) {
+                  dMin = ptInt1.z ;
+                  dMax = ptInt2.z ;
+                  vtNmin = vtN1 ;
+                  vtNmax = vtN2 ;
+               }
+               else {
+                  dMin = ptInt2.z ;
+                  dMax = ptInt1.z ;
+                  vtNmin = vtN2 ;  
+                  vtNmax = vtN1 ;  
+               }
+               SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
+            }
 
            // Traslazione ellisse di punta
-            if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dl, ConusFrame, dSqMinRad, 
+            if ( ! bMoveOnZ  &&  IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dl, ConusFrame, dSqMinRad, 
                                                dLongLen, dOrtLen, bElpsT, bElpsT, ptInt1, ptInt2, vtN1, vtN2)) {
+               double dMin, dMax ;
+               Vector3d vtNmin, vtNmax ;
                if ( ptInt1.z < ptInt2.z) {
                   dMin = ptInt1.z + vtV1.z * dl ;
                   dMax = ptInt2.z + vtV1.z * dl ;
@@ -4596,13 +4558,14 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
                   vtNmin = vtN2 ;
                   vtNmax = vtN1 ;          
                }
-
                SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
             }
 
            // Traslazione ellisse di base
-            if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dL, ConusFrame, dSqMaxRad, 
-                                               dLongLen, dOrtLen, bElpsB, bElpsB, ptInt1, ptInt2, vtN1, vtN2)) {
+            if ( ! bMoveOnZ  &&  IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dL, ConusFrame, dSqMaxRad, 
+                                                      dLongLen, dOrtLen, bElpsB, bElpsB, ptInt1, ptInt2, vtN1, vtN2)) {
+               double dMin, dMax ;
+               Vector3d vtNmin, vtNmax ;
                if ( ptInt1.z < ptInt2.z) {
                   dMin = ptInt1.z + vtV1.z * dL ;
                   dMax = ptInt2.z + vtV1.z * dL ;
@@ -4615,7 +4578,6 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
                   vtNmin = vtN2 ;
                   vtNmax = vtN1 ;          
                }
-
                SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
             }
          }
@@ -4637,6 +4599,8 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
 
            // Cono 
             if ( IntersLineConus( ptC, Z_AX, ConusFrame, dTan, dl, dL, bConeT, bConeB, ptInt1, ptInt2, vtN1, vtN2)) {
+               double dMin, dMax ;
+               Vector3d vtNmin, vtNmax ;
                if ( ptInt1.z < ptInt2.z) {
                   dMin = ptInt1.z ;
                   dMax = ptInt2.z ;
@@ -4649,13 +4613,14 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
                   vtNmin = vtN2 ;
                   vtNmax = vtN1 ;
                }
-
                SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
             }
 
            // Traslazione ellisse 
-            if ( IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dL, ConusFrame, dSqMaxRad, 
-                                               dLongLen, dOrtLen, bConeB, bConeB, ptInt1, ptInt2, vtN1, vtN2)) {
+            if ( ! bMoveOnZ  &&  IntersLineEllipticalCylinder( Z_AX, ptC - vtV1 * dL, ConusFrame, dSqMaxRad, 
+                                                   dLongLen, dOrtLen, bConeB, bConeB, ptInt1, ptInt2, vtN1, vtN2)) {
+               double dMin, dMax ;
+               Vector3d vtNmin, vtNmax ;
                if( ptInt1.z < ptInt2.z) {
                   dMin = ptInt1.z + vtV1.z * dL ;
                   dMax = ptInt2.z + vtV1.z * dL ;
@@ -4668,7 +4633,6 @@ VolZmap::CompConus_Milling( unsigned int nGrid, const Point3d & ptS, const Point
                   vtNmin = vtN2 ;
                   vtNmax = vtN1 ;          
                }
-
                SubtractIntervals( nGrid, i, j, dMin, dMax, vtNmin, vtNmax) ;
             }
          }
@@ -4698,10 +4662,7 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
    Vector3d vtV2 = ( vtMove * ( vtV1 ^ vtAux) > 0 ? ( vtV1 ^ vtAux) : ( vtAux ^ vtV1)) ;
    Vector3d vtV3 = vtV1 ^ vtV2 ;
    Point3d ptO = ptS - dLenZ * vtV1 - vtV2 * ( 0.5 * dLenX) ;
-   Frame3d ParaFrame ; ParaFrame.Set( ptO, vtV1, vtV2, vtV3) ;
-
-  // Lunghezza della traiettoria
-   double dLenMove = vtMove * vtV2 ;
+   Frame3d ParaFrame ; ParaFrame.Set( ptO, vtV2, vtV3, vtV1) ;
 
   // Studio del volume asportato durante il moto
    Point3d ptLs = ( vtMove * vtAux >= 0 ? ptS : ptE) ;
@@ -4712,20 +4673,20 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
 
    Vector3d vtMv = ptLe - ptLs ;
 
-   bool bSymmetry = vtMv * ( vtW3 ^ vtToolDir) > 0 ; 
+   bool bSymmetry = vtMv * vtAnsatz > 0 ; 
 
    Vector3d vtW2 = ( bSymmetry ? vtAnsatz : - vtAnsatz) ;
    Vector3d vtW1 = ( bSymmetry ? vtToolDir : - vtToolDir) ;
 
    Point3d ptBase = bSymmetry ? ptLs - dLenZ * vtW1 : ptLs ;
 
-   Frame3d MotionFrame ;  /*MotionFrame.Set( ptOMotion, vtU1, vtU2, vtU3) ;*/
+   Frame3d MotionFrame ;  
 
    Point3d ptDiagMin = ptBase - vtW2 * ( 0.5 * dLenX) + vtW3 * ( 0.5 * dLenY) ; 
    Point3d ptDiagMax = ptBase + vtW2 * ( 0.5 * dLenX) - vtW3 * ( 0.5 * dLenY) ; 
 
    Vector3d vtU1 = ptDiagMax - ptDiagMin ;
-   double dDimX = ( ptDiagMax - ptDiagMin).Len() ;
+   double dDimLong = ( ptDiagMax - ptDiagMin).Len() ;
    vtU1.Normalize() ;
    bool bSymmetry2 = vtU1 * vtMv > 0 ; 
    Vector3d vtU2 = ( bSymmetry2 ? vtMv - vtMv * vtU1  * vtU1 : 
@@ -4735,10 +4696,10 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
 
    Point3d ptOMotion = ( vtMv * vtU1 > 0 ? ptDiagMin : ptDiagMin + vtMv) + vtU3 * ( 0.5 * dLenZ) ;
 
-   MotionFrame.Set( ptOMotion, vtU1, vtU2, vtU3) ;
+   MotionFrame.Set( ptOMotion, vtU2, vtU3, vtU1) ;  
    
-   double dLen1 = abs( vtMv * vtU1) ;
-   double dLen2 = abs( vtMv * vtU2) ;
+   double dDeltaLong = abs( vtMv * vtU1) ;
+   double dDimOrt = abs( vtMv * vtU2) ;
 
    for ( unsigned int i = nStartI ; i <= nEndI ; ++ i) {
       for ( unsigned int j = nStartJ ; j <= nEndJ ; ++ j) {
@@ -4752,7 +4713,7 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
          Vector3d vtN1, vtN2 ;
 
         // Solido nella posizione iniziale
-         if ( IntersLineMyPolyhedron(  ptC, Z_AX, ParaFrame, dLenZ, dLenX, dLenY, 0, ptInt1, ptInt2, vtN1, vtN2)) {
+         if ( IntersLineMyPolyhedron(  ptC, Z_AX, ParaFrame, dLenX, dLenY, dLenZ, 0, ptInt1, ptInt2, vtN1, vtN2)) {
             double dMin, dMax ;
             Vector3d vtNmin, vtNmax ;
             if ( ptInt1.z < ptInt2.z) {
@@ -4772,7 +4733,7 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
          }
 
          // Solido nella posizione finale
-         if ( IntersLineMyPolyhedron(  ptC - vtMove, Z_AX, ParaFrame, dLenZ, dLenX, dLenY, 0, ptInt1, ptInt2, vtN1, vtN2)) {
+         if ( IntersLineMyPolyhedron(  ptC - vtMove, Z_AX, ParaFrame, dLenX, dLenY, dLenZ, 0, ptInt1, ptInt2, vtN1, vtN2)) {
             double dMin, dMax ;
             Vector3d vtNmin, vtNmax ;
             if ( ptInt1.z < ptInt2.z) {
@@ -4792,7 +4753,7 @@ VolZmap::CompPar_Milling( unsigned int nGrid, double dLenX, double dLenY, double
          }
 
         // Volume spazzato nel moto
-         if ( IntersLineMyPolyhedron(  ptC, Z_AX, MotionFrame, dDimX, dLen2, dLenZ, dLen1, ptInt1, ptInt2, vtN1, vtN2)) {
+         if ( IntersLineMyPolyhedron(  ptC, Z_AX, MotionFrame, dDimOrt, dLenZ, dDimLong, dDeltaLong, ptInt1, ptInt2, vtN1, vtN2)) {
             double dMin, dMax ;
             Vector3d vtNmin, vtNmax ;
             if ( ptInt1.z < ptInt2.z) {
@@ -4836,18 +4797,18 @@ VolZmap::CompBall_Milling( unsigned int nGrid, const Point3d & ptLs, const Point
    Vector3d vtW ;
 
   // Costruisco sistema di riferimento
-   if ( vtV.x * vtV.x > 0.3)  
+   if ( vtV.x * vtV.x > 0.09)  
       vtW.Set( - ( vtV.y + vtV.z) / vtV.x, 1, 1) ;   
    
-   else if ( vtV.y * vtV.y > 0.3) 
+   else if ( vtV.y * vtV.y > 0.09) 
       vtW.Set( 1, - ( vtV.x + vtV.z) / vtV.y, 1) ;   
    
    else
       vtW.Set( 1, 1, - ( vtV.x + vtV.y) / vtV.z) ;
 
-   Point3d ptOnY = ptLs + vtW ;
+   //Point3d ptOnX = ptLs + vtW ;
    
-   Frame3d CylFrame ;  CylFrame.Set( ptLs, ptLe, ptOnY) ;
+   Frame3d CylFrame ;  CylFrame.Set( ptLs, vtV, vtW) ;
 
    double dSqRad = dRad * dRad ;