diff --git a/VolZmap.h b/VolZmap.h
index 5c22b5a..9c6ccc0 100644
--- a/VolZmap.h
+++ b/VolZmap.h
@@ -210,6 +210,13 @@ class VolZmap : public IVolZmap, public IGeoObjRW
                               double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) ;
       bool AddIntervals( int nGrid, int nI, int nJ,
                          double dMin, double dMax, const Vector3d& vtNMin, const Vector3d& vtNMax) ;
+     // Spostamenti utensile
+      bool MillingTranslationStep( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtD, const Vector3d& vtA) ;
+      bool MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
+                                     const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe) ;
+      bool SelectMotion( int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d vtL, const Vector3d vtAL) ;
+      bool InitializePointsAndVectors( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtDs, const Vector3d& vtAs,
+                                       Point3d ptLs[3], Point3d ptLe[3], Vector3d vtLs[3], Vector3d vtALs[3]) ;
     // SOTTRAZIONI 
     // UTENSILI
      // Asse di simmetria parallelo a Z
diff --git a/VolZmapVolume.cpp b/VolZmapVolume.cpp
index 51ac18d..b563f56 100644
--- a/VolZmapVolume.cpp
+++ b/VolZmapVolume.cpp
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2019
+//  EgalTech 2015-2020
 //----------------------------------------------------------------------------
-// File : VolZmap.cpp         Data : 01.03.19           Versione : 2.1c1
+// File : VolZmap.cpp         Data : 05.10.20           Versione : 2.2j1
 // Contenuto : Implementazione della classe Volume Zmap (tre griglie)
 //
 //
@@ -480,14 +480,16 @@ VolZmap::AddIntervals( int nGrid, int nI, int nJ,
 
 //----------------------------------------------------------------------------       
 bool
-VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Point3d& ptPe, const Vector3d& vtDe) 
+VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs,
+                      const Point3d& ptPe, const Vector3d& vtDe) 
 {
    return MillingStep( ptPs, vtDs, Vector3d(), ptPe, vtDe, Vector3d()) ;
 }
 
 //----------------------------------------------------------------------------       
 bool
-VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs, const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe)
+VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
+                      const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe)
 {
   // Se non č definito l'utensile, non devo fare alcunchč
    if ( m_Tool.GetType() == Tool::UNDEF)
@@ -503,278 +505,323 @@ VolZmap::MillingStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d&
       if ( vtAs.IsSmall()  ||  vtAe.IsSmall())
          return false ;
    }
+  // Reset numero di parti
+   m_nConnectedCompoCount = - 1 ;
 
