diff --git a/OperUserNotesConst.h b/OperUserNotesConst.h
index 7ca4a60..aa188d4 100644
--- a/OperUserNotesConst.h
+++ b/OperUserNotesConst.h
@@ -71,8 +71,7 @@ static const std::string UN_STEPNUMBER = "StepNumber" ;
 static const std::string UN_BITANGANG = "BiTangAng" ;
 static const std::string UN_OPTIMALTYPE = "OptimalType" ;
 static const std::string UN_ANGLETOL = "AngleTol" ;
-static const std::string UN_THETA = "Theta" ;
-static const std::string UN_PHI = "Phi" ;
+static const std::string UN_TILT_ANGS = "Tilt" ;
 
 // Solo per SurfRoughing
 static const std::string UN_PLANEZ = "PlaneZ" ;
diff --git a/SurfFinishing.cpp b/SurfFinishing.cpp
index da45878..ec8a563 100644
--- a/SurfFinishing.cpp
+++ b/SurfFinishing.cpp
@@ -49,6 +49,7 @@
 #include "/EgtDev/Include/EGkDistPointSurfTm.h"
 #include "/EgtDev/Include/EGkPolygon3d.h"
 #include "/EgtDev/Include/EGkPolygonElevation.h"
+#include "/EgtDev/Include/EGkGeoVector3d.h"
 #include <thread>
 #include <future>
 // per far dimenticare macro di WinUser.h
@@ -93,6 +94,7 @@ using namespace std ;
 // 3134 = "Error in SurfFinishing : Projecting Path failed"
 // 3135 = "Error in SurfFinishing : Calc Region Elvation failed"
 // 3136 = "Error in SurfFinishing : special apply not calculable"
+// 3137 = "Error in SurfFinishing : Tool direction too steepy"
 // 3151 = "Warning in SurfFinishing : Skipped entity (xx)"
 // 3152 = "Warning in SurfFinishing : No machinable path"
 // 3153 = "Warning in SurfFinishing : Tool name changed (xx)"
@@ -104,6 +106,7 @@ static string KEY_THICK = "THICK" ;
 static string SRF_SUPP_LAYER_NAME = "SUPP" ;
 const double SILH_SAMPLING = 1. ;
 const double SUPP_SURF_RADIAL_OFFS = 5. ;
+const double TILT_ANG_DEG = 60.0 ;
 enum {
    PENCIL_CORNER = 0,
    PENCIL_FAT_CORNER = 1,
@@ -150,6 +153,9 @@ SurfFinishing::Clone( void) const
          pSrF->m_nPhase = m_nPhase ;
          pSrF->m_Params = m_Params ;
          pSrF->m_TParams = m_TParams ;
+         pSrF->m_Frame = m_Frame ;
+         pSrF->m_dTheta = m_dTheta ;
+         pSrF->m_dPhi = m_dPhi ;
          pSrF->m_dTHoldBase = m_dTHoldBase ;
          pSrF->m_dTHoldLen = m_dTHoldLen ;
          pSrF->m_dTHoldDiam = m_dTHoldDiam ;
@@ -272,6 +278,9 @@ SurfFinishing::SurfFinishing( void)
    m_nStatus = MCH_ST_TO_VERIFY ;
    m_nPaths = 0 ;
    m_bRunning = false ;
+   m_Frame.Reset() ;                   // inizialmente invalido
+   m_dTheta = 0. ;                     // orientamento come asse Z di m_Frame
+   m_dPhi = 0. ;                       // orientamento come asse Z di m_Frame
 }
 
 //----------------------------------------------------------------------------
@@ -580,22 +589,6 @@ SurfFinishing::MyApply( bool bRecalc, bool bPostApply)
    if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
       bRecalc = true ;
 
-  // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
-     // confermo i percorsi di lavorazione
-      m_nPaths = nCurrPaths ;
-      string sLog = string( "SurfFinishing apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
-      LOG_DBG_INFO( GetEMkLogger(), sLog.c_str()) ;
-     // eseguo aggiornamento assi macchina e collegamento con operazione precedente
-      if ( ! Update( bPostApply))
-         return false ;
-      m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
-      LOG_DBG_INFO( GetEMkLogger(), "Update done") ;
-     // esco con successo
-      return true ;
-   }
-   m_nStatus = MCH_ST_TO_VERIFY ;
-
   // recupero gruppo per geometria ausiliaria
    int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ;
    bool bChain = false ;
@@ -634,6 +627,67 @@ SurfFinishing::MyApply( bool bRecalc, bool bPostApply)
          m_pGeomDB->EmptyGroup( nAuxId) ;
    }
 
+  // se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
+   if ( bChain  &&  ! Chain( nAuxId)) {
+      m_pMchMgr->SetLastError( 3103, "Error in SurfFinishing : Chaining failed") ;
+      return false ;
+   }
+
+  // se modifica del frame, necessario ricalcolo
+   UpdateFrameAndToolDir( nAuxId, bRecalc) ;
+
+  // recupero il gruppo per posizionamento Frame e versore utensile
+   int nFrameId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_FRAME) ;
+  // se non c'è lo aggiungo
+   if ( nFrameId == GDB_ID_NULL) {
+      nFrameId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
+      if ( nFrameId == GDB_ID_NULL)
+         return false ;
+      m_pGeomDB->SetName( nFrameId, MCH_FRAME) ;
+      m_pGeomDB->SetStatus( nFrameId, GDB_ST_ON) ;
+   }
+  // se richiesto il ricalcolo lo aggiorno
+   else if ( bRecalc)
+      m_pGeomDB->EmptyGroup( nFrameId) ;
+
+  // aggiungo il frame e il versore utensile al suo interno
+   PtrOwner<IGeoFrame3d> pFrGeo( CreateGeoFrame3d()) ;
+   if ( IsNull( pFrGeo)  ||  ! pFrGeo->Set( m_Frame))
+      return false ;
+   int nFrId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nFrameId, ::Release( pFrGeo)) ;
+   if ( nFrId == GDB_ID_NULL)
+      return false ;
+   m_pGeomDB->SetStatus( nFrId, GDB_ST_ON) ;
+   Vector3d vtSperic = GetToGlob( FromSpherical( 25.0, m_dTheta, m_dPhi), m_Frame) ;
+   PtrOwner<IGeoVector3d> vtToolGeo( CreateGeoVector3d()) ;
+   if ( IsNull( vtToolGeo)  ||  ! vtToolGeo->Set( vtSperic))
+      return false ;
+   vtToolGeo->ChangeBase( m_Frame.Orig()) ;
+   int nToolVtId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nFrameId, ::Release( vtToolGeo)) ;
+   if ( nToolVtId == GDB_ID_NULL)
+      return false ;
+   m_pGeomDB->SetStatus( nToolVtId, GDB_ST_ON) ;
+   m_pGeomDB->SetMaterial( nToolVtId, FUCHSIA) ;
+  // nel caso di lavorazioni Optimal o Zlevel nascondo tale frame
+   if ( m_Params.m_nSubType == SURFFIN_SUB_Z_CONST  ||  m_Params.m_nSubType == SURFFIN_SUB_OPTIMAL)
+      m_pGeomDB->SetStatus( nToolVtId, GDB_ST_OFF) ;
+
+  // verifico se necessario continuare nell'aggiornamento
+   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
+     // confermo i percorsi di lavorazione
+      m_nPaths = nCurrPaths ;
+      string sLog = string( "SurfFinishing apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
+      LOG_DBG_INFO( GetEMkLogger(), sLog.c_str()) ;
+     // eseguo aggiornamento assi macchina e collegamento con operazione precedente
+      if ( ! Update( bPostApply))
+         return false ;
+      m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
+      LOG_DBG_INFO( GetEMkLogger(), "Update done") ;
+     // esco con successo
+      return true ;
+   }
+   m_nStatus = MCH_ST_TO_VERIFY ;
+   
   // rendo corrente l'utensile usato nella lavorazione
    if ( ! m_pMchMgr->SetCalcTool( m_TParams.m_sName, m_TParams.m_sHead, m_TParams.m_nExit)) {
       m_pMchMgr->SetLastError( 3102, "Error in SurfFinishing : Tool loading failed") ;
@@ -648,12 +702,6 @@ SurfFinishing::MyApply( bool bRecalc, bool bPostApply)
    m_dTHoldDiam = 0 ;
    m_pGeomDB->GetInfo( nToolId, TTH_DIAM, m_dTHoldDiam) ;
 
-  // se necessario, eseguo concatenamento ed inserisco i percorsi sotto la geometria ausiliaria
-   if ( bChain  &&  ! Chain( nAuxId)) {
-      m_pMchMgr->SetLastError( 3103, "Error in SurfFinishing : Chaining failed") ;
-      return false ;
-   }
-
   // recupero gruppo per geometria di lavorazione (Cutter Location)
    int nClId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_CL) ;
   // se non c'è, lo aggiungo
@@ -687,7 +735,7 @@ SurfFinishing::MyApply( bool bRecalc, bool bPostApply)
       bool bOk = true ;
       int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
       while ( nPathId != GDB_ID_NULL) {
-         if ( ! ProcessCrvCompo( nPathId, GDB_ID_NULL, nClId))
+         if ( ! ProcessCrv( nPathId, GDB_ID_NULL, nClId))
             bOk = false ;
          nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
       }
