diff --git a/CamData.cpp b/CamData.cpp
index f573efe..65a8eff 100644
--- a/CamData.cpp
+++ b/CamData.cpp
@@ -1,13 +1,14 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2016
+//  EgalTech 2015-2023
 //----------------------------------------------------------------------------
-// File : CamData.cpp       Data : 24.02.16          Versione : 1.6n8
+// File : CamData.cpp       Data : 22.11.23          Versione : 2.5k3
 // Contenuto : Implementazione informazioni Cam di ogni movimento.
 //
 //
 //
 // Modifiche : 10.06.15 DS Creazione modulo.
 //             24.02.16 DS Versione 2 (aggiunti m_nMove e m_ptCen).
+//             22.11.23 DS Aggiunto flag ToolShow (forza in ogni caso la visualizzazione della direzione utensile).
 //
 //----------------------------------------------------------------------------
 
@@ -53,7 +54,9 @@ static int CAM_PARAM_V7 = 22 ;
 static string CAM_ORIGFEED = "OrFeed" ;
 static int CAM_PARAM_V8 = 23 ;
 static string CAM_FLAG2 = "Flg2" ;
-static int CAM_TOTPARAM =CAM_PARAM_V8 ;
+static int CAM_PARAM_V9 = 24 ;
+static string CAM_TOOLSHOW = "TSh" ;
+static int CAM_TOTPARAM = CAM_PARAM_V9 ;
 
 
 //----------------------------------------------------------------------------
@@ -79,6 +82,7 @@ CamData::Clone( void) const
          pCam->m_pGeomDB = nullptr ;
          pCam->m_nMove = m_nMove ;
          pCam->m_nCorre = m_nCorre ;
+         pCam->m_bToolShow = m_bToolShow ;
          pCam->m_vtTool = m_vtTool ;
          pCam->m_vtCorr = m_vtCorr ;
          pCam->m_vtAux = m_vtAux ;
@@ -139,6 +143,7 @@ CamData::Dump( string& sOut, bool bMM, const char* szNewLine) const
    sOut += CAM_AXND + "=" + ToString( m_vtMachN) + szNewLine ;
    sOut += CAM_NDLT + "=" + ToString( m_dDeltaN) + szNewLine ;
    sOut += CAM_BDIR + "=" + ToString( m_vtBackAux) + szNewLine ;
+   sOut += CAM_TOOLSHOW + "=" + ToString( m_bToolShow) + szNewLine ;
 
    return true ;
 }
@@ -205,6 +210,8 @@ CamData::Save( int nBaseId, STRVECTOR& vString) const
       vString[++k] = CAM_ORIGFEED + "=" + ToString( m_dOrigFeed) ;
       // parametri aggiunti V8
       vString[++k] = CAM_FLAG2 + "=" + ToString( m_nFlag2) ;
+      // parametri aggiunti V9
+      vString[++k] = CAM_TOOLSHOW + "=" + ToString( m_bToolShow) ;     
    }
    catch( ...) {
       return false ;
@@ -297,6 +304,14 @@ CamData::Load( const STRVECTOR& vString, int nBaseGdbId)
    else {
       m_nFlag2 = 0 ;
    }
+  // parametri aggiunti V9
+   if ( int( vString.size()) >= CAM_PARAM_V9) {
+      if ( ! GetVal( vString[++k], CAM_TOOLSHOW, m_bToolShow))
+         return false ;
+   }
+   else {
+      m_bToolShow = false ;
+   }
    return true ;
 }
 
@@ -313,7 +328,7 @@ CamData::GetDrawPolyLines( POLYLINELIST& lstPL) const
       PolyLine& PL = lstPL.back() ;
      // dimensioni
       const double TLEN = 40 ;
-      const double ALEN = 4 ;
+      const double ALEN = 1 ;
      // inserisco disegno nella polilinea
       PL.AddUPoint( 0, m_ptEnd) ;
       Point3d ptTip = m_ptEnd + m_vtTool * TLEN ;
@@ -335,6 +350,9 @@ CamData::GetDrawPolyLines( POLYLINELIST& lstPL) const
       ptP6.ToGlob( frF) ;
       PL.AddUPoint( 6, ptP6) ;
       PL.AddUPoint( 6, ptTip) ;
+     // da visualizzare sempre se richiesto
+      if ( m_bToolShow)
+         PL.SetTempProp( 1) ;
    }
   // se vettore correzione non nullo
    if ( ! m_vtCorr.IsSmall()) {
@@ -344,7 +362,7 @@ CamData::GetDrawPolyLines( POLYLINELIST& lstPL) const
       PolyLine& PL = lstPL.back() ;
      // dimensioni
       const double CLEN = 20 ;
-      const double ALEN = 2 ;
+      const double ALEN = 1 ;
      // inserisco disegno nella polilinea
       PL.AddUPoint( 0, m_ptEnd) ;
       Point3d ptTip = m_ptEnd + m_vtCorr * CLEN ;
@@ -373,7 +391,7 @@ CamData::GetDrawPolyLines( POLYLINELIST& lstPL) const
       PolyLine& PL = lstPL.back() ;
      // dimensioni
       const double CLEN = 20 ;
-      const double ALEN = 2 ;
+      const double ALEN = 1 ;
      // inserisco disegno nella polilinea
       PL.AddUPoint( 0, m_ptEnd) ;
       Point3d ptTip = m_ptEnd + m_vtAux * CLEN ;
@@ -548,6 +566,7 @@ CamData::CamData( void)
    m_pGeomDB = nullptr ;
    m_nMove = 0 ;
    m_nCorre = 0 ;
+   m_bToolShow = false ;
    m_dAngCen = 0 ;
    m_dDeltaN = 0 ;
    m_dFeed = 0 ;
diff --git a/CamData.h b/CamData.h
index fbaf3ad..a410ed1 100644
--- a/CamData.h
+++ b/CamData.h
@@ -68,11 +68,13 @@ class CamData : public IUserObj
       bool SetAxesAngCen( double dAngCen) ;
       bool SetAxesNormDir( const Vector3d& vtDir) ;
       bool SetBackAuxDir( const Vector3d& vtDir) ;
-      const int GetMoveType( void) const
+      bool SetToolShow( bool bShow)
+              { m_bToolShow = bShow ; return true ; }
+      int             GetMoveType( void) const
                          { return m_nMove ; }
-      const bool IsLine( void) const
+      bool            IsLine( void) const
                          { return ( m_nMove == 0  ||  m_nMove == 1) ; }
-      const bool IsArc( void) const
+      bool            IsArc( void) const
                          { return ( m_nMove == 2  ||  m_nMove == 3) ; }
       const Vector3d& GetToolDir( void) const
                          { return m_vtTool ; }
@@ -108,14 +110,16 @@ class CamData : public IUserObj
                          { return m_vMachAxes ; }
       const Point3d&  GetAxesCen( void) const
                          { return m_ptMachCen ; }
-      const double    GetAxesRad( void) const
+      double          GetAxesRad( void) const
                          { return m_dMachRad ; }
-      const double    GetAxesAngCen( void) const
+      double          GetAxesAngCen( void) const
                          { return m_dMachAngCen ; }
       const Vector3d& GetAxesNormDir( void) const
                          { return m_vtMachN ; }
       const Vector3d& GetBackAuxDir( void) const
                          { return m_vtBackAux ; }
+      bool            GetToolShow( void) const
+                         { return m_bToolShow ; }
 
    public :
       enum { AS_NONE = 0,
@@ -139,6 +143,7 @@ class CamData : public IUserObj
       IGeomDB*    m_pGeomDB ;
       int         m_nMove ;                // tipo movimento (0=rapido, 1=lineare, 2=arco CW, 3=arco CCW)
       int         m_nCorre ;               // tipo correzione (0, 41, 42, 141, 142, 40)
+      bool        m_bToolShow ;            // flag per forzare la visualizzazione della direzione utensile in ogni caso
       Vector3d    m_vtTool ;               // versore fresa
       Vector3d    m_vtCorr ;               // versore correzione
       Vector3d    m_vtAux ;                // versore ausiliario
diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc
index 45676ab..4495130 100644
Binary files a/EgtMachKernel.rc and b/EgtMachKernel.rc differ
diff --git a/GenMachining.cpp b/GenMachining.cpp
index 1d0b29e..0dcb4d2 100644
--- a/GenMachining.cpp
+++ b/GenMachining.cpp
@@ -55,6 +55,17 @@ static const string EVAR_STARTPOS = ".STARTPOS" ;  // IN (num) quota di inizio l
 static const string EVAR_OFFSR = ".OFFSR" ;        // IN (num) offset radiale 
 static const string EVAR_OFFSL = ".OFFSL" ;        // IN (num) offset longitudinale 
 static const string EVAR_TOOL = ".TOOL" ;          // IN (string) nome dell'utensile
+static const string EVAR_HEAD = ".HEAD" ;          // IN (string) nome testa
+static const string EVAR_EXIT = ".EXIT" ;          // IN (int) indice uscita
+static const string EVAR_TTYPE = ".TTYPE" ;        // IN (int) tipo utensile
+static const string EVAR_TMAXMAT = ".TMAXMAT" ;    // IN (num) massimo materiale
+static const string EVAR_TDIAM = ".TDIAM" ;        // IN (num) diametro utensile
+static const string EVAR_TTOTDIAM = ".TTOTDIAM" ;  // IN (num) diametro totale utensile
+static const string EVAR_TLEN = ".TLEN" ;          // IN (num) lunghezza utensile
+static const string EVAR_TTOTLEN = ".TTOTLEN" ;    // IN (num) lunghezza totale utensile
+static const string EVAR_TTHICK = ".THICK" ;       // IN (num) spessore per lame o altezza taglienti
+static const string EVAR_TCORNRAD = ".TCORNRAD" ;  // IN (num) raggio corner
+static const string EVAR_TSIDEANG = ".TSIDEANG" ;  // IN (num) angolo del fianco rispetto all'asse
 static const string EVAR_FEED = ".FEED" ;          // IN (num) feed dell'utensile
 static const string EVAR_STARTFEED = ".STARTFEED" ;// IN (num) feed di inizio dell'utensile
 static const string EVAR_ENDFEED = ".ENDFEED" ;    // IN (num) feed di fine dell'utensile
@@ -481,6 +492,17 @@ GenMachining::Preview( bool bRecalc)
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSR, GetOffsR()) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSL, GetOffsL()) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TOOL, m_TParams.m_sName) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_HEAD, m_TParams.m_sHead) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_EXIT, m_TParams.m_nExit) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTYPE, m_TParams.m_nType) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TMAXMAT, m_TParams.m_dMaxMat) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TDIAM, m_TParams.m_dDiam) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTDIAM, m_TParams.m_dTDiam) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TLEN, m_TParams.m_dLen) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTLEN, m_TParams.m_dTLen) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTHICK, m_TParams.m_dThick) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TCORNRAD, m_TParams.m_dCornRad) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TSIDEANG, m_TParams.m_dSideAng) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_FEED, GetFeed()) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTFEED, GetStartFeed()) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ENDFEED, GetEndFeed()) ;
@@ -584,6 +606,17 @@ GenMachining::Apply( bool bRecalc, bool bPostApply)
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSR, GetOffsR()) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSL, GetOffsL()) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TOOL, m_TParams.m_sName) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_HEAD, m_TParams.m_sHead) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_EXIT, m_TParams.m_nExit) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTYPE, m_TParams.m_nType) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TMAXMAT, m_TParams.m_dMaxMat) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TDIAM, m_TParams.m_dDiam) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTDIAM, m_TParams.m_dTDiam) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TLEN, m_TParams.m_dLen) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTLEN, m_TParams.m_dTLen) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTHICK, m_TParams.m_dThick) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TCORNRAD, m_TParams.m_dCornRad) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TSIDEANG, m_TParams.m_dSideAng) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_FEED, GetFeed()) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTFEED, GetStartFeed()) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ENDFEED, GetEndFeed()) ;
diff --git a/MachMgr.h b/MachMgr.h
index 33dea73..061bdd3 100644
--- a/MachMgr.h
+++ b/MachMgr.h
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
 //  EgalTech 2015-2023
 //----------------------------------------------------------------------------
