diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc
index f97c1f0..c8218aa 100644
Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ
diff --git a/MachMgrMachines.cpp b/MachMgrMachines.cpp
index 50f4caa..c752b27 100644
--- a/MachMgrMachines.cpp
+++ b/MachMgrMachines.cpp
@@ -775,7 +775,7 @@ MachMgr::GetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA,
 {
    DBLVECTOR vAng( 2) ; vAng[0] = dAngA ; vAng[1] = dAngB ;
    Machine* pMch = GetCurrMachine() ;
-   return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, ptTip) : false) ;
+   return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, false, ptTip) : false) ;
 }
 
 //----------------------------------------------------------------------------
@@ -784,7 +784,7 @@ MachMgr::GetCalcTipFromPositions( double dX, double dY, double dZ, const DBLVECT
                                   bool bOverall, bool bBottom, Point3d& ptTip) const
 {
    Machine* pMch = GetCurrMachine() ;
-   return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, ptTip) : false) ;
+   return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, false, ptTip) : false) ;
 }
 
 //----------------------------------------------------------------------------
diff --git a/Machine.h b/Machine.h
index f581845..64dd408 100644
--- a/Machine.h
+++ b/Machine.h
@@ -147,7 +147,7 @@ class Machine
       bool GetNoseFromPositions( double dX, double dY, double dZ, const DBLVECTOR& vAng,
                                  Point3d& ptNose) const ;
       bool GetTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR& vAng,
-                                bool bOverall, bool bBottom, Point3d& ptTip) const ;
+                                bool bOverall, bool bBottom, bool bBack, Point3d& ptTip) const ;
       bool GetToolDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) const ;
       bool GetAuxDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) const ;
       bool GetPartDirFromAngles( const Vector3d& vtPart, const DBLVECTOR& vAng, Vector3d& vtDir) const ;
diff --git a/MachineCalc.cpp b/MachineCalc.cpp
index 212e11e..b62b7e8 100644
--- a/MachineCalc.cpp
+++ b/MachineCalc.cpp
@@ -1369,10 +1369,11 @@ Machine::GetNoseFromPositions( double dX, double dY, double dZ, const DBLVECTOR&
 //----------------------------------------------------------------------------
 bool
 Machine::GetTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR& vAng,
-                              bool bOverall, bool bBottom, Point3d& ptTip) const
+                              bool bOverall, bool bBottom, bool bBack, Point3d& ptTip) const
 {
   // la posizione deve essere espressa rispetto allo ZERO MACCHINA
   // ่ espressa nel riferimento di macchina (tiene conto delle sole rotazioni di testa)
+  // se bBack vero, allora ่ nel riferimento pezzo
 
   // verifico dimensione vettore angoli rispetto al numero di assi rotanti
    if ( vAng.size() < m_vCalcRotAx.size())
@@ -1419,12 +1420,33 @@ Machine::GetTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR&
    if ( m_nCalcChainType == KIN_CHAIN_ROBOT)
       ptTip.ToGlob( m_frRobot) ;
 
+  // Se richiesto nel riferimento pezzo
+   if ( bBack) {
+     // ciclo sugli assi lineari di tavola all'indietro
+      DBLVECTOR vMov( {dX, dY, dZ}) ;
+      for ( int i = int( m_vCalcLinAx.size()) ; i > 0 ; -- i) {
+         if ( ! m_vCalcLinAx[i-1].bHead)
+            ptTip += m_vCalcLinAx[i-1].vtDir * ( vMov[i-1] - m_vCalcLinAx[i-1].dHomeVal) ;
+      }
+     // ciclo sugli assi rotanti di tavola all'indietro !!! NON VERIFICATO !!!
+      for ( int i = int( m_vCalcRotAx.size()) ; i > 0 ; -- i) {
+         if ( ! m_vCalcRotAx[i-1].bHead)
+            ptTip.Rotate( m_vCalcRotAx[i-1].ptPos, m_vCalcRotAx[i-1].vtDir, -vAng[i-1]) ;
+      }
+   }
+
   // Se richiesto ingombro totale o punto sotto del tip utensile
    if ( bOverall  ||  bBottom) {
      // calcolo la direzione fresa
       Vector3d vtDirT ;
-      if ( ! GetDirection( m_vtCalcDir, vAng, vtDirT))
-         return false ;
+      if ( bBack) {
+         if ( ! GetBackDirection( m_vtCalcDir, vAng, vtDirT))
+            return false ;
+      }
+      else {
+         if ( ! GetDirection( m_vtCalcDir, vAng, vtDirT))
+            return false ;
+      }
      // se richiesto ingombro totale
       if ( bOverall)
          ptTip -= vtDirT * max( m_dCalcTOvLen - m_dCalcTLen, 0.) ;
diff --git a/Operation.cpp b/Operation.cpp
index ecfce05..4469b2c 100644
--- a/Operation.cpp
+++ b/Operation.cpp
@@ -2332,7 +2332,7 @@ Operation::VerifyLineMidPoint( const Point3d& ptPrec, const Vector3d& vtDirPrec,
       vAxRotMid[i-3] = vAxMid[i] ;
   // ricavo il punto medio del movimento
    Point3d ptMoveMid ;
-   if ( ! pMachine->GetTipFromPositions( vAxMid[0], vAxMid[1], vAxMid[2], vAxRotMid, false, false, ptMoveMid))
+   if ( ! pMachine->GetTipFromPositions( vAxMid[0], vAxMid[1], vAxMid[2], vAxRotMid, false, false, true, ptMoveMid))
       return false ;
   // verifico le differenze
    double dDist ;
diff --git a/SurfRoughing.cpp b/SurfRoughing.cpp
index 23a7cbb..0972bde 100644
--- a/SurfRoughing.cpp
+++ b/SurfRoughing.cpp
@@ -1847,6 +1847,8 @@ SurfRoughing::AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, co
                else if ( ! bSingleCrv  &&  nSubType == SURFROU_SUB_SPIRALIN)
                   if ( ! CalcRetCrv( vpCrvs[k], ptUp, bOutStart, pRCrv))
                      return false ;
+              // flag approccio libero in aria
+               bool bOutLeadIn = ( bOutStart  ||  bSingleCrv  ||  bOptTrap) ;
               // determino inizio attacco
                Point3d ptP1 ;
                if ( ! CalcLeadInStart( ptStart, vtStart, vtExtr, pRCrv, ptP1))
@@ -1871,16 +1873,21 @@ SurfRoughing::AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, co
                }
               // altrimenti, approccio di collegamento
                else {
-                 // cambio posizione punto per fare elica o similari solo sulla parte con materiale
-                  if ( ( GetLeadInType() == POCKET_LI_ZIGZAG  ||
-                         GetLeadInType() == POCKET_LI_HELIX  ||
-                         GetLeadInType() == POCKET_LI_GLIDE)  &&  ! bIsSubStep) {
-                     ptP1 -= ( nBasicStep * dStep) * vtTool ;
-                  }
-                  if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
+                  if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr, bOutLeadIn)) {
                      m_pMchMgr->SetLastError( 3012, "Error in SurfRoughing : Link not computable") ;
                      return false ;
                   }
+                 // se attacco elica od equivalente di step pieno, devo fare elica o similari solo sulla parte con materiale
+                  if ( ! bIsSubStep  &&
+                       ( GetLeadInType() == POCKET_LI_ZIGZAG  ||
+                         GetLeadInType() == POCKET_LI_HELIX  ||
+                         GetLeadInType() == POCKET_LI_GLIDE)) {
+                     ptP1 -= ( nBasicStep * dStep) * vtTool ;
+                     SetFeed( GetStartFeed()) ;
+                     SetFlag( 0) ;
+                     if ( AddLinearMove( ptP1) == GDB_ID_NULL)
+                        return false ;
+                  }
                }
               // aggiungo attacco
                SetFeed( GetStartFeed()) ;