@@ -994,7 +1042,6 @@ SurfFinishing::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP)
 {
   // compenso il raggio dell'utensile
    ptP += pCamData->GetCorrDir() * ( m_TParams.m_dDiam / 2) ;
-
    return true ;
 }
 
@@ -1316,6 +1363,138 @@ SurfFinishing::Chain( int nGrpDestId)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+SurfFinishing::UpdateFrameAndToolDir( int nAuxId, bool& bRecalc)
+{
+  // di base il ricalcolo è attivo
+   bRecalc = true ;
+   Frame3d FrOld = m_Frame ;
+
+  // se lavorazione con superficie
+   if ( m_Params.m_nSubType == SURFFIN_SUB_ZIGZAG  ||  m_Params.m_nSubType == SURFFIN_SUB_ONEWAY  ||
+        m_Params.m_nSubType == SURFFIN_SUB_SPIRALIN  ||  m_Params.m_nSubType == SURFFIN_SUB_SPIRALOUT  ||
+        m_Params.m_nSubType == SURFFIN_SUB_Z_CONST  ||  m_Params.m_nSubType == SURFFIN_SUB_OPTIMAL  ||
+        m_Params.m_nSubType == SURFFIN_SUB_PENCIL) {
+      PtrOwner<ISurfFlatRegion> pSfr( nullptr) ;
+      int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
+      while ( nPathId != GDB_ID_NULL) {
+        // recupero la superficie
+         int nSfrId = m_pGeomDB->GetFirstInGroup( nPathId) ;
+         if ( m_pGeomDB->GetGeoType( nSfrId) != SRF_FLATRGN)
+            return false ;
+         const ISurfFlatRegion* pSfrGeo = GetSurfFlatRegion( m_pGeomDB->GetGeoObj( nSfrId)) ;
+         if ( pSfrGeo != nullptr  &&  pSfrGeo->IsValid()) {
+            if ( IsNull( pSfr)  ||  ! pSfr->IsValid()) {
+               if ( ! pSfr.Set( CloneSurfFlatRegion( pSfrGeo)))
+                  return false ;
+               else
+                  pSfr->Add( *pSfrGeo) ;
+            }
+         }
+         nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
+      }
+      if ( ! IsNull( pSfr)  &&  pSfr->IsValid()) {
+        // definisco un frame intrinseco dalla superficie
+         Point3d ptCentroid ; pSfr->GetCentroid( ptCentroid) ;
+         Frame3d frLoc ;
+         if ( ! frLoc.Set( ptCentroid, pSfr->GetNormVersor()))
+            return false ;
+        // recupero la PolyLine dal loop esterno in locale al frame creato
+         PolyLine PLLoc ;
+         PtrOwner<ICurve> pExtLoop( pSfr->GetLoop( 0, 0)) ;
+         if ( IsNull( pExtLoop)  ||  ! pExtLoop->IsValid()  ||
+              ! pExtLoop->ApproxWithLines( EPS_SMALL, EPS_ANG_ZERO, ICurve::APL_SPECIAL, PLLoc)  ||
+              ! PLLoc.ToLoc( frLoc))
+            return false ;
+        // calcolo il rettangolo ad area minima
+         Point3d ptFrCenter ; Vector3d vtFrX ;
+         double dDimX, dDimY ;
+         if ( ! PLLoc.GetMinAreaRectangleXY( ptFrCenter, vtFrX, dDimX, dDimY))
+            return false ;
+        // oriento il frame in modo opportuno rispetto all'asse X
+         if ( vtFrX.x < - SQRT1_2)
+            vtFrX.Invert() ;
+         else if ( abs( vtFrX.x) < SQRT1_2  &&  vtFrX.y < - SQRT1_2)
+            vtFrX.Invert() ;
+        // definisco il frame
+         ptFrCenter.ToGlob( frLoc) ;
+         vtFrX.ToGlob( frLoc) ;
+         if ( ! m_Frame.Set( ptFrCenter, pSfr->GetNormVersor(), vtFrX))
+            return false ;
+      }
+   }
+  // se lavorazione come curva di proiezione
+   else if ( m_Params.m_nSubType == SURFFIN_SUB_PROJECT) {
+      ICURVEPOVECTOR vCrv ;
+      int nPathId = m_pGeomDB->GetFirstGroupInGroup( nAuxId) ;
+      while ( nPathId != GDB_ID_NULL) {
+        // recupero la curva (le curve di proiezione)
+         int nCrvId = m_pGeomDB->GetFirstInGroup( nPathId) ;
+         if ( m_pGeomDB->GetGeoType( nCrvId) != CRV_LINE  &&  m_pGeomDB->GetGeoType( nCrvId) != CRV_ARC  &&
+              m_pGeomDB->GetGeoType( nCrvId) != CRV_COMPO  &&  m_pGeomDB->GetGeoType( nCrvId) != CRV_BEZIER)
+            return false ;
+        // recupero la curva
+         const ICurve* pCrv = GetCurve( m_pGeomDB->GetGeoObj( nCrvId)) ;
+         if ( pCrv == nullptr  ||  ! pCrv->IsValid())
+            return false ;
+        // la memorizzo
+         if ( ! vCrv.emplace_back( pCrv->Clone()))
+            return false ;
+         nPathId = m_pGeomDB->GetNextGroup( nPathId) ;
+      }
+      if ( ! vCrv.empty()) {
+         Point3d ptCentroid ; vCrv[0]->GetCentroid( ptCentroid) ;
+         Vector3d vtExtrusion ; vCrv[0]->GetExtrusion( vtExtrusion) ;
+         Frame3d frLoc ;
+         if ( ! frLoc.Set( ptCentroid, vtExtrusion))
+            return false ;
+        // recupero la PolyLine assocuata alla prima curva in locale al frame creato
+         PolyLine PLLoc ;
+         if ( IsNull( vCrv[0])  ||  ! vCrv[0]->IsValid()  ||
+              ! vCrv[0]->ApproxWithLines( EPS_SMALL, EPS_ANG_ZERO, ICurve::APL_SPECIAL, PLLoc)  ||
+              ! PLLoc.ToLoc( frLoc))
+            return false ;
+        // calcolo il rettangolo ad area minima
+         Point3d ptFrCenter ; Vector3d vtFrX ;
+         double dDimX, dDimY ;
+         if ( ! PLLoc.GetMinAreaRectangleXY( ptFrCenter, vtFrX, dDimX, dDimY))
+            return false ;
+         ptFrCenter.ToGlob( frLoc) ;
+         vtFrX.ToGlob( frLoc) ;
+         if ( ! m_Frame.Set( ptFrCenter, vtExtrusion, vtFrX))
+            return false ;
+      }
+   }
+
+  // recupero Theta e Phi correnti
+   double dOldTheta = m_dTheta ;
+   double dOldPhi = m_dPhi ;
+
+   const double ANG_TOL = 10. * EPS_ANG_SMALL ;
+
+  // verifico se presenti parametri Theta e Phi per possibile orientamento utensile in locale al frame corrente
+   m_dTheta = 0. ; m_dPhi = 0. ;
+   string sTiltAngs{} ;
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_TILT_ANGS, sTiltAngs)) {
+      STRVECTOR vsAngs ;
+      if ( Tokenize( sTiltAngs, ",", vsAngs)  &&  ssize( vsAngs) == 2) {
+         double dTheta = 0., dPhi = 0. ;
+         if ( FromString( vsAngs[0], dTheta)  &&  FromString( vsAngs[1], dPhi)) {
+            m_dTheta = dTheta ;
+            m_dPhi = dPhi ;
+         }
+      }
+   }
+
+  // verifico se aggiornare gli angoli
+   if ( ! bRecalc  &&
+        ( ! AreSameFrame( FrOld, m_Frame)  ||  abs( m_dTheta - dOldTheta) > ANG_TOL  ||  abs( m_dPhi - dOldPhi) > ANG_TOL))
+      bRecalc = true ;
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 SurfFinishing::GetSurfacesByIds( SURFLOCALVECTOR& vSrfLoc, SURFLOCALVECTOR& vSrfSuppLoc, Frame3d& frSurf)
@@ -1327,7 +1506,7 @@ SurfFinishing::GetSurfacesByIds( SURFLOCALVECTOR& vSrfLoc, SURFLOCALVECTOR& vSrf
    INTVECTOR vSurfId, vSurfSuppId ;
    GetActiveSurfaces( vSurfId, vSurfSuppId) ;
   // porto tutte le superfici nel riferimento della prima
-   for ( int& nSurfId : vSurfId) {
+   for ( const int& nSurfId : vSurfId) {
        if ( vSrfLoc.empty()) {
           if ( ! m_pGeomDB->GetGlobFrame( nSurfId, frSurf))
              return false ;
@@ -1336,15 +1515,14 @@ SurfFinishing::GetSurfacesByIds( SURFLOCALVECTOR& vSrfLoc, SURFLOCALVECTOR& vSrf
     }
     if ( ! frSurf.IsValid())
        return false ;
-    for ( int& nSrfSuppId : vSurfSuppId)
+    for ( const int& nSrfSuppId : vSurfSuppId)
        vSrfSuppLoc.emplace_back( m_pGeomDB, nSrfSuppId, frSurf) ;
     return true ;
 }
 
 //----------------------------------------------------------------------------
 bool
-SurfFinishing::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool,
-                                    double dRad, double dLen, double& dElev) const
+SurfFinishing::CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dRad, double dLen, double& dElev) const
 {
   // controllo dei parametri
    if ( pSfr == nullptr  ||  ! pSfr->IsValid())
@@ -1461,7 +1639,7 @@ SurfFinishing::SetCAvTlStmForSurfaces( ICAvToolSurfTm* pCAvTlStm, const ISurfFla
    else {
       double dDeltaRad ;
       double dSideAngRad = dToolSideAng * DEGTORAD ;
-      if ( dToolSideAng > 0) {
+      if ( dToolSideAng > 0.) {
          if ( dToolCornRad < EPS_SMALL)
             dDeltaRad = dToolMaxMat * tan( dSideAngRad) ;
          else
@@ -1597,7 +1775,7 @@ SurfFinishing::SetCAvTlStmForSurfaces( ICAvToolSurfTm* pCAvTlStm, const ISurfFla
 
 //---------------------------------------------------------------------------
 bool
-SurfFinishing::EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d& frSurf, const Vector3d& vtTool,
+SurfFinishing::EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d& frSurf, const Vector3d& vtMove,
                                  double dDepth, ISurfFlatRegion* pSfrCnt)
 {
   // controllo dei parametri
@@ -1634,7 +1812,7 @@ SurfFinishing::EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d&
   // determino il frame locale delle superfici analizzando la prima
    Frame3d frPocket ;
    Point3d ptCen ; pSfrCnt->GetCentroid( ptCen) ;
-   frPocket.Set( ptCen, vtTool) ;
+   frPocket.Set( ptCen, vtMove) ;
    frPocket.ToLoc( frSurf) ;
    const double SILH_TOL = 1. ;
    PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
@@ -1688,7 +1866,7 @@ SurfFinishing::EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d&
          pSfrCnt->Clear() ;
          pSfrCnt->CopyFrom( pSfrCntCopy) ;
       }
-     // azzero le proprietà delle curve semplici dei contorni delle regioni ( se 1 lato aperto)
+     // azzero le proprietà delle curve semplici dei contorni delle regioni
       for ( int nC = 0 ; nC < pSfrCnt->GetChunkCount() ; ++ nC) {
          for ( int nL = 0 ; nL < pSfrCnt->GetLoopCount( nC) ; ++ nL) {
             for ( int nCrv = 0 ; ; ++ nCrv) {
@@ -1705,7 +1883,7 @@ SurfFinishing::EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d&
 
 //----------------------------------------------------------------------------
 bool
-SurfFinishing::ProcessCrvCompo( int nPathId, int nPvId, int nClId)
+SurfFinishing::ProcessCrv( int nPathId, int nPvId, int nClId)
 {
   // recupero gruppo per geometria temporanea
    const string GRP_TEMP = "Temp" ;
@@ -1768,8 +1946,12 @@ SurfFinishing::ProcessCrvCompo( int nPathId, int nPvId, int nClId)
    string sPathName ;
    m_pGeomDB->GetName( nPathId, sPathName) ;
 
-  // assegno il versore fresa
+  // assegno il versore fresa e il versore movimento
    Vector3d vtTool = vtExtr ;
+   Vector3d vtToolFrame ;
+   if ( GetLocalToolDir( vtToolFrame))
+      vtTool = vtToolFrame ;
+   Vector3d vtMove = vtExtr ;
 
    // se richiesta lavorazione
    if ( nClId != GDB_ID_NULL) {
@@ -1791,6 +1973,12 @@ SurfFinishing::ProcessCrvCompo( int nPathId, int nPvId, int nClId)
          return false ;
       }
 
+     // l'angolo solido tra la direzione di movimento e la direzione utensile deve essere compreso in 45deg
+      if ( m_dTheta > TILT_ANG_DEG) {
+         m_pMchMgr->SetLastError( 3137, "Error in SurfFinishing : Tool direction too steepy") ;
+         return false ;
+      }
+
      // predispongo l'ambiente di correzione dei percorsi utensili
       PtrOwner<ICAvToolSurfTm> pCAvTlStm( CreateCAvToolSurfTm()) ;
       if ( IsNull( pCAvTlStm)  ||
@@ -1818,7 +2006,7 @@ SurfFinishing::ProcessCrvCompo( int nPathId, int nPvId, int nClId)
 
       switch ( m_Params.m_nSubType) {
       case SURFFIN_SUB_PROJECT :
-         if ( ! AddProjection( pCAvTlStm, vSrfLoc, frSurf, pCrvCompoGDB, vtTool, dDepth, dElev, bSplitArcs))
+         if ( ! AddProjection( pCAvTlStm, vSrfLoc, frSurf, pCrvCompoGDB, vtTool, vtMove, dDepth, dElev, bSplitArcs))
             return false ;
       break ;
       }
@@ -1906,8 +2094,12 @@ SurfFinishing::ProcessSfr( int nPathId, int nPvId, int nClId)
    string sPathName ;
    m_pGeomDB->GetName( nPathId, sPathName) ;
 
-  // assegno il versore fresa
+  // assegno il versore fresa e il versore movimento
    Vector3d vtTool = vtExtr ;
+   Vector3d vtToolFrame ;
+   if ( GetLocalToolDir( vtToolFrame))
+      vtTool = vtToolFrame ;
+   Vector3d vtMove = vtExtr ;
 
   // se richiesta lavorazione
    if ( nClId != GDB_ID_NULL) {
@@ -1950,19 +2142,19 @@ SurfFinishing::ProcessSfr( int nPathId, int nPvId, int nClId)
 
      // calcolo l'elevazione al di sopra della curva
       double dElev = 0. ;
-      if ( ! CalcRegionElevation( pSfrCnt, vtTool, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dElev)) {
+      if ( ! CalcRegionElevation( pSfrCnt, vtExtr, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dElev)) {
          m_pMchMgr->SetLastError( 3135, "Error in SurfFinishing : Calc Region Elvation failed") ;
          return false ;
       }
      // posiziono la superficie a quella quota (top del grezzo)
       if ( dElev > EPS_SMALL) {
-         pSfrCnt->Translate( vtTool * dElev) ;
+         pSfrCnt->Translate( vtExtr * dElev) ;
          dDepth += dElev ;
       }
      // controllo di non scendere al di sotto del grezzo con la depth
       double dInvElev = 0. ;
       pSfrCnt->Invert() ;
-      if ( ! CalcRegionElevation( pSfrCnt, vtTool, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dInvElev)) {
+      if ( ! CalcRegionElevation( pSfrCnt, vtExtr, m_TParams.m_dDiam / 2., m_TParams.m_dLen, dInvElev)) {
          m_pMchMgr->SetLastError( 3135, "Error in SurfFinishing : Calc Region Elvation failed") ;
          return false ;
       }
@@ -1974,7 +2166,14 @@ SurfFinishing::ProcessSfr( int nPathId, int nPvId, int nClId)
          dDepth = dInvElev + dToolDepth ;
       }
 
-     // alla regione di contorno applico un Offset stabilito dal parametro di Overlap
+     // l'angolo solido tra la direzione di movimento e la direzione utensile deve essere compreso in 45deg
+      if ( m_dTheta > TILT_ANG_DEG) {
+         m_pMchMgr->SetLastError( 3137, "Error in SurfFinishing : Tool direction too steepy") ;
+         return false ;
+      }
+
+     // alla regione di contorno applico un Offset stabilito dal parametro di Overlap.
+     // NB. Questo bordo tiene conto della direzione utensile
       if ( ! pSfrCnt->Offset( m_Params.m_dOverlap, ICurve::OFF_FILLET)) {
          m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
          return false ;
@@ -2018,7 +2217,7 @@ SurfFinishing::ProcessSfr( int nPathId, int nPvId, int nClId)
       if ( bSkipMaxDown  &&  m_Params.m_nSubType != SURFFIN_SUB_Z_CONST  &&  m_Params.m_nSubType != SURFFIN_SUB_PENCIL) {
          PtrOwner<ISurfFlatRegion> pSfrMaxDown( CloneSurfFlatRegion( pSfrCnt)) ;
          if ( IsNull( pSfrMaxDown)  ||  ! pSfrMaxDown->IsValid()  ||
-              ! EraseMaxDownSurf( vSrfLoc, frSurf, vtTool, dDepth, pSfrMaxDown)) {
+              ! EraseMaxDownSurf( vSrfLoc, frSurf, vtMove, dDepth, pSfrMaxDown)) {
             m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
             return false ;
          }
@@ -2068,19 +2267,19 @@ SurfFinishing::ProcessSfr( int nPathId, int nPvId, int nClId)
 
       switch ( m_Params.m_nSubType) {
       case SURFFIN_SUB_ZIGZAG :
-         if ( ! AddZigZag( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs))
+         if ( ! AddZigZag( pCAvTlStm, frSurf, pSfrCnt, vtTool, vtMove, dDepth, dElev, bSplitArcs))
             return false ;
          break ;
       case SURFFIN_SUB_ONEWAY :
-         if ( ! AddOneWay( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs))
+         if ( ! AddOneWay( pCAvTlStm, frSurf, pSfrCnt, vtTool, vtMove, dDepth, dElev, bSplitArcs))
             return false ;
          break ;
       case SURFFIN_SUB_SPIRALIN :
-         if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs, true))
+         if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, vtMove, dDepth, dElev, bSplitArcs, true))
             return false ;
          break ;
       case SURFFIN_SUB_SPIRALOUT :
-         if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, dDepth, dElev, bSplitArcs, false))
+         if ( ! AddSpiral( pCAvTlStm, frSurf, pSfrCnt, vtTool, vtMove, dDepth, dElev, bSplitArcs, false))
             return false ;
          break ;
       case SURFFIN_SUB_Z_CONST :
@@ -2088,7 +2287,7 @@ SurfFinishing::ProcessSfr( int nPathId, int nPvId, int nClId)
             return false ;
          break ;
       case SURFFIN_SUB_OPTIMAL :
-         if ( ! AddOptimal( pCAvTlStm, vSrfLoc, frSurf, pSfrCnt, pSfrCntOrig, vtTool, dDepth, dElev, bSplitArcs))
+         if ( ! AddOptimal( pCAvTlStm, vSrfLoc, frSurf, pSfrCnt, pSfrCntOrig, vtTool, vtMove, dDepth, dElev, bSplitArcs))
             return false ;
          break ;
       case SURFFIN_SUB_PENCIL :
@@ -2218,7 +2417,7 @@ SurfFinishing::GetActiveSurfaces( INTVECTOR& vSurfId, INTVECTOR& vSurfSuppId) co
 //----------------------------------------------------------------------------
 bool
 SurfFinishing::CorrectPathByCollision( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Vector3d& vtTool,
-                                       double dDepth, ICRVCOMPOPOVECTOR& vpCrvs)
+                                       const Vector3d& vtMove, double dDepth, ICRVCOMPOPOVECTOR& vpCrvs)
 {
   // se non ho curve, non faccio nulla
    if ( vpCrvs.empty())
@@ -2228,13 +2427,12 @@ SurfFinishing::CorrectPathByCollision( ICAvToolSurfTm* pCAvTlStm, const Frame3d&
    if ( pCAvTlStm != nullptr) {
 
      // porto i dati geometrici in locale alle superfici
-      Vector3d vtAxL = vtTool ;
-      vtAxL.ToLoc( frSurf) ;
-      Vector3d vtMoveL = vtAxL ;
+      Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;         // direzione utensile
+      Vector3d vtMoveL = GetToLoc( vtMove, frSurf) ;         // direzione risalita per collisione
 
      // scorro le curve
       double dProgCoeff = 1. / max( int( vpCrvs.size()), 1) ;
-      for ( int i = 0 ; i < int( vpCrvs.size()) ; ++ i) {
+      for ( int i = 0 ; i < ssize( vpCrvs) ; ++ i) {
 
         // controllo che la curva sia valida
          if ( IsNull( vpCrvs[i])  ||  ! vpCrvs[i]->IsValid())
@@ -2252,18 +2450,18 @@ SurfFinishing::CorrectPathByCollision( ICAvToolSurfTm* pCAvTlStm, const Frame3d&
         // porto nel riferimento delle superfici
          PL.ToLoc( frSurf) ;
         // traslo della lunghezza utensile diminuita dell'affondamento
-         PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
+         PL.Translate( vtToolL * m_TParams.m_dLen - vtMoveL * dDepth) ;
         // eseguo CAv
-         if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox, ( i + 1) * dProgCoeff))
+         if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtToolL, vtMoveL, m_Params.m_dApprox, ( i + 1) * dProgCoeff))
             return false ;
         // contro-traslo della lunghezza utensile
-         PL.Translate( - vtAxL * m_TParams.m_dLen) ;
+         PL.Translate( - vtToolL * m_TParams.m_dLen) ;
         // riporto la polilinea nel riferimento della curva
          PL.ToGlob( frSurf) ;
         // elimino i punti allineati
          PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
         // creo una curva composita a partire dalla polilinea
-         PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ;
+         PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
          if ( IsNull( pCompo)  ||  ! pCompo->FromPolyLine( PL))
             return false ;
         // sostituisco la vecchia curva con la nuova
@@ -2277,11 +2475,11 @@ SurfFinishing::CorrectPathByCollision( ICAvToolSurfTm* pCAvTlStm, const Frame3d&
 //----------------------------------------------------------------------------
 bool
 SurfFinishing::AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
-                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
+                          const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs)
 {
   // calcolo lo ZigZag
    ICRVCOMPOPOVECTOR vpCrvs ;
-   if ( ! CalcPocketing( pSfrCnt, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, m_Params.m_dSideAngle, 5.,
+   if ( ! CalcPocketing( pSfrCnt, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, GetLocalSideAngle(), 5.,
                          POCKET_ZIGZAG, false, false, m_Params.m_bInvert, true, true, false, false, P_INVALID, nullptr, true, m_Params.m_dSideStep,
                          GetLeadInType(), m_Params.m_dLiTang, 0., GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., false, vpCrvs)) {
       m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
@@ -2289,13 +2487,13 @@ SurfFinishing::AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, cons
    }
 
   // correggo i percorsi mediante collisione con le supercici
-   if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, dDepth, vpCrvs)) {
+   if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, vtMove, dDepth, vpCrvs)) {
       m_pMchMgr->SetLastError( 3134, "Error in SurfFinishing : Projecting Path failed") ;
       return false ;
    }
 
   // aggiungo i percorsi di finitura calcolati
-   if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vpCrvs, vtTool, dElev, dDepth, bSplitArcs))
+   if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vpCrvs, vtTool, vtMove, dElev, dDepth, bSplitArcs))
       return false ;
 
    return true ;
@@ -2304,12 +2502,11 @@ SurfFinishing::AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, cons
 //----------------------------------------------------------------------------
 bool
 SurfFinishing::AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
-                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
+                          const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs)
 {
-
   // calcolo OneWay
    ICRVCOMPOPOVECTOR vpCrvs ;
-   if ( ! CalcPocketing( pSfrCnt, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, m_Params.m_dSideAngle, 5.,
+   if ( ! CalcPocketing( pSfrCnt, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, GetLocalSideAngle(), 5.,
                          POCKET_ONEWAY, false, false, m_Params.m_bInvert, true, true, false, false, P_INVALID, nullptr, true, m_Params.m_dSideStep,
                          GetLeadInType(), m_Params.m_dLiTang, 0., GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., false, vpCrvs)) {
       m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
@@ -2317,13 +2514,13 @@ SurfFinishing::AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, cons
    }
 
   // correggo i percorsi mediante collisione con le supercici
-   if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, dDepth, vpCrvs)) {
+   if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, vtMove, dDepth, vpCrvs)) {
       m_pMchMgr->SetLastError( 3134, "Error in SurfFinishing : Projecting Path failed") ;
       return false ;
    }
 
   // aggiungo i percorsi di finitura calcolati
-   if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vpCrvs, vtTool, dElev, dDepth, bSplitArcs))
+   if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vpCrvs, vtTool, vtMove, dElev, dDepth, bSplitArcs))
       return false ;
 
    return true ;
@@ -2332,12 +2529,12 @@ SurfFinishing::AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, cons
 //----------------------------------------------------------------------------
 bool
 SurfFinishing::AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
-                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut)
+                          const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut)
 {
   // calcolo la spirale
    int nType = ( bInVsOut ? POCKET_SPIRALIN : POCKET_SPIRALOUT) ;
    ICRVCOMPOPOVECTOR vpCrvs ;
-   if ( ! CalcPocketing( pSfrCnt, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, m_Params.m_dSideAngle, 5.,
+   if ( ! CalcPocketing( pSfrCnt, m_TParams.m_dDiam / 2., 0., m_Params.m_dSideStep, GetLocalSideAngle(), 5.,
                          nType, false, false, m_Params.m_bInvert, true, true, false, false, P_INVALID, nullptr, true, m_Params.m_dSideStep,
                          GetLeadInType(), m_Params.m_dLiTang, 0., GetLeadOutType(), m_Params.m_dLoTang, false, 0., 0., false, vpCrvs)) {
       m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
@@ -2345,13 +2542,13 @@ SurfFinishing::AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, cons
    }
 
   // correggo i percorsi mediante collisione con le supercici
-   if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, dDepth, vpCrvs)) {
+   if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, vtMove, dDepth, vpCrvs)) {
       m_pMchMgr->SetLastError( 3134, "Error in SurfFinishing : Projecting Path failed") ;
       return false ;
    }
 
   // aggiungo i percorsi di finitura calcolati