-// File : MachMgr.h           Data : 25.08.23          Versione : 2.5h3
+// File : MachMgr.h           Data : 28.10.23          Versione : 2.5j4
 // Contenuto : Dichiarazione della classe MachMgr.
 //
 //
@@ -12,6 +12,7 @@
 //             17.03.21 DS Aggiunte funzioni per import/export utensili.
 //             21.09.22 DS Aggiunta GetAxisOffset.
 //             25.08.23 DS Aggiunta CopyMachGroup.
+//             28.10.23 DS Aggiunte GetClEntAxesVal e GetToolSetupPosInCurrSetup.
 //
 //----------------------------------------------------------------------------
 
@@ -205,6 +206,7 @@ class MachMgr : public IMachMgr
       bool ImportSetup( const std::string& sName) override ;
       bool VerifyCurrSetup( STRVECTOR& vsErrors) override ;
       bool FindToolInCurrSetup( const std::string& sTool) override ;
+      bool GetToolSetupPosInCurrSetup( const std::string& sTool, std::string& sTcPos) override ;
       bool GetToolsInCurrSetupPos( const std::string& sTcPos, STRVECTOR& vsTools) override ;
       bool UpdateCurrSetup( void) override ;
       bool EraseCurrSetup( void) override ;
@@ -303,8 +305,9 @@ class MachMgr : public IMachMgr
       bool GetMachiningEndPoint( Point3d& ptEnd) const override ;
      // CL Entities Interrogations
       bool GetClEntMove( int nEntId, int& nMove) const override ;
-      bool GetClEntFlag( int nEntId, int& nFlag) const override ;
+      bool GetClEntFlag( int nEntId, int& nFlag, int& nFlag2) const override ;
       bool GetClEntIndex( int nEntId, int& nIndex) const override ;
+      bool GetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) const override ;
      // Simulation
       bool SimInit( void) override ;
       bool SimStart( bool bFirst) override ;
@@ -323,6 +326,7 @@ class MachMgr : public IMachMgr
      // Machine Calc
       bool SetCalcTable( const std::string& sTable) override ;
       bool SetCalcTool( const std::string& sTool, const std::string& sHead, int nExit) override ;
+      bool GetAllCurrAxesName( STRVECTOR& vAxName) const override ;
       bool SetRotAxisBlock( const std::string& sAxis, double dVal) override ;
       bool GetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) const override ;
       bool GetCalcTool( std::string& sTool) const override ;
@@ -432,7 +436,6 @@ class MachMgr : public IMachMgr
      // MachineCalc
       int  GetCurrLinAxes( void) const ;
       int  GetCurrRotAxes( void) const ;
-      bool GetAllCurrAxesName( STRVECTOR& vAxName) const ;
       bool GetAllCurrAxesHomePos( DBLVECTOR& vAxHomeVal) const ;
       bool GetCurrAxisHomePos( int nInd, double& dHome) const ;
       const Frame3d& GetCurrLinAxesFrame( void) const ;
diff --git a/MachMgrClEntities.cpp b/MachMgrClEntities.cpp
index b7dbc9a..5a684d5 100644
--- a/MachMgrClEntities.cpp
+++ b/MachMgrClEntities.cpp
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2019-2019
+//  EgalTech 2019-2023
 //----------------------------------------------------------------------------
-// File : MachMgrClEntities.cpp       Data : 15.10.19      Versione : 2.1j4
+// File : MachMgrClEntities.cpp       Data : 27.10.23      Versione : 2.5j4
 // Contenuto : Implementazione interrogazione entità CL della classe MachMgr.
 //
 //
@@ -39,10 +39,11 @@ MachMgr::GetClEntMove( int nEntId, int& nMove) const
 
 //----------------------------------------------------------------------------
 bool
-MachMgr::GetClEntFlag( int nEntId, int& nFlag) const
+MachMgr::GetClEntFlag( int nEntId, int& nFlag, int& nFlag2) const
 {
   // default
    nFlag = 0 ;
+   nFlag2 = 0 ;
   // verifico validita GeomDB
    if ( m_pGeomDB == nullptr)
       return false ;
@@ -50,8 +51,9 @@ MachMgr::GetClEntFlag( int nEntId, int& nFlag) const
    const CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
    if ( pCamData == nullptr)
       return false ;
-  // recupero il flag
+  // recupero i flag
    nFlag = pCamData->GetFlag() ;
+   nFlag2 = pCamData->GetFlag2() ;
    return true ;
 }
 
@@ -72,3 +74,21 @@ MachMgr::GetClEntIndex( int nEntId, int& nIndex) const
    nIndex = pCamData->GetIndex() ;
    return true ;
 }