@@ -1900,7 +1907,7 @@ SurfRoughing::AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, co
                if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pCompo,
                                  ( ( nSubType == SURFROU_SUB_SPIRALIN  ||  nSubType == SURFROU_SUB_SPIRALOUT)) ? Get( pRCrv) : nullptr,
                                  ( nSubType == SURFROU_SUB_SPIRALOUT) ? m_Params.m_bInvert : ! m_Params.m_bInvert,
-                                  bSplitArcs, ( bOutStart  ||  bSingleCrv  ||  bOptTrap), false)) {
+                                  bSplitArcs, bOutLeadIn, false)) {
                   m_pMchMgr->SetLastError( 3013, "Error in SurfRoughing : LeadIn not computable") ;
                   return false ;
                }
@@ -2013,7 +2020,7 @@ SurfRoughing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dS
 
 //----------------------------------------------------------------------------
 bool
-SurfRoughing::AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
+SurfRoughing::AddLinkApproach(const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr, bool bOutMove)
 {
   // se sopra attacco c'รจ spazio per approccio
    if ( ( dElev + dAppr) > 10 * EPS_SMALL) {
@@ -2026,7 +2033,7 @@ SurfRoughing::AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, doubl
       }
      // affondo al punto iniziale
       SetFlag( 0) ;
-      SetFeed( GetTipFeed()) ;
+      SetFeed( bOutMove ? GetStartFeed() : GetTipFeed()) ;
       if ( AddLinearMove( ptP) == GDB_ID_NULL)
          return false ;
    }
diff --git a/SurfRoughing.h b/SurfRoughing.h
index 742f3ec..d7c8740 100644
--- a/SurfRoughing.h
+++ b/SurfRoughing.h
@@ -79,7 +79,7 @@ class SurfRoughing : public Machining
       bool AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, const Vector3d& vtExtr,
                       double dElev, double dStep, bool bSplitArcs) ;
       bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
-      bool AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
+      bool AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr, bool bOutMove) ;
       bool AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
       bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
       bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, const ICurveComposite* pCrvPath, Point3d& ptP1) const ;