-   if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vpCrvs, vtTool, dElev, dDepth, bSplitArcs))
+   if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vpCrvs, vtTool, vtMove, dElev, dDepth, bSplitArcs))
       return false ;
 
    return true ;
@@ -2359,9 +2556,8 @@ SurfFinishing::AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, cons
 
 //----------------------------------------------------------------------------
 bool
-SurfFinishing::GetZConstQuotesInsideSfrParallelToTool( const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
-                                                       const ISurfFlatRegion* pSfr, const Vector3d& vtTool,
-                                                       set<double>& setZAmbiguos) const
+SurfFinishing::GetZConstQuotesInsideSfrParallelToTool( const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfr,
+                                                       const Vector3d& vtTool, set<double>& setZAmbiguos) const
 {
   // controllo dei parametri
    setZAmbiguos.clear() ;
@@ -2669,9 +2865,8 @@ SurfFinishing::CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SU
 
 //----------------------------------------------------------------------------
 bool
-SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf,
-                                  vector<ICRVCOMPOPOVECTOR>& vCrvCompo, const Vector3d& vtTool, const ISurfFlatRegion* pSfr,
-                                  double dDepth, ICRVCOMPOPOVECTOR& vCrvPath) const
+SurfFinishing::CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, vector<ICRVCOMPOPOVECTOR>& vCrvCompo,
+                                  const Vector3d& vtTool, const ISurfFlatRegion* pSfr, double dDepth, ICRVCOMPOPOVECTOR& vCrvPath) const
 {
   // funzione per collegare le curve trovate creando quindi i percorsi di lavoro
   // NB. Nel primo TempParam deve essere memorizzata la distanza del piano della curva con il piano della Sfr
@@ -3225,9 +3420,9 @@ SurfFinishing::AddZConst( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrf
   // aggiusto la regione a seconda dei parametri e la porto nel frame locale delle superfici
   // NB. Per rendere questa superficie coerente con le superfici degli altri tipi di lavorazione, devo effettuare un ControOffset
   //     del raggio utensile. Se la lavorazione fosse a ZigZag le curve si trovano all'interno di questa regione del raggio utensile
-  //     ( questo passaggio è calcolato implicitamente dalla lavorazione di Pocketing ZigZag). Nel caso di Lavorazione a ZLevel bissogna
+  //     ( questo passaggio è calcolato implicitamente dalla lavorazione di Pocketing ZigZag). Nel caso di Lavorazione a ZLevel bisogna
   //     aggiungere questo passaggio in modo tale che dalla curva originaria Offsettata del parametro di Overlap, tutto l'utensile stia
-  //     al suo interno. Quindi le curve all'esterno della pSfrClass ( pSfrCnt è già estesa del parametro Overlap)
+  //     al suo interno.
    PtrOwner<ISurfFlatRegion> pSfrClass( pSfrCnt->CreateOffsetSurf( - m_TParams.m_dDiam / 2. + EPS_SMALL, ICurve::OFF_FILLET)) ;
    if ( IsNull( pSfrClass)  ||  ! pSfrClass->IsValid()  ||  ! pSfrClass->ToLoc( frSurf))
       return false ;
@@ -3297,11 +3492,11 @@ SurfFinishing::AddZConst( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrf
    ExeProcessEvents( 90, 0) ;
 
   // porto tutti i percorsi in Globale
-   for ( int i = 0 ; i < int( vCrvPath.size()) ; ++ i)
+   for ( int i = 0 ; i < ssize( vCrvPath) ; ++ i)
       vCrvPath[i]->ToGlob( frSurf) ;
 
   // aggiungo i percorsi di finitura calcolati
-   if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vCrvPath, vtTool, dElev, dDepth, bSplitArcs))
+   if ( ! AddFinishing( pSfrCnt, pCAvTlStm, frSurf, vCrvPath, vtTool, vtTool, dElev, dDepth, bSplitArcs))
       return false ;
 
    return true ;
@@ -5035,7 +5230,7 @@ SurfFinishing::WorkPencilCurves( const ICRVCOMPOPOVECTOR& vCrvCompo, const ISurf
    for ( const auto& pCrvCompo : vCrvCompoInSfr) {
       if ( pCrvCompo != nullptr  &&  pCrvCompo->IsValid()) {
          pCrvCompo->ToGlob( frSurf) ;
-         if ( ! AddProjection( pCAvTlStm, vSrfLoc, frSurf, pCrvCompo, vtTool, dDepth, dElev, bSplitArcs))
+         if ( ! AddProjection( pCAvTlStm, vSrfLoc, frSurf, pCrvCompo, vtTool, vtTool, dDepth, dElev, bSplitArcs))
             return false ;
       }
    }
@@ -6165,7 +6360,7 @@ SurfFinishing::CalcOptimalZigZagRegion( const ISurfFlatRegion* pSfrCntLoc, const
 bool
 SurfFinishing::AddOptimal( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
                            const ISurfFlatRegion* pSfrCnt, const ISurfFlatRegion* pSfrCntExt,
-                           const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
+                           const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs)
 {
   // se entrambe le regioni non sono valide, non faccio nulla
    if ( ( pSfrCnt == nullptr  ||  ! pSfrCnt->IsValid())  &&  ( pSfrCntExt == nullptr  ||  ! pSfrCntExt->IsValid()))
@@ -6247,7 +6442,7 @@ SurfFinishing::AddOptimal( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSr
    for ( int i = 0 ; i < ssize( vPaths) ; ++ i)
       vCrvCompo[i].Set( Release( vPaths[i].pCrvPath)) ;
    if ( ! AddFinishing( ( pSfrCntExt == nullptr  ||  ! pSfrCntExt->IsValid()) ? pSfrCnt : pSfrCntExt,
-                        pCAvTlStm, frSurf, vCrvCompo, vtTool, dElev, dDepth, bSplitArcs))
+                        pCAvTlStm, frSurf, vCrvCompo, vtTool, vtMove, dElev, dDepth, bSplitArcs))
       return false ;
 
    return true ;
@@ -6256,7 +6451,8 @@ SurfFinishing::AddOptimal( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSr
 //----------------------------------------------------------------------------
 bool
 SurfFinishing::AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
-                              const ICurveComposite* pCrvCompo, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
+                              const ICurveComposite* pCrvCompo, const Vector3d& vtTool, const Vector3d& vtMove, double dDepth,
+                              double dElev, bool bSplitArcs)
 {
   // controllo che la curva sia valida
    if ( pCrvCompo == nullptr  ||  ! pCrvCompo->IsValid())
@@ -6265,7 +6461,7 @@ SurfFinishing::AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR&
   // definisco un sistema di riferimento locale alla curva
    Point3d ptStart ; pCrvCompo->GetStartPoint( ptStart) ;
    Frame3d frLoc ;
-   if ( ! frLoc.Set( ptStart, vtTool))
+   if ( ! frLoc.Set( ptStart, vtMove))
       return false ;
   // definisco il frame inverso per il calcolo del Box3d
    Frame3d frLocInv = frLoc ;
@@ -6278,7 +6474,7 @@ SurfFinishing::AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR&
    ICRVCOMPOPOVECTOR vCrvToProj ;   // vettore delle curve da proiettare sulla superficie
 
   // scorro il vettore di superfici selezionate
-   for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i) {
+   for ( int i = 0 ; i < ssize( vSrfLoc) ; ++ i) {
      // recupero la superficie ( TriMesh o Bezier)
       const ISurf* pSurf = GetSurf( vSrfLoc[i].Get()) ;
       if ( pSurf == nullptr  ||  ! pSurf->IsValid())
@@ -6326,7 +6522,7 @@ SurfFinishing::AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR&
      // definisco i dati di calcolo della Silhouette
       const double SILH_TOL = 1.0 ;
       CISURFTMPVECTOR vSurf ; vSurf.reserve( vpStm.size()) ;
-      for ( int i = 0; i < int( vpStm.size()) ; ++ i)
+      for ( int i = 0; i < ssize( vpStm) ; ++ i)
          vSurf.emplace_back( vpStm[i]) ;
       PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
       if ( IsNull( pCavParSilh)  ||  ! pCavParSilh->SetData( vSurf, frLoc, SILH_TOL))
@@ -6336,23 +6532,23 @@ SurfFinishing::AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR&
       if ( ! pCavParSilh->GetSilhouette( BBox3Loc.GetMin().z , vPL))
          return false ;
      // creo la regione piana dalle PolyLine ricavate dalla Silhouette
+      const double SILH_ARC_TOL = 0.1 * SILH_TOL ;
+      const double SILH_ARC_FEA_MAX = 100. ;
       SurfFlatRegionByContours SfrMaker ;
-      for ( auto& PL : vPL) {
+      for ( const PolyLine& PL : vPL) {
         // recupero la curva dalla silhouette
          PtrOwner<ICurveComposite> pSilCrv( CreateCurveComposite()) ;
          if ( IsNull( pSilCrv))
             return false ;
          pSilCrv->FromPolyLine( PL) ;
         // approssimo con archi
-         const double SILH_ARC_TOL = 0.1 * SILH_TOL ;
-         const double SILH_ARC_FEA_MAX = 100. ;
          PolyArc PA ;
          if ( pSilCrv->ApproxWithArcsEx( SILH_ARC_TOL, ANG_TOL_STD_DEG, SILH_ARC_FEA_MAX, PA)) {
             PtrOwner<ICurveComposite> pTempCrv( CreateCurveComposite()) ;
             if ( ! IsNull( pTempCrv)  &&
                  pTempCrv->FromPolyArc( PA)  &&
-                 pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG)  &&
-                 pTempCrv->MergeCurves( SILH_ARC_TOL / 2, ANG_TOL_STD_DEG))
+                 pTempCrv->RemoveSmallDefects( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG)  &&
+                 pTempCrv->MergeCurves( SILH_ARC_TOL / 2., ANG_TOL_STD_DEG))
                pSilCrv.Set( pTempCrv) ;
          }
         // aggiungo per regione
@@ -6365,19 +6561,23 @@ SurfFinishing::AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR&
       PtrOwner<ISurfFlatRegion> pSfrSil( SfrMaker.GetSurf()) ;
       if ( ! IsNull( pSfrSil)  &&  pSfrSil->IsValid()) {
         // Offset alla Silhouette
-         double dPockRadOffs = m_TParams.m_dDiam - m_Params.m_dSideStep - m_Params.m_dOverlap ;
+         double dPockRadOffs = SILH_ARC_TOL ;
          pSfrSil->Offset( dPockRadOffs, ICurve::OFF_CHAMFER) ;
+        // aggiungo un Offset del raggio utensile sottratto di una leggera quantità per consentire ai percorsi di essere
+        // all'interno di una regione che consente all'utensile di avere una collisione con normale di contatto circa
+        // perpendicolare rispetto all'estrusione
+         pSfrSil->Offset( m_TParams.m_dDiam / 2. - SILH_TOL, ICurve::OFF_FILLET) ;
         // porto la curva e la Silhouette nel frame locale per classificazione ( alla stezza zLoc)
          PtrOwner<ICurveComposite> pCrvCompoCL( CloneCurveComposite( pCrvCompo)) ;
          if ( IsNull( pCrvCompoCL)  ||  ! pCrvCompoCL->IsValid())
             return false ;
-         pCrvCompoCL->Translate( BBox3Loc.GetMin().z * vtTool) ;
+         pCrvCompoCL->Translate( BBox3Loc.GetMin().z * vtMove) ;
          pCrvCompoCL->ToLoc( frLoc) ;
          pSfrSil->ToLoc( frLoc) ;
         // classifico
          CRVCVECTOR ccClass ;
          if ( pSfrSil->GetCurveClassification( *pCrvCompoCL, EPS_SMALL, ccClass)) {
-            for ( int i = 0 ; i < int( ccClass.size()) ; ++ i) {
+            for ( int i = 0 ; i < ssize( ccClass) ; ++ i) {
               // se tratto di curva interno
                if ( ccClass[i].nClass != CRVC_OUT) {
                  // recupero la curva
@@ -6392,18 +6592,17 @@ SurfFinishing::AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR&
    else
       vCrvToProj.emplace_back( CloneCurveComposite( pCrvCompo)) ;
 
-
   // correggo i percorsi mediante collisione con le supercici
-   if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, dDepth, vCrvToProj)) {
+   if ( ! CorrectPathByCollision( pCAvTlStm, frSurf, vtTool, vtMove, dDepth, vCrvToProj)) {
       m_pMchMgr->SetLastError( 3134, "Error in SurfFinishing : Projecting Path failed") ;
       return false ;
    }
 
   // aggiungo il percorso di finitura calcolati
-   for ( int i = 0 ; i < int( vCrvToProj.size()) ; ++ i) {
+   for ( int i = 0 ; i < ssize( vCrvToProj) ; ++ i) {
       ICRVCOMPOPOVECTOR vCrvSingle ;
       vCrvSingle.emplace_back( Release( vCrvToProj[i])) ;
-      if ( ! AddFinishing( nullptr, pCAvTlStm, frSurf, vCrvSingle, vtTool, dElev, dDepth, bSplitArcs))
+      if ( ! AddFinishing( nullptr, pCAvTlStm, frSurf, vCrvSingle, vtTool, vtMove, dElev, dDepth, bSplitArcs))
          return false ;
    }
 
@@ -6539,8 +6738,8 @@ SurfFinishing::GetLeadInType( void) const
 
 //----------------------------------------------------------------------------
 bool
-SurfFinishing::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool,
-                                const Vector3d& vtNorm, Point3d& ptP1) const
+SurfFinishing::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, const Vector3d& vtNorm,
+                                Point3d& ptP1) const
 {
   // Assegno tipo e parametri
    int nType = GetLeadInType() ;
@@ -6683,8 +6882,8 @@ SurfFinishing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Po
 
 //----------------------------------------------------------------------------
 bool
-SurfFinishing::GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Point3d& ptStart,
-                                 const Point3d& ptEnd, const Vector3d& vtInit, const Vector3d& vtTool,
+SurfFinishing::GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Point3d& ptStart, const Point3d& ptEnd,
+                                 const Vector3d& vtInit, const Vector3d& vtTool, const Vector3d& vtMove,
                                  bool bLeadInVsOut, Point3d& ptP1) const
 {
   // se inizio e fine coincidono, non faccio nulla
@@ -6696,6 +6895,8 @@ SurfFinishing::GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSur
    Point3d ptEndL = GetToLoc( ptEnd, frSurf) ;
    Vector3d vtInitL = GetToLoc( vtInit, frSurf) ;
    Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
+   Vector3d vtMoveL = GetToLoc( vtMove, frSurf) ;
+
   // porto i punti dal tip al naso mandrino
    ptStartL += vtToolL * m_TParams.m_dLen ;
    ptEndL += vtToolL * m_TParams.m_dLen ;
@@ -6767,11 +6968,11 @@ SurfFinishing::GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSur
    }
 
   // se non ho inserito almeno 2 punti nella lista, non faccio nulla
-   if ( int( lstPntU.size()) < 2)
+   if ( ssize( lstPntU) < 2)
       return true ; // per sicurezza...
 
   // eseguo controllo collisione
-   if ( ! pCAvTlStm->TestPath( lstPntU, vtToolL, vtToolL, m_Params.m_dApprox, 0.))
+   if ( ! pCAvTlStm->TestPath( lstPntU, vtToolL, vtMoveL, m_Params.m_dApprox, 0.))
       return false ;
 
   // cerco l'ultimo punto non spostato per evitare collisione
@@ -6779,7 +6980,7 @@ SurfFinishing::GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSur
    auto currPU = lstPntU.begin() ;
    while ( ! bFound  &&  currPU != lstPntU.end()) {
       auto nextPU = next( currPU) ;
-      if ( nextPU == lstPntU.end()  ||  nextPU->second > m_Params.m_dApprox){
+      if ( nextPU == lstPntU.end()  ||  nextPU->second > m_Params.m_dApprox) {
          bFound = true ;
          ptP1 = GetToGlob( currPU->first - vtToolL * ( m_TParams.m_dLen + currPU->second), frSurf) ;
       }
@@ -6791,8 +6992,9 @@ SurfFinishing::GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSur
 
 //----------------------------------------------------------------------------
 bool
-SurfFinishing::GetLinkFromPaths( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtTool, const ISurfFlatRegion* pSfrCnt,
-                                 double dDepth, double dSafeZ, ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, ICurveComposite* pCrvLink) const
+SurfFinishing::GetLinkFromPaths( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtTool, const Vector3d& vtMove,
+                                 const ISurfFlatRegion* pSfrCnt, double dDepth, double dSafeZ, ICAvToolSurfTm* pCAvTlStm,
+                                 const Frame3d& frSurf, ICurveComposite* pCrvLink) const
 {
   // controllo dei parametri
    if ( pCAvTlStm == nullptr  ||  pCrvLink == nullptr  ||  pSfrCnt == nullptr)
@@ -6806,27 +7008,28 @@ SurfFinishing::GetLinkFromPaths( const Point3d& ptStart, const Point3d& ptEnd, c
    Point3d ptEndL = GetToLoc( ptEnd, frSurf) ;
    Point3d ptStartL = GetToLoc( ptStart, frSurf) ;
    Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
-  // porto i punti dal tip al naso mandrino
+   Vector3d vtMoveL = GetToLoc( vtMove, frSurf) ;
+  // porto i punti sul top dell'utensile
    ptEndL += vtToolL * m_TParams.m_dLen ;
    ptStartL += vtToolL * m_TParams.m_dLen ;
 
   // mi assicuro che il collegamento non interferica con la superficie
    PNTULIST lstPntU{ { ptEndL, 0.}, { ptStartL, 1.}} ;
-   if ( ! pCAvTlStm->TestPath( lstPntU, vtToolL, vtToolL, m_Params.m_dApprox, 0.))
+   if ( ! pCAvTlStm->TestPath( lstPntU, vtToolL, vtMoveL, m_Params.m_dApprox, 0.))
       return false ;
 
   // determino un piano al di sotto della lavorazione, orientato come pSfrCnt
   // --- serve per individuare la quota ZLocMax per i Link tra le curve di finitura
    Point3d ptC ; pSfrCnt->GetCentroid( ptC) ;
    Plane3d plZLocMin ;
-   if ( ! plZLocMin.Set( ptC, vtTool))
+   if ( ! plZLocMin.Set( ptC, vtMove))
       return false ;
-   plZLocMin.Translate( - vtTool * 10 * ( m_TParams.m_dLen + abs( dDepth))) ;
+   plZLocMin.Translate( - vtMove * 10. * ( m_TParams.m_dLen + abs( dDepth))) ;
 
   // determino il punto con ZLocale più alta
    Point3d ptZMax = ptEnd ;
    double dZMax = 0. ;
-   for ( auto& ptU : lstPntU) {
+   for ( const POINTU& ptU : lstPntU) {
       Point3d ptUGlob = GetToGlob( ptU.first - vtToolL * m_TParams.m_dLen, frSurf) ;
       double dCurrZ = DistPointPlane( ptUGlob, plZLocMin) ;
       if ( dCurrZ > dZMax) {
@@ -6836,13 +7039,13 @@ SurfFinishing::GetLinkFromPaths( const Point3d& ptStart, const Point3d& ptEnd, c
    }
 
   // determino elevazione sopra a ptEnd
-   double dEndElev = dSafeZ + abs( ( ptZMax - ptEnd) * vtTool) ;
-   double dStartElev = dSafeZ + abs( ( ptZMax - ptStart) * vtTool) ;
+   double dEndElev = dSafeZ + abs( ( ptZMax - ptEnd) * vtMove) ;
+   double dStartElev = dSafeZ + abs( ( ptZMax - ptStart) * vtMove) ;
 
   // definisco il collegamento
    pCrvLink->AddPoint( ptEnd) ;
-   pCrvLink->AddLine( ptEnd + vtTool * dEndElev) ;
-   pCrvLink->AddLine( ptStart + vtTool * dStartElev) ;
+   pCrvLink->AddLine( ptEnd + vtMove * dEndElev) ;
+   pCrvLink->AddLine( ptStart + vtMove * dStartElev) ;
    pCrvLink->AddLine( ptStart) ;
 
    return true ;
@@ -6850,18 +7053,19 @@ SurfFinishing::GetLinkFromPaths( const Point3d& ptStart, const Point3d& ptEnd, c
 
 //----------------------------------------------------------------------------
 bool
-SurfFinishing::GetSurfaceNormalAtPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf,
-                                        const Point3d& ptTool, const Vector3d& vtTool, Vector3d& vtNorm) const
+SurfFinishing::GetSurfaceNormalAtPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Point3d& ptTool, const Vector3d& vtTool,
+                                        const Vector3d& vtMove, Vector3d& vtNorm) const
 {
-  // porto il punto e il versore nel riferimento superficie
+  // porto il punto e i versori nel riferimento superficie
    Point3d ptToolL = GetToLoc( ptTool, frSurf) ;
    Vector3d vtToolL = GetToLoc( vtTool, frSurf) ;
+   Vector3d vtMoveL = GetToLoc( vtMove, frSurf) ;
   // porto i punti dal tip al naso mandrino
    ptToolL += vtToolL * m_TParams.m_dLen ;
   // affondo di poco il punto per ricavare ultima superficie di contatto e sua normale
    double dMove ;
    Vector3d vtNormL ;
-   if ( ! pCAvTlStm->TestPosition( ptToolL - vtToolL, vtToolL, vtToolL, dMove, &vtNormL)  ||  dMove < EPS_SMALL)
+   if ( ! pCAvTlStm->TestPosition( ptToolL - vtToolL, vtToolL, vtMoveL, dMove, &vtNormL)  ||  dMove < EPS_SMALL)
       return false ;
   // porto la normale in globale
    vtNorm = GetToGlob( vtNormL, frSurf) ;
@@ -6898,7 +7102,7 @@ SurfFinishing::GetRadiusForStartEndElevation( void) const
 //----------------------------------------------------------------------------
 bool
 SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ICRVCOMPOPOVECTOR& vCrvCompo,
-                             const Vector3d& vtTool, double dElev, double dDepth, bool bSplitArcs)
+                             const Vector3d& vtTool, const Vector3d& vtMove, double dElev, double dDepth, bool bSplitArcs)
 {
   // se non ho curve, non faccio nulla
    if ( vCrvCompo.empty())
@@ -6907,7 +7111,7 @@ SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCA
    if ( pCAvTlStm == nullptr)
       return false ;
   // tutte le curve devono essere valide e ben definite
-   for ( const auto& pMCrv : vCrvCompo) {
+   for ( const PtrOwner<ICurveComposite>& pMCrv : vCrvCompo) {
       if ( pMCrv == nullptr  ||  ! pMCrv->IsValid())
          return false ;
    }
@@ -6935,7 +7139,7 @@ SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCA
    double dStElev = dElev ;
    Point3d ptStart, ptP1 ;
    Vector3d vtStart ;
-   for ( int nCrv = 0 ; nCrv < int( vCrvCompo.size()) ; ++ nCrv) {
+   for ( int nCrv = 0 ; nCrv < ssize( vCrvCompo) ; ++ nCrv) {
 
       #if ENABLE_LINK_DEBUG
          int nIdCrv = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayCurve, CloneCurveComposite( vCrvCompo[nCrv])) ;
@@ -6960,9 +7164,9 @@ SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCA
             pCurve->GetStartDir( vtStart) ;
            // determino normale della superficie sul punto iniziale
             Vector3d vtNorm ;
-            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) {
+            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtMove, vtNorm)) {
                Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ;
-               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm))
+               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtMove, vtNorm))
                   vtNorm = V_NULL ;
             }
            // determino inizio attacco
@@ -6978,7 +7182,7 @@ SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCA
                m_pGeomDB->SetMaterial( nPtId, AQUA) ;
             #endif
            // eventuale correzione inizio attacco per evitare interferenze
-            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptP1, ptStart, vtStart, vtTool, true, ptP1))
+            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptP1, ptStart, vtStart, vtTool, vtMove, true, ptP1))
                return false ;
             #if ENABLE_LINK_DEBUG
                pt->Set( ptP1) ;
@@ -6986,7 +7190,7 @@ SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCA
                m_pGeomDB->SetMaterial( nPtId, TEAL) ;
             #endif
            // determino elevazione su inizio attacco
-            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
+            if ( ! GetElevation( m_nPhase, ptStart - 10. * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtMove, dStElev))
                dStElev = dElev ;
             dStElev -= ( ptP1 - ptStart) * vtTool ;
            // --- approccio globale al punto iniziale
@@ -7026,12 +7230,12 @@ SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCA
             Point3d ptEnd ; pCurve->GetEndPoint( ptEnd) ;
             Vector3d vtEnd ; pCurve->GetEndDir( vtEnd) ;
            // --- se ultima entità in assoluto
-            if ( nCrv == int( vCrvCompo.size()) - 1) {
+            if ( nCrv == ssize( vCrvCompo) - 1) {
               // determino normale della superficie sul punto finale
                Vector3d vtNorm ;
-               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
+               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtMove, vtNorm)) {
                   Point3d ptStart ; pCurve->GetStartPoint( ptStart) ;
-                  if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm))
+                  if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtMove, vtNorm))
                      vtNorm = V_NULL ;
                }
               // determino fine uscita
@@ -7047,7 +7251,7 @@ SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCA
                   m_pGeomDB->SetMaterial( nPtId, AQUA) ;
                #endif
               // eventuale correzione fine uscita per evitare interferenze
-               if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtEnd, vtTool, false, ptP1))
+               if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtEnd, vtTool, vtMove, false, ptP1))
                   return false ;
                #if ENABLE_LINK_DEBUG
                   pt->Set( ptP1) ;