+
+//----------------------------------------------------------------------------
+bool
+MachMgr::GetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) const
+{
+  // default
+   vAxes.clear() ;
+  // verifico validita GeomDB
+   if ( m_pGeomDB == nullptr)
+      return false ;
+  // recupero l'oggetto CamData
+   const CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
+   if ( pCamData == nullptr)
+      return false ;
+  // recupero i valori degli assi
+   vAxes = pCamData->GetAxesVal() ;
+   return true ;
+}
diff --git a/MachMgrDBTools.cpp b/MachMgrDBTools.cpp
index abd0d94..0249df0 100644
--- a/MachMgrDBTools.cpp
+++ b/MachMgrDBTools.cpp
@@ -721,7 +721,7 @@ MachMgr::UpdateStandardToolDraw( const ToolData* pTdata, int nGenCtx, int nToolC
    if ( ! ExeLuaGetGlobIntVar( "TOOL.ERR", &nErr)  ||  nErr != 0)
       return nErr ;
   // Se per salvataggio
-   if ( bOk && bToSave) {
+   if ( bOk  &&  bToSave) {
      // Nascondo layer ausiliario
       int nAuxId = ExeGetFirstNameInGroup( ExeGetFirstGroupInGroup( GDB_ID_ROOT), "AUX") ;
       ExeSetStatus( { nAuxId}, GDB_ST_OFF) ;
@@ -731,6 +731,16 @@ MachMgr::UpdateStandardToolDraw( const ToolData* pTdata, int nGenCtx, int nToolC
          ExeRotate( { nPartId}, ORIG, Z_AX, -90, RTY_GLOB) ;
       }
    }
+  // altrimenti per visualizzazione
+   else if ( bOk) {
+     // Nascondo oggetto/i Carter
+      int nSolidId = ExeGetFirstNameInGroup( ExeGetFirstGroupInGroup( GDB_ID_ROOT), "SOLID") ;
+      int nCarterId = ExeGetFirstNameInGroup( nSolidId, "Carter") ;
+      while ( nCarterId != GDB_ID_NULL) {
+         ExeSetStatus( { nCarterId}, GDB_ST_OFF) ;
+         nCarterId = ExeGetNextName( nCarterId, "Carter") ;
+      }
+   }
    return ( bOk ? 0 : TD_INT_ERR) ;
 }
 
diff --git a/MachMgrRawParts.cpp b/MachMgrRawParts.cpp
index 4a4873d..e92f27c 100644
--- a/MachMgrRawParts.cpp
+++ b/MachMgrRawParts.cpp
@@ -625,6 +625,7 @@ MachMgr::VerifyRawPartPhase( int nRawId, int nPhase) const
    INTVECTOR vPhase ;
    if ( ! GetRawPartPhases( nRawId, vPhase))
       return false ;
+  // verifico presenza nella fase indicata
    return ( find( vPhase.begin(), vPhase.end(), nPhase) != vPhase.end()) ;
 }
 
diff --git a/MachMgrSetup.cpp b/MachMgrSetup.cpp
index 70a4110..c7e0215 100644
--- a/MachMgrSetup.cpp
+++ b/MachMgrSetup.cpp
@@ -130,6 +130,13 @@ MachMgr::FindToolInCurrSetup( const string& sTool)
    return m_stuMgr.FindTool( sTool) ;
 }
 