-  // Punti nei sistemi di riferimento intrinseci dello Zmap
+  // Punti e vettori descriventi il moto nel sistema intrinseco dello Zmap
+   Point3d ptPLs = ptPs ;
+   ptPLs.ToLoc( m_MapFrame) ;
+   Point3d ptPLe = ptPe ;
+   ptPLe.ToLoc( m_MapFrame) ;
+   Vector3d vtDLs = vtDs ;
+   vtDLs.ToLoc( m_MapFrame) ;
+   vtDLs.Normalize() ;
+   Vector3d vtDLe = vtDe ;
+   vtDLe.ToLoc( m_MapFrame) ;
+   vtDLe.Normalize() ;
+   Vector3d vtALs = vtAs ;
+   vtALs.ToLoc( m_MapFrame) ;
+   vtALs.Normalize() ;
+   Vector3d vtALe = vtAe ;
+   vtALe.ToLoc( m_MapFrame) ;
+   vtALe.Normalize() ;
+
+  // Se pura traslazione
+   if ( AreSameVectorApprox( vtDLs, vtDLe))
+      return MillingTranslationStep( ptPLs, ptPLe, vtDLs, vtALs) ;
+   else
+      return MillingGeneralMotionStep( ptPLs, vtDLs, vtALs, ptPLe, vtDLe, vtALe) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+VolZmap::MillingGeneralMotionStep( const Point3d& ptPs, const Vector3d& vtDs, const Vector3d& vtAs,
+                                   const Point3d& ptPe, const Vector3d& vtDe, const Vector3d& vtAe)
+{
+   // Ciclo sulle mappe
+   double dAngDeg ;
+   vtDs.GetAngle( vtDe, dAngDeg) ;
+   int nNumSubStep = int( abs( dAngDeg) / 0.5) ;
+   Vector3d vtMove = ptPe - ptPs ;
+   double dLenPath = vtMove.Len() ;
+   double dDeltaLen = dLenPath / nNumSubStep ;
+   vtMove /= dLenPath ;
+   bool bSuccessful = true ;
+   for ( int n = 0 ; n < nNumSubStep + 1 &&  bSuccessful ; ++ n) {
+      double dPathSt = 0 ;
+      double dPathEn = 0.5 * dDeltaLen ;
+      if ( n == nNumSubStep) {
+         dPathSt = ( n - 0.5) * dDeltaLen ;
+         dPathEn = n * dDeltaLen ;
+      }
+      else if ( n > 0) {
+         dPathSt = ( n - 0.5) * dDeltaLen ;
+         dPathEn = ( n + 0.5) * dDeltaLen ;
+      }
+      Point3d ptSt = ptPs + dPathSt * vtMove ;
+      Point3d ptEn = ptPs + dPathEn * vtMove ;
+      Vector3d vtD = ( dLenPath - dPathSt) * vtDs + dPathSt * vtDe ;
+      vtD.Normalize() ;
+      Vector3d vtA = ( dLenPath - dPathSt) * vtAs + dPathSt * vtAe ;
+      vtA.Normalize() ;
+      bSuccessful = bSuccessful  &&  MillingTranslationStep( ptSt, ptEn, vtD, vtA) ;
+   }
+   return bSuccessful ;
+}
+
+//----------------------------------------------------------------------------
+bool
+VolZmap::MillingTranslationStep( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtD, const Vector3d& vtA)
+{
    Point3d ptLs[3] ;
    Point3d ptLe[3] ;
+   Vector3d vtLs[3] ;
+   Vector3d vtALs[3] ;
+   InitializePointsAndVectors( ptPs, ptPe, vtD, vtA, ptLs, ptLe, vtLs, vtALs) ;
+   // Ciclo sulle mappe 
+   for ( int i = 0 ; i < m_nMapNum ; ++ i) {
+      SelectMotion( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
+   }
+   return true ;
+}
 
+//----------------------------------------------------------------------------
+bool
+VolZmap::InitializePointsAndVectors( const Point3d& ptPs, const Point3d& ptPe, const Vector3d& vtDs, const Vector3d& vtAs,
+                                     Point3d ptLs[3], Point3d ptLe[3], Vector3d vtLs[3], Vector3d vtALs[3])
+{
+  // Punti posizione
    ptLs[0] = ptPs ;
-   ptLs[0].ToLoc( m_MapFrame) ;
-
    ptLe[0] = ptPe ;
-   ptLe[0].ToLoc( m_MapFrame) ;
-
    if ( m_nMapNum > 1) {
       ptLs[1].x = ptLs[0].y ;  ptLs[1].y = ptLs[0].z ;  ptLs[1].z = ptLs[0].x ;
       ptLs[2].x = ptLs[0].z ;  ptLs[2].y = ptLs[0].x ;  ptLs[2].z = ptLs[0].y ;
-
       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 ;
    }
 
-  // Vettori nei sistemi di riferimento intrinseci dello Zmap 
-   Vector3d vtLs[3] ;
-   Vector3d vtLe[3] ;
-
-   vtLs[0] = vtDs ;  
-   vtLs[0].ToLoc( m_MapFrame) ;
-   vtLs[0].Normalize() ;
-
-   vtLe[0] = vtDe ;
-   vtLe[0].ToLoc( m_MapFrame) ;
-   vtLe[0].Normalize() ;
-
+  // Vettori asse utensile
+   vtLs[0] = vtDs ;
    if ( m_nMapNum > 1) {
       vtLs[1].x = vtLs[0].y ;  vtLs[1].y = vtLs[0].z ;  vtLs[1].z = vtLs[0].x ;
       vtLs[2].x = vtLs[0].z ;  vtLs[2].y = vtLs[0].x ;  vtLs[2].z = vtLs[0].y ;
-
-      vtLe[1].x = vtLe[0].y ;  vtLe[1].y = vtLe[0].z ;  vtLe[1].z = vtLe[0].x ;
-      vtLe[2].x = vtLe[0].z ;  vtLe[2].y = vtLe[0].x ;  vtLe[2].z = vtLe[0].y ;
    }
 
-  // Vettori ausiliari nei sistemi di riferimento intrinseci dello Zmap 
-   Vector3d vtALs[3] ;
-   Vector3d vtALe[3] ;
-
-   vtALs[0] = vtAs ;  
-   vtALs[0].ToLoc( m_MapFrame) ;
-   vtALs[0].Normalize() ;
-
-   vtALe[0] = vtAe ;
-   vtALe[0].ToLoc( m_MapFrame) ;
-   vtALe[0].Normalize() ;
-
+  // Vettori ausiliari 
+   vtALs[0] = vtAs ;
    if ( m_nMapNum > 1) {
       vtALs[1].x = vtALs[0].y ;  vtALs[1].y = vtALs[0].z ;  vtALs[1].z = vtALs[0].x ;
       vtALs[2].x = vtALs[0].z ;  vtALs[2].y = vtALs[0].x ;  vtALs[2].z = vtALs[0].y ;
-
-      vtALe[1].x = vtALe[0].y ;  vtALe[1].y = vtALe[0].z ;  vtALe[1].z = vtALe[0].x ;
-      vtALe[2].x = vtALe[0].z ;  vtALe[2].y = vtALe[0].x ;  vtALe[2].z = vtALe[0].y ;
    }
 
-  // Ciclo sulle mappe 
-   for ( int i = 0 ; i < m_nMapNum ; ++ i) {
-     // Direzione utensile costante: pura traslazione 
-      if ( AreSameVectorApprox( vtLs[i], vtLe[i])) {
+   return true ;
+}
 
-        // Versore utensile parallelo all'asse Z (coincide con spillone)
-         if ( vtLs[i].SqLenXY() < EPS_ZERO * EPS_ZERO) {
+//----------------------------------------------------------------------------
+bool
+VolZmap::SelectMotion( int nGrid, const Point3d& ptLs, const Point3d& ptLe, const Vector3d vtL, const Vector3d vtAL)
+{
+  // Versore utensile parallelo all'asse Z (coincide con spillone)
+   if ( vtL.SqLenXY() < EPS_ZERO * EPS_ZERO) {
 
-            Vector3d vtMove = ptLe[i] - ptLs[i] ;
+      Vector3d vtMove = ptLe - ptLs ;
 
-           // Foratura
-            if ( vtMove.SqLenXY() < EPS_SMALL * EPS_SMALL) {
-               switch ( m_Tool.GetType())  {
-               case Tool::GEN :
-                  GenTool_ZDrilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CYLMILL :
-               case Tool::BALLMILL :
-                  CylBall_ZDrilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CONEMILL :
-                  Conus_ZDrilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::MORTISER :
-                  Mrt_ZDrilling( i, ptLs[i],  ptLe[i], vtLs[i],  vtALs[i]) ;
-                  break ;
-               case Tool::CHISEL :
-                  Chs_ZDrilling( i, ptLs[i],  ptLe[i], vtLs[i],  vtALs[i]) ;
-                  break ;
-               }
-            }
-
-           // Fresatura con vettore movimento perpendicolare all'utensile
-            else if ( abs( vtMove.z) < EPS_SMALL) {
-               switch ( m_Tool.GetType())  {
-               case Tool::GEN :
-                  GenTool_ZMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CYLMILL :
-               case Tool::BALLMILL :
-                  CylBall_ZPerp( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CONEMILL :
-                  Conus_ZPerp( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::MORTISER :
-                  Mrt_Milling(i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]);
-                  break ;
-               case Tool::CHISEL :
-                  Chs_Milling( i, ptLs[i],  ptLe[i], vtLs[i],  vtALs[i]) ;
-                  break ;     
-               }
-            }
-
-           // Fresatura con vettore movimento generico rispetto all'utensile
-            else {
-               switch ( m_Tool.GetType())  {
-               case Tool::GEN :
-                  GenTool_ZMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CYLMILL :
-               case Tool::BALLMILL :
-                  CylBall_ZMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CONEMILL :
-                  Conus_ZMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::MORTISER :
-                  Mrt_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
-                  break ;
-               }
-            }
-         }
-
-        // Versore utensile nel piano XY (perpendicolare allo spillone)
-         else if ( abs( vtLs[i].z) < EPS_ZERO) {
-
-            Vector3d vtMove = ptLe[i] - ptLs[i] ;
-            Vector3d vtMLong = ( vtMove * vtLs[i]) * vtLs[i] ;
-            Vector3d vtMOrt = vtMove - vtMLong ;
-
-            double dSqLLong = vtMLong.SqLen() ;
-            double dSqLOrt = vtMOrt.SqLen() ;
-
-           // Foratura
-            if ( dSqLOrt < EPS_SMALL * EPS_SMALL) {
-               switch ( m_Tool.GetType())  {
-               case Tool::GEN :
-                  GenTool_Drilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CYLMILL :
-               case Tool::BALLMILL :
-                  CylBall_XYDrilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CONEMILL :
-                  Conus_XYDrilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::MORTISER :
-                  Mrt_Drilling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
-                  break ;
-               case Tool::CHISEL :
-                  Chs_Drilling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
-                  break ;
-               }
-            }
-           // Fresatura con vettore movimento perpendicolare all'utensile
-            else if ( dSqLLong < EPS_SMALL * EPS_SMALL) {
-               switch ( m_Tool.GetType())  {
-               case Tool::GEN :
-                  GenTool_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CYLMILL :
-               case Tool::BALLMILL :
-                  CylBall_XYPerp( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CONEMILL :
-                  // Usiamo la generica per via dell'intsabilitā di Conus_XYPerp
-                  //Conus_XYPerp( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  Conus_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::MORTISER :
-                  Mrt_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
-                  break ;
-               case Tool::CHISEL :
-                  Chs_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
-                  break ;
-               }
-            } 
-           // Fresatura con vettore movimento generico rispetto all'utensile
-            else {
-               switch ( m_Tool.GetType())  {
-               case Tool::GEN :
-                  GenTool_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CYLMILL :
-               case Tool::BALLMILL :
-                  CylBall_XYMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CONEMILL :
-                  Conus_XYMilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;     
-               case Tool::MORTISER :                 
-                  Mrt_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
-                  break ;
-               }
-            }
-         }
-
-        // Versore utensile con direzione generica
-         else {
-            Vector3d vtMove = ptLe[i] - ptLs[i] ;
-            Vector3d vtMLong = ( vtMove * vtLs[i]) * vtLs[i] ;
-            Vector3d vtMOrt = vtMove - vtMLong ;
-
-            double dSqLLong = vtMLong.SqLen() ;
-            double dSqLOrt = vtMOrt.SqLen() ;
-
-           // Foratura
-            if ( dSqLOrt < EPS_SMALL * EPS_SMALL) {
-               switch ( m_Tool.GetType())  {
-               case Tool::GEN :
-                  GenTool_Drilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CYLMILL :
-               case Tool::BALLMILL :
-                  CylBall_Drilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CONEMILL :
-                  Conus_Drilling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::MORTISER :
-                  Mrt_Drilling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
-                  break ;
-               case Tool::CHISEL :
-                  Chs_Drilling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
-                  break ;
-               }
-            }
-           // Fresatura con vettore movimento generico rispetto all'utensile
-            else {
-               switch ( m_Tool.GetType())  {
-               case Tool::GEN :
-                  GenTool_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CYLMILL :
-               case Tool::BALLMILL :
-                  CylBall_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::CONEMILL :
-                  Conus_Milling( i, ptLs[i], ptLe[i], vtLs[i]) ;
-                  break ;
-               case Tool::MORTISER :
-                  Mrt_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
-                  break ;
-               case Tool::CHISEL :
-                 // ammesso solo movimento perpendicolare all'asse utensile
-                  if ( dSqLLong < EPS_SMALL * EPS_SMALL)
-                     Chs_Milling( i, ptLs[i], ptLe[i], vtLs[i], vtALs[i]) ;
-                  break ;
-               }
-            }
+     // Foratura
+      if ( vtMove.SqLenXY() < EPS_SMALL * EPS_SMALL) {
+         switch ( m_Tool.GetType()) {
+         case Tool::GEN :
+            GenTool_ZDrilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CYLMILL :
+         case Tool::BALLMILL :
+            CylBall_ZDrilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CONEMILL :
+            Conus_ZDrilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::MORTISER :
+            Mrt_ZDrilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         case Tool::CHISEL :
+            Chs_ZDrilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
          }
       }
 
-      else   ;
-     // Altri casi al momento non gestiti
-       //  return false ;
+     // Fresatura con vettore movimento perpendicolare all'utensile
+      else if ( abs( vtMove.z) < EPS_SMALL) {
+         switch ( m_Tool.GetType()) {
+         case Tool::GEN :
+            GenTool_ZMilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CYLMILL :
+         case Tool::BALLMILL :
+            CylBall_ZPerp( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CONEMILL :
+            Conus_ZPerp( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::MORTISER :
+            Mrt_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         case Tool::CHISEL :
+            Chs_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         }
+      }
+
+     // Fresatura con vettore movimento generico rispetto all'utensile
+      else {
+         switch ( m_Tool.GetType()) {
+         case Tool::GEN :
+            GenTool_ZMilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CYLMILL :
+         case Tool::BALLMILL :
+            CylBall_ZMilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CONEMILL :
+            Conus_ZMilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::MORTISER :
+            Mrt_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         }
+      }
+   }
+
+  // Versore utensile nel piano XY (perpendicolare allo spillone)
+   else if ( abs( vtL.z) < EPS_ZERO) {
+
+      Vector3d vtMove = ptLe - ptLs ;
+      Vector3d vtMLong = ( vtMove * vtL) * vtL ;
+      Vector3d vtMOrt = vtMove - vtMLong ;
+
+      double dSqLLong = vtMLong.SqLen() ;
+      double dSqLOrt = vtMOrt.SqLen() ;
+
+     // Foratura
+      if ( dSqLOrt < EPS_SMALL * EPS_SMALL) {
+         switch ( m_Tool.GetType()) {
+         case Tool::GEN :
+            GenTool_Drilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CYLMILL :
+         case Tool::BALLMILL :
+            CylBall_XYDrilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CONEMILL :
+            Conus_XYDrilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::MORTISER :
+            Mrt_Drilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         case Tool::CHISEL :
+            Chs_Drilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         }
+      }
+     // Fresatura con vettore movimento perpendicolare all'utensile
+      else if ( dSqLLong < EPS_SMALL * EPS_SMALL) {
+         switch ( m_Tool.GetType()) {
+         case Tool::GEN :
+            GenTool_Milling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CYLMILL :
+         case Tool::BALLMILL :
+            CylBall_XYPerp( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CONEMILL :
+           // Usiamo la generica per via dell'intsabilitā di Conus_XYPerp
+           //Conus_XYPerp( i, ptLs[i], ptLe[i], vtLs[i]) ;
+            Conus_Milling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::MORTISER :
+            Mrt_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         case Tool::CHISEL :
+            Chs_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         }
+      }
+     // Fresatura con vettore movimento generico rispetto all'utensile
+      else {
+         switch ( m_Tool.GetType()) {
+         case Tool::GEN :
+            GenTool_Milling( nGrid, ptLs, ptLe, vtL);
+            break ;
+         case Tool::CYLMILL :
+         case Tool::BALLMILL :
+            CylBall_XYMilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CONEMILL :
+            Conus_XYMilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::MORTISER :
+            Mrt_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         }
+      }
+   }
+
+  // Versore utensile con direzione generica
+   else {
+      Vector3d vtMove = ptLe - ptLs ;
+      Vector3d vtMLong = ( vtMove * vtL) * vtL ;
+      Vector3d vtMOrt = vtMove - vtMLong ;
+
+      double dSqLLong = vtMLong.SqLen() ;
+      double dSqLOrt = vtMOrt.SqLen() ;
+
+      // Foratura
+      if ( dSqLOrt < EPS_SMALL * EPS_SMALL) {
+         switch ( m_Tool.GetType()) {
+         case Tool::GEN :
+            GenTool_Drilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CYLMILL :
+         case Tool::BALLMILL :
+            CylBall_Drilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CONEMILL :
+            Conus_Drilling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::MORTISER :
+            Mrt_Drilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         case Tool::CHISEL :
+            Chs_Drilling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         }
+      }
+     // Fresatura con vettore movimento generico rispetto all'utensile
+      else {
+         switch ( m_Tool.GetType()) {
+         case Tool::GEN :
+            GenTool_Milling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CYLMILL :
+         case Tool::BALLMILL :
+            CylBall_Milling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::CONEMILL :
+            Conus_Milling( nGrid, ptLs, ptLe, vtL) ;
+            break ;
+         case Tool::MORTISER :
+            Mrt_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         case Tool::CHISEL :
+           // ammesso solo movimento perpendicolare all'asse utensile
+            if ( dSqLLong < EPS_SMALL * EPS_SMALL)
+               Chs_Milling( nGrid, ptLs, ptLe, vtL, vtAL) ;
+            break ;
+         }
+      }
    }
-   
-   m_nConnectedCompoCount = - 1 ;
    return true ;
 }
 
+
 // ---------- VERSORE UTENSILE DERETTO COME Z --------------------------------