@@ -7062,7 +7266,7 @@ SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCA
                }
               // determino elevazione su fine uscita
                double dEndElev ;
-               if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
+               if ( ! GetElevation( m_nPhase, ptEnd - 10. * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                   dEndElev = dElev ;
                dEndElev -= ( ptP1 - ptEnd) * vtTool ;
               // aggiungo retroazione finale
@@ -7081,7 +7285,7 @@ SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCA
               // definisco il collegamento tra i due percorsi
                PtrOwner<ICurveComposite> pCrvLink( CreateCurveComposite()) ;
                if ( IsNull( pCrvLink)  ||
-                    ! GetLinkFromPaths( ptStart, ptEnd, vtTool, pSfrCnt, dDepth, dSafeZ, pCAvTlStm, frSurf, pCrvLink))
+                    ! GetLinkFromPaths( ptStart, ptEnd, vtTool, vtMove, pSfrCnt, dDepth, dSafeZ, pCAvTlStm, frSurf, pCrvLink))
                   return false ;
                #if ENABLE_LINK_DEBUG
                   int nIdLink = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nLayLink, CloneCurveComposite( pCrvLink)) ;
@@ -7099,3 +7303,52 @@ SurfFinishing::AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCA
    ExeProcessEvents( 100, 0) ;
    return true ;
 }