+//----------------------------------------------------------------------------
+bool
+MachMgr::GetToolSetupPosInCurrSetup( const string& sTool, string& sTcPos)
+{
+   return m_stuMgr.GetToolSetupPos( sTool, sTcPos) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 MachMgr::GetToolsInCurrSetupPos( const string& sTcPos, STRVECTOR& vsTools)
diff --git a/Machine.cpp b/Machine.cpp
index 7dc0ebb..be64455 100644
--- a/Machine.cpp
+++ b/Machine.cpp
@@ -659,9 +659,9 @@ Machine::LoadMachineSpecialHead( const string& sName, const string& sParent, con
 
 //----------------------------------------------------------------------------
 bool
-Machine::LoadMachineTcPos( const string& sName, const string& sParent,
-                           const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
-                           const string& sGeo, const STRVECTOR& vsAux)
+Machine::LoadMachineStdTcPos( const string& sName, const string& sParent,
+                              const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
+                              const string& sGeo, const STRVECTOR& vsAux)
 {
   // recupero pezzo e layer della geometria originale della posizione nel cambio utensile
    string sPart, sLay ;
@@ -701,6 +701,48 @@ Machine::LoadMachineTcPos( const string& sName, const string& sParent,
    return m_mapGroups.emplace( sName, nLay).second ;
 }
 
+//----------------------------------------------------------------------------
+bool
+Machine::LoadMachineMultiTcPos( const string& sName, const string& sParent,
+                                const MUEXITVECTOR& vMuExit, const Vector3d& vtADir,
+                                const string& sGeo, const STRVECTOR& vsAux)
+{
+  // recupero pezzo e layer della geometria originale della posizione nel cambio utensile
+   string sPart, sLay ;
+   Split( sGeo, "/", true, sPart, sLay) ;
+  // cerco il gruppo nella geometria originale
+   int nPart = m_pGeomDB->GetFirstNameInGroup( m_nTempGroupId, sPart) ;
+   int nLay = m_pGeomDB->GetFirstNameInGroup( nPart, sLay) ;
+   if ( nLay == GDB_ID_NULL)
+      return false ;
+  // cerco il gruppo padre per spostarvelo
+   int nParentId = GetGroup( sParent) ;
+   if ( nParentId == GDB_ID_NULL  ||
+        ! m_pGeomDB->RelocateGlob( nLay, nParentId, GDB_LAST_SON))
+      return false ;
+  // sistemo lo stato di visualizzazione
+   m_pGeomDB->SetStatus( nLay, GDB_ST_ON) ;
+  // gli assegno il nome
+   m_pGeomDB->SetName( nLay, sName) ;
+  // sistemo la geometria ausiliaria
+   if ( ! AdjustAuxGeometry( vsAux, nLay))
+      return false ;
+  // installo e inizializzo il gestore della posizione nel cambio utensile
+   TcPos* pTcPos = new(nothrow) TcPos ;
+   if ( pTcPos == nullptr)
+      return false ;
+   pTcPos->Set( sName, vtADir) ;
+   m_pGeomDB->SetUserObj( nLay, pTcPos) ;
+  // sistemo il riferimento dell'uscita rispetto alla direzione ausiliaria
+   if ( ! AdjustExitFrames( nLay, vMuExit, vtADir))
+      return false ;
+  // trasformazione del riferimento di uscita in gruppo di uscita
+   if ( ! CreateExitGroups( nLay, vMuExit))
+      return false ;
+  // lo inserisco nel dizionario dei gruppi della macchina
+   return m_mapGroups.emplace( sName, nLay).second ;
+}
+
 //----------------------------------------------------------------------------
 int
 Machine::GetGroup( const string& sGroup) const
diff --git a/Machine.h b/Machine.h
index 5e467b9..5d4742d 100644
--- a/Machine.h
+++ b/Machine.h
@@ -215,9 +215,12 @@ class Machine
                                    const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
                                    double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
                                    const std::string& sGeo, const STRVECTOR& vsAux) ;
-      bool LoadMachineTcPos( const std::string& sName, const std::string& sParent,
-                             const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
-                             const std::string& sGeo, const STRVECTOR& vsAux) ;
+      bool LoadMachineStdTcPos( const std::string& sName, const std::string& sParent,
+                                const Point3d& ptPos, const Vector3d& vtTDir, const Vector3d& vtADir,
+                                const std::string& sGeo, const STRVECTOR& vsAux) ;
+      bool LoadMachineMultiTcPos( const std::string& sName, const std::string& sParent,
+                                  const MUEXITVECTOR& vMuExit, const Vector3d& vtADir,
+                                  const std::string& sGeo, const STRVECTOR& vsAux) ;
       int  GetGroup( const std::string& sGroup) const ;
       bool IsBaseGroup( int nGroup) const ;
       Axis* GetAxis( int nGroup) const ;
@@ -325,6 +328,8 @@ class Machine
       static int LuaEmtMultiHead( lua_State* L) ;
       static int LuaEmtSpecialHead( lua_State* L) ;
       static int LuaEmtTcPos( lua_State* L) ;
+      static int LuaEmtStdTcPos( lua_State* L) ;
+      static int LuaEmtMultiTcPos( lua_State* L) ;
       static int LuaEmtModifyAxisPosition( lua_State* L) ;
       static int LuaEmtModifyAxisDirection( lua_State* L) ;
       static int LuaEmtModifyAxisStroke( lua_State* L) ;
diff --git a/MachineCalc.cpp b/MachineCalc.cpp
index 56eed2a..9969cd7 100644
--- a/MachineCalc.cpp
+++ b/MachineCalc.cpp
@@ -502,8 +502,10 @@ Machine::CalculateKinematicChain( void)
          m_vCalcLinAx[i].nInd *= -1 ;
    }
    // devono essere 3
-   if ( m_vCalcLinAx.size() != 3)
+   if ( m_vCalcLinAx.size() != 3)  {
+      LOG_ERROR( GetEMkLogger(), "Linear Axes are not 3 in number")
       return false ;
+   }
    // devono essere ordinabili come XYZ
    if ( ! m_vCalcLinAx[0].vtDir.IsX()) {
       if ( m_vCalcLinAx[1].vtDir.IsX())
diff --git a/MachineLua.cpp b/MachineLua.cpp
index 886c719..cbe8ff1 100644
--- a/MachineLua.cpp
+++ b/MachineLua.cpp
@@ -44,6 +44,7 @@ static const string FLD_INVERT = "Invert" ;
 static const string FLD_AXIS_OFFSET = "Offset" ;
 static const string FLD_REF1 = "Ref1" ;
 static const string FLD_SCALE = "Scale" ;
+static const string FLD_EXIT_NBR = "ExitNbr" ;
 static const string FLD_POS = "Pos" ;
 static const string FLD_DIR = "Dir" ;
 static const string FLD_STROKE = "Stroke" ;
@@ -661,7 +662,7 @@ Machine::LuaEmtMultiHead( lua_State* L)
    LuaCheckTabFieldParam( L, 1, FLD_HSET, sHSet)
   // lettura campo 'ExitNbr' dalla tabella
    int nExitNbr ;
-   LuaCheckTabFieldParam( L, 1, "ExitNbr", nExitNbr)
+   LuaCheckTabFieldParam( L, 1, FLD_EXIT_NBR, nExitNbr)
   // lettura campi 'PosN' e 'TDirN' per ogni uscita dalla tabella
    MUEXITVECTOR vMuExit ;
    vMuExit.reserve( nExitNbr) ;
@@ -676,7 +677,7 @@ Machine::LuaEmtMultiHead( lua_State* L)
      // inserimento nell'array
       vMuExit.emplace_back( ptPos, vtTDir) ;
    }
-  // lettura campo 'ADir' dalla tabella
+  // lettura eventuale campo 'ADir' dalla tabella
    Vector3d vtADir ;
    LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
   // lettura eventuale campo 'Rot1W' dalla tabella (default 1)
@@ -713,7 +714,7 @@ Machine::LuaEmtMultiHead( lua_State* L)
   // carico i dati della testa multipla
    if ( ! m_pMchLua->LoadMachineMultiHead( sName, sParent, sHSet, vMuExit, vtADir,
                                            dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
-      return luaL_error( L, " Load Machine Standard Head failed") ;
+      return luaL_error( L, " Load Machine Multi Head failed") ;
 
   // restituisco l'indice della testa
    int nHeadId = m_pMchLua->GetHeadId( sName) ;
@@ -797,6 +798,26 @@ Machine::LuaEmtSpecialHead( lua_State* L)
 //----------------------------------------------------------------------------
 int
 Machine::LuaEmtTcPos( lua_State* L)
+{
+  // Il parametro 1 deve essere una tabella
+   if ( ! lua_istable( L, 1))
+      return luaL_error( L, " Invalid Parameter, required a table") ;
+  // lettura campo opzionale 'ExitNbr' dalla tabella
+   int nExitNbr = 1 ;
+   LuaGetTabFieldParam( L, 1, FLD_EXIT_NBR, nExitNbr) ;
+
+  // Procedo alla lettura a seconda del tnumero di uscite
+   if ( nExitNbr == 1)
+      return LuaEmtStdTcPos( L) ;
+   else if ( nExitNbr > 1)
+      return LuaEmtMultiTcPos( L) ;
+   else
+      return luaL_error( L, " Tc Position type unknown") ;
+}
+
+//----------------------------------------------------------------------------
+int
+Machine::LuaEmtStdTcPos( lua_State* L)
 {
   // Il parametro 1 deve essere una tabella
    if ( ! lua_istable( L, 1))
@@ -833,8 +854,70 @@ Machine::LuaEmtTcPos( lua_State* L)
       return luaL_error( L, " Unknown Machine") ;
 
   // carico i dati della posizione cambio utensile
-   if ( ! m_pMchLua->LoadMachineTcPos( sName, sParent, ptPos, vtTDir, vtADir, sGeo, vsAux))
-      return luaL_error( L, " Load Machine Tc Position failed") ;
+   if ( ! m_pMchLua->LoadMachineStdTcPos( sName, sParent, ptPos, vtTDir, vtADir, sGeo, vsAux))
+      return luaL_error( L, " Load Machine Standard Tc Position failed") ;
+
+  // restituisco l'indice della posizione cambio utensile
+   int nTcPosId = m_pMchLua->GetTcPosId( sName) ;
+   if ( nTcPosId != GDB_ID_NULL)
+      LuaSetParam( L, nTcPosId) ;
+   else
+      LuaSetParam( L) ;
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+int
+Machine::LuaEmtMultiTcPos( lua_State* L)
+{
+  // Il parametro 1 deve essere una tabella
+   if ( ! lua_istable( L, 1))
+      return luaL_error( L, " Invalid Parameter, required a table") ;
+  // lettura campo 'Name' dalla tabella
+   string sName ;
+   LuaCheckTabFieldParam( L, 1, FLD_NAME, sName)
+  // lettura campo 'Parent' dalla tabella
+   string sParent ;
+   LuaCheckTabFieldParam( L, 1, FLD_PARENT, sParent)
+  // lettura campo 'ExitNbr' dalla tabella
+   int nExitNbr ;
+   LuaCheckTabFieldParam( L, 1, FLD_EXIT_NBR, nExitNbr)
+  // lettura campi 'PosN' e 'TDirN' per ogni uscita dalla tabella
+   MUEXITVECTOR vMuExit ;
+   vMuExit.reserve( nExitNbr) ;
+   for ( int i = 0 ; i < nExitNbr ;  ++ i) {
+     // lettura
+      string sPos = FLD_POS + ToString( i + 1) ;
+      Point3d ptPos ;
+      LuaCheckTabFieldParam( L, 1, sPos.c_str(), ptPos)
+      string sTDir = FLD_TDIR + ToString( i + 1) ;
+      Vector3d vtTDir ;
+      LuaCheckTabFieldParam( L, 1, sTDir.c_str(), vtTDir)
+     // inserimento nell'array
+      vMuExit.emplace_back( ptPos, vtTDir) ;
+   }
+  // lettura eventuale campo 'ADir' dalla tabella
+   Vector3d vtADir ;
+   LuaGetTabFieldParam( L, 1, FLD_ADIR, vtADir) ;
+  // lettura campo 'Geo' dalla tabella
+   string sGeo ;
+   LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
+  // lettura eventuale campo 'Aux' dalla tabella
+   STRVECTOR vsAux ;
+   LuaGetTabFieldParam( L, 1, FLD_AUX, vsAux) ;
+   LuaClearStack( L) ;
+
+  // info
+   string sOut = "LuaEmtTcPos : " + sName ;
+   LOG_DBG_INFO( GetEMkLogger(), sOut.c_str())
+
+  // verifico ci sia una macchina attiva
+   if ( m_pMchLua == nullptr)
+      return luaL_error( L, " Unknown Machine") ;
+
+  // carico i dati della posizione cambio utensile
+   if ( ! m_pMchLua->LoadMachineMultiTcPos( sName, sParent, vMuExit, vtADir, sGeo, vsAux))
+      return luaL_error( L, " Load Machine Multi Tc Position failed") ;
 
   // restituisco l'indice della posizione cambio utensile
    int nTcPosId = m_pMchLua->GetTcPosId( sName) ;
@@ -1395,7 +1478,7 @@ Machine::LuaEmtAddToolForVmill( lua_State* L)
 int
 Machine::LuaEmtMoveAxes( lua_State* L)
 {
-  // 4, ..., 16 parametri : nMoveType, sAx1, dPos1, dStep1 [, sAx2, dPos2, dStep2] [, sAx3, dPos3, dStep3] [, sAx4, dPos4, dStep4] [, sAx5, dPos5, dStep5]
+  // 4, ..., 31 parametri : nMoveType, sAx1, dPos1, dStep1 [, sAx2, dPos2, dStep2] ... [, sAx10, dPos10, dStep10]
    int nMoveType ;
    LuaCheckParam( L, 1, nMoveType)
    string sAx1 ;
@@ -1406,7 +1489,7 @@ Machine::LuaEmtMoveAxes( lua_State* L)
    LuaCheckParam( L, 4, dStep1) ;
    SAMVECTOR vAxNaEpSt ;
    vAxNaEpSt.emplace_back( sAx1, dEnd1, dStep1) ;
-   for ( int i = 0 ; i < 4 ; ++ i) {
+   for ( int i = 0 ; i < 9 ; ++ i) {
       int nInd = 5 + 3 * i ;
       string sAxN ;
       double dEndN ;
diff --git a/MachineLuaCL.cpp b/MachineLuaCL.cpp
index ffeeb57..f81ee6c 100644
--- a/MachineLuaCL.cpp
+++ b/MachineLuaCL.cpp
@@ -31,7 +31,7 @@ using namespace std ;
 int
 Machine::LuaEmtAddRapidStart( lua_State* L)
 {
-  // 6 parametri : nPathId, ptP, vtTool, vtCorr, vtAux, nFlag
+  // 6 o 7 parametri : nPathId, ptP, vtTool, vtCorr, vtAux, nFlag [, bToolShow]
    int nPathId ;
    LuaCheckParam( L, 1, nPathId)
    Point3d ptP ;
@@ -44,6 +44,8 @@ Machine::LuaEmtAddRapidStart( lua_State* L)
    LuaCheckParam( L, 5, vtAux)
    int nFlag ;
    LuaCheckParam( L, 6, nFlag)
+   bool bToolShow = false ;
+   LuaGetParam( L, 7, bToolShow) ;
    LuaClearStack( L) ;
   // verifico ci sia una macchina attiva valida
    if ( m_pMchLua == nullptr  ||
@@ -69,6 +71,7 @@ Machine::LuaEmtAddRapidStart( lua_State* L)
       pCam->SetEndPoint( ptP) ;
       pCam->SetFeed( 0) ;
       pCam->SetFlag( nFlag) ;
+      pCam->SetToolShow( bToolShow) ;
      // associo questo oggetto a quello geometrico
       m_pMchLua->m_pGeomDB->SetUserObj( nId, Release( pCam)) ;
    }
@@ -84,7 +87,7 @@ Machine::LuaEmtAddRapidStart( lua_State* L)
 int
 Machine::LuaEmtAddRapidMove( lua_State* L)
 {
-  // 7 parametri : nPathId, ptIni, ptFin, vtTool, vtCorr, vtAux, nFlag
+  // 7 o 8 parametri : nPathId, ptIni, ptFin, vtTool, vtCorr, vtAux, nFlag [, bToolShow]
    int nPathId ;
    LuaCheckParam( L, 1, nPathId)
    Point3d ptIni ;
@@ -99,6 +102,8 @@ Machine::LuaEmtAddRapidMove( lua_State* L)
    LuaCheckParam( L, 6, vtAux)
    int nFlag ;
    LuaCheckParam( L, 7, nFlag)
+   bool bToolShow = false ;
+   LuaGetParam( L, 8, bToolShow) ;
    LuaClearStack( L) ;
   // verifico ci sia una macchina attiva valida
    if ( m_pMchLua == nullptr  ||
@@ -124,6 +129,7 @@ Machine::LuaEmtAddRapidMove( lua_State* L)
       pCam->SetEndPoint( ptFin) ;
       pCam->SetFeed( 0) ;
       pCam->SetFlag( nFlag) ;
+      pCam->SetToolShow( bToolShow) ;
      // associo questo oggetto a quello geometrico
       m_pMchLua->m_pGeomDB->SetUserObj( nId, Release( pCam)) ;
    }
@@ -139,7 +145,7 @@ Machine::LuaEmtAddRapidMove( lua_State* L)
 int
 Machine::LuaEmtAddLinearMove( lua_State* L)
 {
-  // 8 parametri : nPathId, ptIni, ptFin, vtTool, vtCorr, vtAux, dFeed, nFlag
+  // 8 o 9 parametri : nPathId, ptIni, ptFin, vtTool, vtCorr, vtAux, dFeed, nFlag [, bToolShow]
    int nPathId ;
    LuaCheckParam( L, 1, nPathId)
    Point3d ptIni ;
@@ -156,6 +162,8 @@ Machine::LuaEmtAddLinearMove( lua_State* L)
    LuaCheckParam( L, 7, dFeed)
    int nFlag ;
    LuaCheckParam( L, 8, nFlag)
+   bool bToolShow = false ;
+   LuaGetParam( L, 9, bToolShow) ;
    LuaClearStack( L) ;
   // verifico ci sia una macchina attiva valida
    if ( m_pMchLua == nullptr  ||
@@ -181,6 +189,7 @@ Machine::LuaEmtAddLinearMove( lua_State* L)
       pCam->SetEndPoint( ptFin) ;
       pCam->SetFeed( dFeed) ;
       pCam->SetFlag( nFlag) ;
+      pCam->SetToolShow( bToolShow) ;
      // associo questo oggetto a quello geometrico
       m_pMchLua->m_pGeomDB->SetUserObj( nId, Release( pCam)) ;
    }
@@ -196,7 +205,7 @@ Machine::LuaEmtAddLinearMove( lua_State* L)
 int
 Machine::LuaEmtAddArcMove( lua_State* L)
 {
-  // 11 parametri : nPathId, ptIni, ptFin, ptCen, dAngCen, vtN, vtTool, vtCorr, vtAux, dFeed, nFlag
+  // 11 o 12 parametri : nPathId, ptIni, ptFin, ptCen, dAngCen, vtN, vtTool, vtCorr, vtAux, dFeed, nFlag [, bToolShow]
    int nPathId ;
    LuaCheckParam( L, 1, nPathId)
    Point3d ptIni ;
@@ -219,6 +228,8 @@ Machine::LuaEmtAddArcMove( lua_State* L)
    LuaCheckParam( L, 10, dFeed)
    int nFlag ;
    LuaCheckParam( L, 11, nFlag)
+   bool bToolShow = false ;
+   LuaGetParam( L, 12, bToolShow) ;
    LuaClearStack( L) ;
   // verifico ci sia una macchina attiva valida
    if ( m_pMchLua == nullptr  ||
@@ -252,6 +263,7 @@ Machine::LuaEmtAddArcMove( lua_State* L)
       pCam->SetNormDir( vtN) ;
       pCam->SetFeed( dFeed) ;
       pCam->SetFlag( nFlag) ;
+      pCam->SetToolShow( bToolShow) ;
      // associo questo oggetto a quello geometrico
       m_pMchLua->m_pGeomDB->SetUserObj( nId, Release( pCam)) ;
    }
diff --git a/Milling.cpp b/Milling.cpp
index deccdf0..1c1c71f 100644
--- a/Milling.cpp
+++ b/Milling.cpp
@@ -2369,7 +2369,7 @@ Milling::AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTo
            // se attacco a zigzag o a spirale, l'elevazione va nell'attacco
             if ( IsLeadInHelixOrZigzag()) {
                ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ;
-               dStElev = - LIO_ELEV_TOL ;
+               dStElev = -LIO_ELEV_TOL ;
             }
            // approccio al punto iniziale
             if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutStart, bAboveStart)) {
@@ -2815,7 +2815,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                      return false ;
                }
               // se attacco a zigzag o a spirale, non affondo
-               else if ( IsLeadInHelixOrZigzag()) {
+               else if ( IsLeadInHelixOrZigzagOrGlide()) {
                   ptP1 += vtTool * ( dStElev + LIO_ELEV_TOL) ;
                   dStElev = - LIO_ELEV_TOL ;
                }
@@ -2888,6 +2888,8 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
            // se non c'è attacco a zigzag o a spirale oppure ultimo step, aggiungo uscita
             Point3d ptP1 = ptEnd ;
             if ( ! IsLeadInHelixOrZigzag()  ||  k == nStep) {
+               if ( k != nStep  &&  GetLeadInType() == MILL_LI_GLIDE)
+                  dEndElev = -LIO_ELEV_TOL ;
                SetFeed( GetEndFeed()) ;
                if ( ! AddLeadOut( ptEnd, vtEnd, vtTool, dEndElev, bInvert, pCompo, bSplitArcs, ptP1)) {
                   m_pMchMgr->SetLastError( 2311, "Error in Milling : LeadOut not computable") ;
@@ -3017,7 +3019,7 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
    AdjustOscillParams( pCompo, bPathOscEnable, dOscRampLen, dOscFlatLen) ;
 
   // percorso speciale : chiuso e con attacco a spirale o zigzag
-   bool bSpecial = pCompo->IsClosed() && IsLeadInHelixOrZigzag() ;
+   bool bSpecial = ( pCompo->IsClosed() && IsLeadInHelixOrZigzagOrGlide()) ;
 
   // percorso senza retrazioni intermedie : chiuso e con attacco e uscita con punti esterni coincidenti
    bool bMidRetract = true ;
@@ -3026,6 +3028,8 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
       int nLoType = GetLeadOutType() ;
       if ( nLiType == MILL_LI_NONE  &&  ( nLoType == MILL_LO_NONE  ||  nLoType == MILL_LO_AS_LI))
          bMidRetract = false ;
+      if ( nLiType == MILL_LI_GLIDE)
+         bMidRetract = false ;
       if ( ( nLiType == MILL_LI_TANGENT  ||  nLiType == MILL_LI_LINEAR  ||  nLiType == MILL_LI_TG_PERP)  &&
            nLoType == MILL_LO_AS_LI  &&
            abs( m_Params.m_dLiTang) < EPS_SMALL)
@@ -3108,12 +3112,20 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
 
   // ciclo sugli step
    bool bOk = true ;
-   int nMaxInd = pCompo->GetCurveCount() - 1 ;
    for ( int k = 1 ; k <= nStep ; ++ k) {
       int j = ( bStepUp ? nStep - k + 1 : k) ;
       m_dCurrTabsLen = 0 ;
       m_dCurrOscillLen = 2 * dOscRampLen + 1.5 * dOscFlatLen ;
+     // se percorso chiuso e attacco ad inseguimento sposto inizio
+      if ( k > 1  &&  pCompo->IsClosed()  &&  GetLeadInType() == MILL_LI_GLIDE) {
+         double dU ;
+         if ( pCompo->GetParamAtLength( m_Params.m_dLiTang, dU)) {
+            const_cast<ICurveComposite*>( pCompo)->ChangeStartPoint( dU) ;
+            const_cast<ICurveComposite*>( pCompo)->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL, false) ;
+         }
+      }
      // ciclo sulle curve elementari
+      int nMaxInd = pCompo->GetCurveCount() - 1 ;
       for ( int i = 0 ; i <= nMaxInd ; ++ i) {
         // curva corrente
          const ICurve* pCrvC = pCompo->GetCurve( i) ;
@@ -4059,33 +4071,34 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
    double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
    double dElevZ = vtAppr.z * dElev ;
    if ( ! bAboveStart  &&  ! bBottomStart  &&  dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
+      Point3d ptP1 = ptP + vtAppr * ( dElev + dAppr) ;
      // se distanza di sicurezza minore di distanza di inizio
       if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
         // 1 -> punto sopra inizio
-         Point3d ptP1 = ptP + vtAppr * ( dElev + dAppr) ;
          if ( ( ! m_bAggrBottom  &&  AddRapidStart( ptP1) == GDB_ID_NULL)  ||
               ( m_bAggrBottom  &&  AddRapidMove( ptP1) == GDB_ID_NULL))
             return false ;
       }
       else {
-        // 1a -> punto sopra inizio
-         Point3d ptP1b = ptP + vtAppr * ( dElev + dAppr) ;
-         Point3d ptP1a = ptP1b + vtAppr * ( dSafeDist - dAppr) ;
+        // 1a -> punto molto sopra inizio
+         Point3d ptP1a = ptP1 + vtAppr * ( dSafeDist - dAppr) ;
          if ( ( ! m_bAggrBottom  &&  AddRapidStart( ptP1a) == GDB_ID_NULL)  ||
               ( m_bAggrBottom  &&  AddRapidMove( ptP1a) == GDB_ID_NULL))
             return false ;
-        // 1b -> punto appena sopra inizio
-         if ( ( dElev + dAppr) > EPS_SMALL) {
+        // 1 -> punto sopra inizio
+         if ( ( dElev + dAppr) > 10 * EPS_SMALL  ||  (( dElev + dAppr) > -EPS_ZERO  &&  dAppr > EPS_SMALL)) {
             SetFlag( 0) ;
-            if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
+            if ( AddRapidMove( ptP1) == GDB_ID_NULL)
                return false ;
          }
+         else
+            ptP1 = ptP1a ;
       }
      // affondo al punto iniziale
       SetFlag( 0) ;
       bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_NOTIP  ||  m_TParams.m_nType == TT_MILL_POLISHING) ;
       SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
-      if ( AddLinearMove( ptP) == GDB_ID_NULL)
+      if ( ! AreSamePointApprox( ptP1, ptP)  &&  AddLinearMove( ptP) == GDB_ID_NULL)
          return false ;
    }
   // sono sopra il pezzo ma non abbastanza
diff --git a/Milling.h b/Milling.h
index 86b36a3..93b2273 100644
--- a/Milling.h
+++ b/Milling.h
@@ -147,6 +147,9 @@ class Milling : public Machining
       bool IsLeadInHelixOrZigzag() const
          { int nType = GetLeadInType() ;
            return ( nType == MILL_LI_ZIGZAG  ||  nType == MILL_LI_HELIX) ; }
+      bool IsLeadInHelixOrZigzagOrGlide() const
+         { int nType = GetLeadInType() ;
+           return ( nType == MILL_LI_ZIGZAG  ||  nType == MILL_LI_HELIX  ||  nType == MILL_LI_GLIDE) ; }
       bool LeadInRawIsOk( void) const
          { if ( ( m_TParams.m_nType & TF_SAWBLADE) != 0)
               return false ;
diff --git a/Operation.cpp b/Operation.cpp
index 1cd5e80..f7b7c44 100644
--- a/Operation.cpp
+++ b/Operation.cpp
@@ -33,6 +33,7 @@
 #include "/EgtDev/Include/EGkGeomDB.h"
 #include "/EgtDev/Include/EGkCDeBoxClosedSurfTm.h"
 #include "/EgtDev/Include/EGkCDeCylClosedSurfTm.h"
+#include "/EgtDev/Include/EGkCAvToolSurfTm.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
@@ -379,6 +380,8 @@ Operation::GetElevation( int nPhase, const Point3d& ptP1, const Point3d& ptP2, c
    return true ;
 }
 
+#if 1
+
 //----------------------------------------------------------------------------
 bool
 Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad,
@@ -459,6 +462,102 @@ Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool,
    return true ;
 }
 
+#else
+
+//----------------------------------------------------------------------------
+bool
+Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad,
+                         const Vector3d& vtDir, double& dElev) const
+{
+   const double STD_TOOL_LEN = 100 ;
+   return GetElevation( nPhase, ptP, vtTool, dRad, STD_TOOL_LEN, vtDir, dElev) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Operation::GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad, double dLen,
+                         const Vector3d& vtDir, double& dElev) const
+{
+  // risultato di default
+   dElev = 0 ;
+  // verifico oggetti base
+   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
+      return false ;
+  // inizializzo elevazioni per ogni grezzo
+   INTDBLVECTOR vRawElev ;
+  // ciclo sui grezzi della fase
+   int nRawId = m_pMchMgr->GetFirstRawPart() ;
+   while ( nRawId != GDB_ID_NULL) {
+     // verifico che il grezzo compaia nella fase
+      if ( m_pMchMgr->VerifyRawPartPhase( nRawId, nPhase)) {
+        // recupero la trimesh del grezzo
+         int nStmId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
+         ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nStmId)) ;
+         if ( pStm != nullptr) {
+           // recupero il riferimento della trimesh
+            Frame3d frStm ;
+            m_pGeomDB->GetGlobFrame( nStmId, frStm) ;
+           // porto posizione e direzioni in questo riferimento
+            Point3d ptPL = GetToLoc( ptP, frStm) ;
+            Vector3d vtToolL = GetToLoc( vtTool, frStm) ;
+            Vector3d vtDirL = GetToLoc( vtDir, frStm) ;
+           // determino quanto allontanarsi
+            PtrOwner<ICAvToolSurfTm> pCAvTlStm( CreateCAvToolSurfTm()) ;
+            if ( IsNull( pCAvTlStm))
+               return false ;
+            pCAvTlStm->SetStdTool( dLen, dRad, 0) ;
+            pCAvTlStm->SetSurfTm( *pStm) ;
+            double dDist = 0 ;
+            // per Collision Avoid il punto di riferimento non è il tip dell'utensile ma il naso mandrino
+            if ( ! pCAvTlStm->TestPosition( ptPL + dLen * vtToolL, vtToolL, vtDirL, dDist))
+               return false ;
+            if ( dDist > 0)
+               vRawElev.emplace_back( nStmId, dDist) ;
+         }
+      }
+     // passo al grezzo successivo
+      nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
+   }
+  // se trovate elevazioni
+   if ( ! vRawElev.empty()) {
+     // ordino il vettore secondo l'elevazione crescente
+      sort( vRawElev.begin(), vRawElev.end(), []( const INTDBL& a, const INTDBL& b)
+                                                  { return a.second < b.second ; }) ;
+     // box dell'utensile nella posizione iniziale
+      BBox3d b3Tool ;
+      b3Tool.Add( ptP) ;
+      b3Tool.Add( ptP + dLen * vtTool) ;
+      if ( vtTool.IsX())
+         b3Tool.Expand( 0, dRad, dRad) ;
+      else if ( vtTool.IsY())
+         b3Tool.Expand( dRad, 0, dRad) ;
+      else if ( vtTool.IsZ())
+         b3Tool.Expand( dRad, dRad, 0) ;
+      else {
+         double dExpandX = dRad * sqrt( 1 - vtTool.x * vtTool.x) ;
+         double dExpandY = dRad * sqrt( 1 - vtTool.y * vtTool.y) ;
+         double dExpandZ = dRad * sqrt( 1 - vtTool.z * vtTool.z) ;
+         b3Tool.Expand( dExpandX, dExpandY, dExpandZ) ;
+      }
+      b3Tool.Expand( MAX_DIST_RAW) ;
+     // verifico la reale interferenza dell'utensile con i diversi grezzi
+      for ( int i = 0 ; i < vRawElev.size() ; ++ i) {
+        // box del grezzo
+         BBox3d b3Raw ; 
+         m_pGeomDB->GetGlobalBBox( vRawElev[i].first, b3Raw) ;
+        // confronto con il box dell'utensile nella posizione precedente
+         BBox3d b3CurrTool = b3Tool ;
+         b3CurrTool.Translate( dElev * vtDir) ;
+         if ( b3Raw.Overlaps( b3CurrTool))
+            dElev = vRawElev[i].second ;
+      }
+   }
+
+   return true ;
+}
+
+#endif
+
 //----------------------------------------------------------------------------
 bool
 Operation::GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
@@ -917,8 +1016,12 @@ Operation::GetDistanceFromRawSide( int nPhase, const Point3d& ptP, const Vector3
    IntersCurveCurve intCC( *pRay, *pOut) ;
    int  nInters = intCC.GetIntersCount() ;
    IntCrvCrvInfo aInfo ;
-   if ( nInters > 0  &&  intCC.GetIntCrvCrvInfo( nInters - 1, aInfo))
-      dDist = aInfo.IciA[0].dU * RAY_LEN - EXTRA_LEN ;
+   if ( nInters > 0  &&  intCC.GetIntCrvCrvInfo( nInters - 1, aInfo)) {
+      if ( ! aInfo.bOverlap)
+         dDist = aInfo.IciA[0].dU * RAY_LEN - EXTRA_LEN ;
+      else
+         dDist = aInfo.IciA[1].dU * RAY_LEN - EXTRA_LEN ;
+   }
    else
       dDist = 0 ;
    return true ;
@@ -1698,6 +1801,11 @@ Operation::CalcMirrorByDouble( int nClId, const std::string& sUserNotes)
   // eseguo mirroring rispetto a piano opportuno
    m_pGeomDB->MirrorGroup( nDblId, ptOn, vtNorm) ;
 
+  // se presente una differenza in Z, eseguo spostamento
+   double dDeltaZ ;
+   if ( GetValInNotes( sUserNotes, "DeltaZ", dDeltaZ)  &&  abs( dDeltaZ) > EPS_SMALL)
+      m_pGeomDB->TranslateGlob( nDblId, Vector3d( 0, 0, dDeltaZ)) ;
+
    return true ;
 }
 
@@ -2120,7 +2228,7 @@ Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes,
                else
                   m_pMchMgr->GetNearestAngleInStroke( i, vAxRotPrec[i], vAng1[i]) ;
                if ( abs( vAng1[i] - vAxRotPrec[i]) > dAngDeltaMinForHome)
-                  vAng1[i] = m_pMchMgr->GetNearestAngleInStroke( i, vAxRotHome[i], vAng1[i]) ;
+                  m_pMchMgr->GetNearestAngleInStroke( i, vAxRotHome[i], vAng1[i]) ;
             }
            // se sol.ne indeterminata (sempre il primo asse libero), assegno il precedente
             if ( nRStat < 0  &&  vAng1.size() >= 1) {
@@ -2171,13 +2279,13 @@ Operation::CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes,
                else
                   m_pMchMgr->GetNearestAngleInStroke( i, vAxRotPrec[i], vAng1[i]) ;
                if ( abs( vAng1[i] - vAxRotPrec[i]) > dAngDeltaMinForHome)
-                  vAng1[i] = m_pMchMgr->GetNearestAngleInStroke( i, vAxRotHome[i], vAng1[i]) ;
+                  m_pMchMgr->GetNearestAngleInStroke( i, vAxRotHome[i], vAng1[i]) ;
                if ( bRotContOnNext)
                   vAng2[i] = AngleNearAngle( vAng2[i], vAxRotPrec[i]) ;
                else
                   m_pMchMgr->GetNearestAngleInStroke( i, vAxRotPrec[i], vAng2[i]) ;
                if ( abs( vAng2[i] - vAxRotPrec[i]) > dAngDeltaMinForHome)
-                  vAng2[i] = m_pMchMgr->GetNearestAngleInStroke( i, vAxRotHome[i], vAng2[i]) ;
+                  m_pMchMgr->GetNearestAngleInStroke( i, vAxRotHome[i], vAng2[i]) ;
             }
            // se sol.ne indeterminata (sempre il primo asse libero), assegno il precedente
             if ( nRStat < 0  &&  vAng1.size() >= 1) {
diff --git a/OutputConst.h b/OutputConst.h
index 6398959..468f5ef 100644
--- a/OutputConst.h
+++ b/OutputConst.h
@@ -60,6 +60,7 @@ static const std::string GVAR_TOOL = ".TOOL" ;           // (string)   nome uten
 static const std::string GVAR_HEAD = ".HEAD" ;           // (string)   nome testa
 static const std::string GVAR_EXIT = ".EXIT" ;           // (int)      indice uscita
 static const std::string GVAR_TCPOS = ".TCPOS" ;         // (string)   eventuale posizione utensile nel TC
+static const std::string GVAR_TTYPE = ".TTYPE" ;         // (int)      tipo utensile
 static const std::string GVAR_TCOMP = ".TCOMP" ;         // (int)      numero correttore utensile
 static const std::string GVAR_TDIAM = ".TDIAM" ;         // (num)      diametro utensile
 static const std::string GVAR_TTOTDIAM = ".TTOTDIAM" ;   // (num)      diametro totale utensile
diff --git a/Pocketing.cpp b/Pocketing.cpp
index 3406218..ca1dd9d 100644
--- a/Pocketing.cpp
+++ b/Pocketing.cpp
@@ -8775,32 +8775,34 @@ Pocketing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafe
   // se sopra attacco c'è spazio per sicurezza o approccio
    double dSafeDist = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
    if ( ! bBottomOutStart  &&  dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
+      Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ;
      // se distanza di sicurezza minore di distanza di inizio
       if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
         // 1 -> punto sopra inizio
-         Point3d ptP1 = ptP + vtTool * ( dElev + dAppr) ;
          if ( ( ! m_bAggrBottom  &&  AddRapidStart( ptP1) == GDB_ID_NULL)  ||
               ( m_bAggrBottom  &&  AddRapidMove( ptP1) == GDB_ID_NULL))
             return false ;
       }
       else {
-        // 1a -> punto sopra inizio
-         Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ;
-         Point3d ptP1a = ptP1b + vtTool * ( dSafeDist - dAppr) ;
+        // 1a -> punto molto sopra inizio
+         Point3d ptP1a = ptP1 + vtTool * ( dSafeDist - dAppr) ;
          if ( ( ! m_bAggrBottom  &&  AddRapidStart( ptP1a) == GDB_ID_NULL)  ||
               ( m_bAggrBottom  &&  AddRapidMove( ptP1a) == GDB_ID_NULL))
             return false ;
-        // 1b -> punto appena sopra inizio
-         if ( ( dElev + dAppr) > EPS_SMALL) {
+        // 1 -> punto sopra inizio
+         if ( ( dElev + dAppr) > 10 * EPS_SMALL  ||  (( dElev + dAppr) > -EPS_ZERO  &&  dAppr > EPS_SMALL)) {
             SetFlag( 0) ;
-            if ( AddRapidMove( ptP1b) == GDB_ID_NULL)
+            if ( AddRapidMove( ptP1) == GDB_ID_NULL)
                return false ;
          }
+         else
+            ptP1 = ptP1a ;
       }
      // affondo al punto iniziale
       SetFlag( 0) ;
-      SetFeed( bOutStart ? GetStartFeed() : GetTipFeed()) ;
-      if ( AddLinearMove( ptP) == GDB_ID_NULL)
+      bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_NOTIP) ;
+      SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
+      if ( ! AreSamePointApprox( ptP1, ptP)  &&  AddLinearMove( ptP) == GDB_ID_NULL)
          return false ;
    }
    else {
diff --git a/Processor.cpp b/Processor.cpp
index 914daec..aca3ace 100644
--- a/Processor.cpp
+++ b/Processor.cpp
@@ -603,6 +603,7 @@ Processor::ProcessToolData( void)
       string sHead ;
       int    nExit ;
       string sTcPos ;
+      int    nType ;
       int    nComp ;
       double dDiam ;
       double dTDiam ;
@@ -611,7 +612,7 @@ Processor::ProcessToolData( void)
       double dDist ;
       double dMaxSpeed ;
       MyToolData( void)
-         : sName(), sHead(), nExit( 0), sTcPos(), nComp(0), dDiam( 0), dLen( 0), dDist( 0), dMaxSpeed( 0) {}
+         : sName(), sHead(), nExit( 0), sTcPos(), nType(0), nComp(0), dDiam( 0), dLen( 0), dDist( 0), dMaxSpeed( 0) {}
    } ;
    typedef vector<MyToolData>   TDATAVECTOR ;
    TDATAVECTOR vTdata ;
@@ -636,6 +637,7 @@ Processor::ProcessToolData( void)
             m_pMchMgr->TdbGetCurrToolParam( TPA_HEAD, Tdata.sHead) ;
             m_pMchMgr->TdbGetCurrToolParam( TPA_EXIT, Tdata.nExit) ;
             m_pMchMgr->TdbGetCurrToolParam( TPA_TCPOS, Tdata.sTcPos) ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_TYPE, Tdata.nType) ;
             m_pMchMgr->TdbGetCurrToolParam( TPA_CORR, Tdata.nComp) ;
             m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, Tdata.dDiam) ;
             m_pMchMgr->TdbGetCurrToolParam( TPA_TOTDIAM, Tdata.dTDiam) ;
@@ -674,7 +676,8 @@ Processor::ProcessToolData( void)
          bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, nExit) ;
          bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, sTcPos) ;
          if ( m_pMchMgr->TdbSetCurrTool( sTool)) {
-            int nComp ; double dDiam ; double dTDiam ; double dLen ; double dTLen ; double dDist ; double dMaxSpeed ;
+            int nType ; int nComp ; double dDiam ; double dTDiam ; double dLen ; double dTLen ; double dDist ; double dMaxSpeed ;
+            m_pMchMgr->TdbGetCurrToolParam( TPA_TYPE, nType) ;
             m_pMchMgr->TdbGetCurrToolParam( TPA_CORR, nComp) ;
             m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, dDiam) ;
             m_pMchMgr->TdbGetCurrToolParam( TPA_TOTDIAM, dTDiam) ;
@@ -682,6 +685,7 @@ Processor::ProcessToolData( void)
             m_pMchMgr->TdbGetCurrToolParam( TPA_TOTLEN, dTLen) ;
             m_pMchMgr->TdbGetCurrToolParam( TPA_DIST, dDist) ;
             m_pMchMgr->TdbGetCurrToolParam( TPA_MAXSPEED, dMaxSpeed) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTYPE, nType) ;
             bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCOMP, nComp) ;
             bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIAM, dDiam) ;
             bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTDIAM, dTDiam) ;
@@ -721,6 +725,7 @@ Processor::ProcessToolData( void)
             bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_HEAD, vTdata[i].sHead) ;
             bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, vTdata[i].nExit) ;
             bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, vTdata[i].sTcPos) ;