+
+//----------------------------------------------------------------------------
+double
+SurfFinishing::GetLocalSideAngle() const
+{
+  // se non ho un frame Valido, allora è rispetto all'asse x globale
+   if ( ! m_Frame.IsValid())
+      return m_Params.m_dSideAngle ;
+
+  // calcolo l'angolo tra l'asse x generale e l'asse x locale
+  // NB. Il frame Locale è sempre orientato con il versore Z perpendicolare alle curve di Finitura selezionate
+   double dExtraSideAng = 0. ;
+   bool bDet ;
+   Frame3d frSrf ;
+   frSrf.Set( ORIG, m_Frame.VersZ()) ;
+   frSrf.VersX().GetRotation( m_Frame.VersX(), m_Frame.VersZ(), dExtraSideAng, bDet) ;
+   return ( m_Params.m_dSideAngle + dExtraSideAng) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SurfFinishing::GetLocalToolDir( Vector3d& vtToolLoc) const
+{
+  // l'orientamento dell'utensile mediante il versore ausiliario definito dagli angoli theta e phi viene applicato solo
+  // se lavorazione in Spiral, ZigZag, OneWay o Projection
+   if ( m_Params.m_nSubType != SURFFIN_SUB_ZIGZAG  &&  m_Params.m_nSubType != SURFFIN_SUB_ONEWAY  &&
+        m_Params.m_nSubType != SURFFIN_SUB_SPIRALIN  &&  m_Params.m_nSubType != SURFFIN_SUB_SPIRALOUT  &&
+        m_Params.m_nSubType != SURFFIN_SUB_PROJECT)
+      return false ;
+
+  // ricerca del vettore direzione utensile locale all'interno del gruppo Owner della lavorazione di finitura corrente
+   int nFrameId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_FRAME) ;
+   if ( nFrameId == GDB_ID_NULL)
+      return false ;
+   int nId = m_pGeomDB->GetFirstInGroup( nFrameId) ;
+   while ( nId != GDB_ID_NULL) {
+      if ( m_pGeomDB->GetGeoType( nId) == GEO_VECT3D) {
+         const IGeoVector3d* vGeoLoc = GetGeoVector3d( m_pGeomDB->GetGeoObj( nId)) ;
+         if ( vGeoLoc != nullptr  &&  vGeoLoc->IsValid()) {
+            vtToolLoc = vGeoLoc->GetVector() ;
+            vtToolLoc.Normalize() ;
+            return true ;
+         }
+      }
+      nId = m_pGeomDB->GetNext( nId) ;
+   }
+
+   return false ;
+}
diff --git a/SurfFinishing.h b/SurfFinishing.h
index bd9a39f..78ede9f 100644
--- a/SurfFinishing.h
+++ b/SurfFinishing.h
@@ -100,21 +100,25 @@ class SurfFinishing : public Machining
 
    public :
       SurfFinishing( void) ;
+      Frame3d GetFrame() const { return m_Frame ; } ;                           // spostare in Machining se tutto ok
+      Frame3d& GetFrame() { return m_Frame ; } ;                                // spostare in Machining se tutto ok
+      void SetFrame( const Frame3d& frFinishing) { m_Frame = frFinishing ; } ;  // spostare in Machining se tutto ok
 
    private :
       bool MyApply( bool bRecalc, bool bPostApply) ;
       bool VerifyGeometry( SelData Id, int& nSubs) ;
       bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
       bool Chain( int nGrpDestId) ;
+      bool UpdateFrameAndToolDir( int nAuxId, bool& bRecalc) ;
       bool GetSurfacesByIds( SURFLOCALVECTOR& vSrfLoc, SURFLOCALVECTOR& vSrfSuppLoc, Frame3d& frSurf) ;
-      bool CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dRad, double dLen, double& dElev) const ; ;
+      bool CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dRad, double dLen, double& dElev) const ;
       bool SetCAvTlStmForSurfaces( ICAvToolSurfTm* pCAvTlStm, const ISurfFlatRegion* pSfrCnt, double dDepth,
                                    double dToolLen, double dToolDiam, double dToolCornRad,
                                    double dToolSideAng, double dToolMaxMat, double dMachOffsR,
                                    const SURFLOCALVECTOR& vSurfLoc, const SURFLOCALVECTOR& vSurfSuppLoc) ;