+            bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTYPE, vTdata[i].nType) ;
             bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCOMP, vTdata[i].nComp) ;
             bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIAM, vTdata[i].dDiam) ;
             bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TTOTDIAM, vTdata[i].dTDiam) ;
diff --git a/SetupMgr.cpp b/SetupMgr.cpp
index 5747235..97af17c 100644
--- a/SetupMgr.cpp
+++ b/SetupMgr.cpp
@@ -181,16 +181,12 @@ SetupMgr::Import( const string& sFileName)
         m_pMchMgr->GetCurrMachGroup() == GDB_ID_NULL)
       return false ;
 
-  // recupero il gruppo di setup
-   int nSetupId = m_pMchMgr->GetCurrSetupGroupId() ;
-
   // inizializzo lo scanner
    Scanner TheScanner ;
    if ( ! TheScanner.Init( sFileName, ";"))
       return false ;
 
   // eseguo la lettura dei campi di attrezzaggio
-   int nPos = 1 ;
    string sLine ;
    while ( TheScanner.GetLine( sLine)) {
      // salto dichiarazione sezione
@@ -228,8 +224,6 @@ SetupMgr::Import( const string& sFileName)
          stuData.m_nExit = 0 ;
          m_vStuData.emplace_back( stuData) ;
       }
-     // passo alla successiva posizione
-      ++ nPos ;
    }
 
    return true ;   