-      bool EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d& frSurf, const Vector3d& vtTool,
+      bool EraseMaxDownSurf( const SURFLOCALVECTOR& vSurfLoc, const Frame3d& frSurf, const Vector3d& vtMove,
                              double dDepth, ISurfFlatRegion* pSfrCnt) ;
-      bool ProcessCrvCompo( int nPathId, int nPvId, int nClId) ;
+      bool ProcessCrv( int nPathId, int nPvId, int nClId) ;
       bool ProcessSfr( int nPathId, int nPvId, int nClId) ;
       bool SimplifyCurve( ICurveComposite* pCompo, const Frame3d& frLocXY,
                           double dMergeLinTol = 200. * EPS_SMALL, double dMergeAndTolDeg = 200. * EPS_ANG_SMALL,
@@ -126,26 +130,26 @@ class SurfFinishing : public Machining
                                     ICurveComposite* pCrv) const ;
      // lavorazioni per superfici
       bool AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
-                      const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
+                      const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs) ;
       bool AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
-                      const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
+                      const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs) ;
       bool AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
-                      const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut) ;
+                      const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut) ;
       bool AddZConst( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
                       const ISurfFlatRegion* pSfrCnt, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
       bool AddOptimal( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
                        const ISurfFlatRegion* pSfrCntZigZag, const ISurfFlatRegion* pSfrCntZConst, const Vector3d& vtTool,
-                       double dDepth, double dElev, bool bSplitArcs) ;
+                       const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs) ;
       bool AddPencil( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
                       const ISurfFlatRegion* pSfrCnt, const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
      // lavorazioni per curve
       bool AddProjection( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ICurveComposite* pCompo,
-                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
+                          const Vector3d& vtTool, const Vector3d& vtMove, double dDepth, double dElev, bool bSplitArcs) ;
      // creazione del percorso finale di lavorazione
       bool AddFinishing( const ISurfFlatRegion* pSfrCnt, ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ICRVCOMPOPOVECTOR& vCrvCompo,
-                         const Vector3d& vtTool, double dElev, double dDepth, bool bSplitArcs) ;
+                         const Vector3d& vtTool, const Vector3d& vtMove, double dElev, double dDepth, bool bSplitArcs) ;
      // collisione con i percorsi di lavorazione