@@ -277,14 +271,20 @@ SetupMgr::GetPosData( int nPos, string& sTcPos, string& sHead, int& nExit, strin
 bool
 SetupMgr::GetToolData( const string& sName, string& sTcPos, string& sHead, int& nExit, int* pnPos) const
 {
+  // reset valori di ritorno
+   sTcPos.clear() ;
+   sHead.clear() ;
+   nExit = 0 ;
+   if ( pnPos != nullptr)
+      *pnPos = 0 ;
   // verifico validità utensile
    if ( IsEmptyOrSpaces( sName))
       return false ;
   // cerco l'utensile
    int nI = - 1 ;
-   for ( size_t i = 0 ; i < m_vStuData.size() ; ++ i) {
+   for ( int i = 0 ; i < int( m_vStuData.size()) ; ++ i) {
       if ( m_vStuData[i].m_nExit > 0  &&  EqualNoCase( sName, m_vStuData[i].m_sName)) {
-         nI = int( i) ;
+         nI = i ;
          break ;
       }
    }
@@ -318,11 +318,21 @@ SetupMgr::GetToolName( const string& sHead, int nExit, string& sName) const
 bool
 SetupMgr::GetToolsInSetupPos( const string& sTcPos, STRVECTOR& vsTools) const
 {
+  // default vettore vuoto
    vsTools.clear() ;
-  // eseguo ricerca
+  // verifico macchina
+   if ( m_pMachine == nullptr)
+      return false ;
+  // eseguo ricerca (con inserimento nel vettore secondo indice dell'uscita)
    for ( int i = 0 ; i < int( m_vStuData.size()) ; ++ i) {
-      if ( EqualNoCase( sTcPos, m_vStuData[i].m_sTcPos)) {
-         vsTools.emplace_back( m_vStuData[i].m_sName) ;
+      if ( ! IsEmptyOrSpaces( m_vStuData[i].m_sHead)  &&  EqualNoCase( sTcPos, m_vStuData[i].m_sTcPos)) {
+         if ( vsTools.empty()) {
+            int nExitCnt = m_pMachine->GetHeadExitCount( m_vStuData[i].m_sHead) ;
+            vsTools.resize( nExitCnt) ;
+         }
+         int nExit = m_vStuData[i].m_nExit ;
+         if ( nExit > 0  &&  nExit <= int( vsTools.size()))
+            vsTools[nExit - 1] = m_vStuData[i].m_sName ;
       }
    }
    return true ;
diff --git a/Simulator.cpp b/Simulator.cpp
index 8d1c24b..d1cb8af 100644
--- a/Simulator.cpp
+++ b/Simulator.cpp
@@ -125,12 +125,17 @@ Simulator::Start( bool bFirst)
    m_pMchMgr->ResetLastError() ;
    m_pMchMgr->ResetWarnings() ;
 
-  // Forzo aggiornamento attrezzaggio della macchinata
-   bool bOk = m_pMchMgr->UpdateCurrSetup() ;
+   bool bOk = true ;
 
-  // Se avvio vero, verifico attrezzaggio
-   if ( bFirst  &&  ! VerifySetup())
-      bOk = false ;
+  // Se avvio vero
+   if ( bFirst) {
+     // Forzo aggiornamento attrezzaggio della macchinata
+      if ( ! m_pMchMgr->UpdateCurrSetup())
+         bOk = false ;
+     // Verifico attrezzaggio
+      if ( ! VerifySetup())
+         bOk = false ;
+   }
 
   // Reset utensile, interpolazione e assi correnti
    m_sTool.clear() ;
@@ -141,6 +146,7 @@ Simulator::Start( bool bFirst)
    ResetInterpolation() ;
    ResetAxes() ;
    ResetAuxAxes() ;
+
   // porto la macchina in home
    if ( ! GoHome())
       bOk = false ;
@@ -994,8 +1000,18 @@ Simulator::ManageSingleMove( int& nStatus, double& dMove)
          double dSqCoeff = (( i < 3) ? 1 : 100) ;
          dSqDist += dSqCoeff * ( AxesEnd[i] - m_AxesVal[i]) * ( AxesEnd[i] - m_AxesVal[i]) ;
       }
+     // Calcolo distanza di movimento eventuali assi ausiliari
+      double dSqDistAux = 0 ;     
+      for ( int i = 0 ; i < int( m_AuxAxesName.size()) ; ++ i) {
+         if ( m_AuxAxesLink[i] != 0)
+            continue ;
+        // coefficiente moltiplicativo per differenziare assi lineari e rotanti
+         double dSqCoeff = ( m_AuxAxesLinear[i] ? 1 : 100) ;
+         dSqDistAux += dSqCoeff * ( m_AuxAxesEnd[i] - m_AuxAxesVal[i]) * ( m_AuxAxesEnd[i] - m_AuxAxesVal[i]) ;
+      }
+     // Considero il massimo delle due distanze
       double dPrevCoeff = m_dCoeff ;
-      double dDist = sqrt( dSqDist) ;
+      double dDist = sqrt( max( dSqDist, dSqDistAux)) ;
       if ( dDist > EPS_SMALL) {
          double dStep = min( ( nMoveType == 0 ? 2 : 1) * m_dStep, MAX_STEP) ;
          int nStep = max( int( dDist / dStep), 1) ;