-      bool CorrectPathByCollision( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Vector3d& vtTool,
+      bool CorrectPathByCollision( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Vector3d& vtTool, const Vector3d& vtMove,
                                    double dDepth, ICRVCOMPOPOVECTOR& vpCrvs) ;
 
       bool WorkPencilCurves( const ICRVCOMPOPOVECTOR& vCrvCompo, const ISurfFlatRegion* pSfrCnt, int nPencilType, double dOffs, int nOffs,
@@ -198,13 +202,12 @@ class SurfFinishing : public Machining
       bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, bool bSplitArcs) ;
       bool CalcLeadOutEnd( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtTool, const Vector3d& vtNorm, Point3d& ptP1) const ;
       bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Point3d& ptP1, const Vector3d& vtTool, bool bSplitArcs) ;
-      bool GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Point3d& ptStart,
-                             const Point3d& ptEnd, const Vector3d& vtInit, const Vector3d& vtTool,
-                             bool bLeadInVsOut, Point3d& ptP1) const ;
-      bool GetLinkFromPaths( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtTool, const ISurfFlatRegion* pSfrCnt,
+      bool GetLastGoodPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Point3d& ptStart, const Point3d& ptEnd,
+                             const Vector3d& vtInit, const Vector3d& vtTool, const Vector3d& vtMove, bool bLeadInVsOut, Point3d& ptP1) const ;
+      bool GetLinkFromPaths( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtTool, const Vector3d& vtMove, const ISurfFlatRegion* pSfrCnt,
                              double dDepth, double dSafeZ, ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, ICurveComposite* pCrvLink) const ;
       bool GetSurfaceNormalAtPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf,
-                                    const Point3d& ptTool, const Vector3d& vtTool, Vector3d& vtNorm) const ;
+                                    const Point3d& ptTool, const Vector3d& vtTool, const Vector3d& vtMove, Vector3d& vtNorm) const ;
       bool GetActiveSurfaces( INTVECTOR& vSurfId, INTVECTOR& vSurfSuppId) const ;
       int ProcessSquare( int nFlag, double dLevel, double dQPt0, double dQpt1, double dQpt2, double dQpt3,
                          int& nI1s, int& nI1e, int& nI2s, int& nI2e) const ;
@@ -222,6 +225,8 @@ class SurfFinishing : public Machining
                                     const Frame3d& frSurf, const Vector3d& vtTool, double dDepth, double dSplitAngDeg, ISURFFRPOVECTOR& vpSfrZigZagProj) const ;
       double GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const ;
       double GetRadiusForStartEndElevation( void) const ;
+      double GetLocalSideAngle() const ;
+      bool GetLocalToolDir( Vector3d& vtToolLoc) const ;
 
    private :
       double GetSpeed() const
@@ -238,6 +243,7 @@ class SurfFinishing : public Machining
          { return ( IsUnknownValue( m_Params.m_dOffsR) ? m_TParams.m_dOffsR : m_Params.m_dOffsR) ; }
       double GetSideStep( void) const
          { return Clamp( m_Params.m_dSideStep, 0.1, m_TParams.m_dTDiam) ; }
+      
       int GetLeadInType( void) const ;
       int GetLeadOutType( void) const ;
 
@@ -245,6 +251,9 @@ class SurfFinishing : public Machining
       SELVECTOR         m_vId ;             // identificativi entità geometriche da lavorare
       SurfFinishingData m_Params ;          // parametri lavorazione
       ToolData          m_TParams ;         // parametri utensile
+      Frame3d           m_Frame ;           // terna per orientamento finitura ZigZag/OneWay
+      double            m_dTheta ;          // orientamento verticale utensile rispetto a m_Frame
+      double            m_dPhi ;            // orientamento orizzontale utesnile rispetto a m_Frame
       double            m_dTHoldBase ;      // posizione base del porta-utensile
       double            m_dTHoldLen ;       // lunghezza del porta-utensile
       double            m_dTHoldDiam ;      // diametro del porta-utensile