EgtMachKernel (Preview) :

- in Drilling in doppio aggiunta nuova gestione per punte in opposizione e aggiunta gestione della realtiva preview.
- correzioni varie.

Axis.cpp

@@ -50,6 +50,7 @@ Axis::Clone( void) const
             pAx->m_bInvert = m_bInvert ;
             pAx->m_dOffset = m_dOffset ;
             pAx->m_nType = m_nType ;
+            pAx->m_nUse = m_nUse ;
             pAx->m_ptPos = m_ptPos ;
             pAx->m_vtDir = m_vtDir ;
             pAx->m_Stroke = m_Stroke ;
@@ -74,6 +75,7 @@ Axis::Dump( string& sOut, bool bMM, const char* szNewLine) const
    sOut += "Name=" + m_sName + szNewLine ;
    sOut += "Token=" + m_sToken + szNewLine ;
    sOut += "Type=" + ToString( m_nType) + szNewLine ;
+   sOut += "Use=" + ToString( m_nUse) + szNewLine ;
    sOut += "Pos=" + ToString( GetInUiUnits( m_ptPos, bMM), 4) + szNewLine ;
    sOut += "Dir=" + ToString( m_vtDir) + szNewLine ;
    if ( m_nType == MCH_AT_LINEAR)
@@ -113,20 +115,21 @@ Axis::GetGeomDB( void) const
 //----------------------------------------------------------------------------
 Axis::Axis( void)
    : m_nOwnerId( GDB_ID_NULL), m_pGeomDB( nullptr), m_bInvert( false), m_dOffset( 0),
-     m_nType( MCH_AT_NONE), m_Stroke( {{0,0}}), m_dHomeVal( 0), m_dCurrVal( 0)
+     m_nType( MCH_AT_NONE), m_nUse( MCH_AU_NONE), m_Stroke( {{0,0}}), m_dHomeVal( 0), m_dCurrVal( 0)
 {
 }
 
 //----------------------------------------------------------------------------
 bool
 Axis::Set( const string& sName, const string& sToken, bool bInvert, double dOffset,
-           int nType, const Point3d& ptPos, const Vector3d& vtDir, const STROKE& Stroke, double dHome)
+           int nType, int nUse, const Point3d& ptPos, const Vector3d& vtDir, const STROKE& Stroke, double dHome)
 {
    m_sName = sName ;
    m_sToken = sToken ;
    m_bInvert = bInvert ;
    m_dOffset = dOffset ;
-   m_nType = nType ;
+   m_nType = ( nType == MCH_AT_ROTARY ? MCH_AT_ROTARY : MCH_AT_LINEAR) ;
+   m_nUse = (( nUse == MCH_AU_DISPOSITION  ||  nUse == MCH_AU_AUXILIAR) ? nUse : MCH_AU_GENERAL) ;
    m_ptPos = ptPos ;
    m_vtDir = vtDir ;
    m_Stroke = Stroke ;

Axis.h

@@ -1,13 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2022
+//  EgalTech 2015-2025
 //----------------------------------------------------------------------------
-// File : Axis.h           Data : 21.09.22          Versione : 2.4i
+// File : Axis.h           Data : 17.04.25          Versione : 2.7d2
 // Contenuto : Dichiarazione della classe Axis.
 //
 //
 //
 // Modifiche : 24.05.15 DS Creazione modulo.
-//
+//             17.04.25 DS Aggiunto campo Use.
 //
 //----------------------------------------------------------------------------
 
@@ -31,7 +31,7 @@ class Axis : public IUserObj
    public :
       Axis( void) ;
       bool Set( const std::string& sName, const std::string& sToken, bool bInvert, double dOffset,
-                int nType, const Point3d& ptPos, const Vector3d& vtDir, const STROKE& Stroke, double dHome) ;
+                int nType, int nUse, const Point3d& ptPos, const Vector3d& vtDir, const STROKE& Stroke, double dHome) ;
       bool Modify( const Point3d& ptPos, double dAxisMaxAdjust) ;
       bool Modify( const Vector3d& vtDir, double dAxisMaxRotAdj) ;
       bool Modify( const STROKE& Stroke) ;
@@ -48,6 +48,8 @@ class Axis : public IUserObj
               { return m_dOffset ; }
       int  GetType( void) const
               { return m_nType ; }
+      int  GetUse( void) const
+              { return m_nUse ; }
       const Point3d& GetPos( void) const
               { return m_ptPos ; }
       const Vector3d& GetDir( void) const
@@ -67,6 +69,7 @@ class Axis : public IUserObj
       bool        m_bInvert ;
       double      m_dOffset ;
       int         m_nType ;
+      int         m_nUse ;
       Point3d     m_ptPos ;
       Vector3d    m_vtDir ;
       STROKE      m_Stroke ;

CamData.h

@@ -72,6 +72,8 @@ class CamData : public IUserObj
               { m_bToolShow = bShow ; return true ; }
       int             GetMoveType( void) const
                          { return m_nMove ; }
+      bool            IsRapid( void) const
+                         { return ( m_nMove == 0) ; }
       bool            IsLine( void) const
                          { return ( m_nMove == 0  ||  m_nMove == 1) ; }
       bool            IsArc( void) const

Chiseling.cpp

@@ -44,6 +44,7 @@ using namespace std ;
 // 2910 = "Error in Chiseling : link movements not calculable"
 // 2911 = "Error in Chiseling : link outstroke xx"
 // 2912 = "Error in Chiseling : post apply not calculable"
+// 2913 = "Error in Chiseling : special apply not calculable"
 // 2951 = "Warning in Chiseling : Skipped entity (xx)"
 // 2952 = "Warning in Chiseling : Plunges not found"
 // 2953 = "Warning in Chiseling : Tool name changed (xx)"
@@ -397,7 +398,8 @@ Chiseling::SetGeometry( const SELVECTOR& vIds)
   // verifico validità gestore DB geometrico
    if ( m_pGeomDB == nullptr)
       return false ;
-  // reset della geometria corrente
+  // copia temporanea e reset della geometria corrente
+   SELVECTOR vOldId = m_vId ;
    m_vId.clear() ;
   // verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve o tutte facce)
    int nType = GEO_NONE ;
@@ -413,7 +415,8 @@ Chiseling::SetGeometry( const SELVECTOR& vIds)
       m_vId.emplace_back( Id) ;
    }
   // aggiorno lo stato
-   m_nStatus |= MCH_ST_GEO_MODIF ;
+   if ( m_vId != vOldId)
+      m_nStatus |= MCH_ST_GEO_MODIF ;
   // restituisco presenza geometria da lavorare
    return ( ! m_vId.empty()  ||  vIds.empty()) ;
 }
@@ -495,15 +498,17 @@ Chiseling::Apply( bool bRecalc, bool bPostApply)
       return false ;
 
   // aggiorno dati geometrici dell'utensile
-   bool bToolChanged = true ;
-   if ( ! UpdateToolData( &bToolChanged)) {
+   if ( ! UpdateToolData()) {
       m_pMchMgr->SetLastError( 2901, "Error in Chiseling : UpdateToolData failed") ;
       return false ;
    }
 
+  // se modificata geometria, necessario ricalcolo
+   if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
+      bRecalc = true ;
+
   // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ! bToolChanged  &&  
-        ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
+   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
      // confermo i percorsi di lavorazione
       m_nChisels = nCurrChisels ;
       string sLog = string( "Chiseling apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
@@ -616,6 +621,19 @@ Chiseling::Update( bool bPostApply)
       return false ;
    }
 
+  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+   CalcAndSetAxesBBox() ;
+
+  // esecuzione eventuali personalizzazioni speciali
+   string sSpecErr ;
+   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
+      if ( ! IsEmptyOrSpaces( sSpecErr))
+         m_pMchMgr->SetLastError( 2913, sSpecErr) ;
+      else
+         m_pMchMgr->SetLastError( 2913, "Error in Chiseling : special apply not calculable") ;
+      return false ;
+   }
+
   // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
    if ( ! AdjustStartEndMovements()) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
@@ -626,14 +644,11 @@ Chiseling::Update( bool bPostApply)
       return false ;
    }
 
-  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
-   CalcAndSetAxesBBox() ;
-
-  // esecuzione eventuali personalizzazioni
-   string sErr ;
-   if ( bPostApply  &&  ! PostApply( sErr)) {
-      if ( ! IsEmptyOrSpaces( sErr))
-         m_pMchMgr->SetLastError( 2912, sErr) ;
+  // esecuzione eventuali personalizzazioni finali
+   string sPostErr ;
+   if ( bPostApply  &&  ! PostApply( sPostErr)) {
+      if ( ! IsEmptyOrSpaces( sPostErr))
+         m_pMchMgr->SetLastError( 2912, sPostErr) ;
       else
          m_pMchMgr->SetLastError( 2912, "Error in Chiseling : post apply not calculable") ;
       return false ;
@@ -763,7 +778,7 @@ Chiseling::GetToolData( void) const
 
 //----------------------------------------------------------------------------
 bool
-Chiseling::UpdateToolData( bool* pbChanged)
+Chiseling::UpdateToolData( void)
 {
   // recupero il gestore DB utensili della macchina corrente
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
@@ -814,9 +829,9 @@ Chiseling::UpdateToolData( bool* pbChanged)
                      m_Params.m_sToolName + ")" ;
       m_pMchMgr->SetWarning( 2954, sInfo) ;
    }
-  // se definito parametro di ritorno, lo assegno
-   if ( pbChanged != nullptr)
-      *pbChanged = bChanged ;
+  // se modificato, aggiusto lo stato
+   if ( bChanged)
+      m_nStatus = MCH_ST_TO_VERIFY ;
    return true ;
 }
 
@@ -1016,7 +1031,7 @@ Chiseling::GetCurves( SelData Id, ICURVEPLIST& lstPC)
      // la porto in globale
       pCrvCompo->ToGlob( frGlob) ;
      // sistemazioni varie
-      AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, 0) ;
+      AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, {}, 0) ;
      // la restituisco
       lstPC.emplace_back( Release( pCrvCompo)) ;
       return true ;
@@ -1052,7 +1067,7 @@ Chiseling::GetCurves( SelData Id, ICURVEPLIST& lstPC)
            // la porto in globale
             pCrvCompo->ToGlob( frGlob) ;
            // sistemazioni varie
-            AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, 0) ;
+            AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, {}, 0) ;
            // la restituisco
             lstPC.emplace_back( Release( pCrvCompo)) ;
          }

Chiseling.h

@@ -37,8 +37,14 @@ class Chiseling : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_CHISELING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nChisels == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nChisels == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -60,7 +66,7 @@ class Chiseling : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 

Disposition.cpp

@@ -1639,7 +1639,7 @@ Disposition::SpecialUpdate( void)
       return true ;
    }
   // calcolo assi macchina
-   if ( ! CalculateAxesValues( "", false)) {
+   if ( ! CalculateAxesValues( "")) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
       if ( sInfo.empty())
          m_pMchMgr->SetLastError( 2008, "Error in Disposition : axes values not calculable") ;

Disposition.h

@@ -73,8 +73,14 @@ class Disposition : public Operation
    public :                           // Operation
       int  GetType( void) const override
                { return OPER_DISP ; }
-      bool IsEmpty( void) const override
-               { return ( m_nShifts == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nShifts == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
                { m_nStatus |= nModif ; return true ; }
 

DllMain.h

@@ -18,7 +18,7 @@
 #include <string>
 
 //-----------------------------------------------------------------------------
-std::string GetEMkVer( void) ;
+const std::string& GetEMkVer( void) ;
 ILogger* GetEMkLogger( void) ;
 const std::string& GetEMkKey( void) ;
 bool GetEMkNetHwKey( void) ;

Drilling.cpp

@@ -18,6 +18,7 @@
 #include "DllMain.h"
 #include "Drilling.h"
 #include "OperationConst.h"
+#include "OperUserNotesConst.h"
 #include "/EgtDev/Include/EXeCmdLogOff.h"
 #include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkGeoVector3d.h"
@@ -30,6 +31,7 @@
 #include "/EgtDev/Include/EGnStringKeyVal.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include "/EgtDev/Include/EGkGeoFrame3d.h"
+#include "/EgtDev/Include/EgtIniFile.h"
 
 using namespace std ;
 
@@ -52,6 +54,7 @@ using namespace std ;
 // 2116 = "Error in Drilling : multi drilling head without valid tools"
 // 2117 = "Error in Drilling : incorrect multi drilling head"
 // 2118 = "Error in Drilling : Tool loading failed"
+// 2119 = "Error in Drilling : special apply not calculable"
 // 2151 = "Warning in Drilling : Skipped entity (xx)"
 // 2152 = "Warning in Drilling : No machinable path"
 // 2153 = "Warning in Drilling : Tool name changed (xx)"
@@ -519,7 +522,8 @@ Drilling::SetGeometry( const SELVECTOR& vIds)
   // verifico validità gestore generale e gestore DB geometrico
    if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
       return false ;
-  // reset della geometria corrente
+  // copia temporanea e reset della geometria corrente
+   SELVECTOR vOldId = m_vId ;
    m_vId.clear() ;
   // se lavorazione standard
    if ( m_Params.m_nSubType == DRI_SUB_STD) {
@@ -550,7 +554,8 @@ Drilling::SetGeometry( const SELVECTOR& vIds)
       }
    }
   // aggiorno lo stato
-   m_nStatus |= MCH_ST_GEO_MODIF ;
+   if ( m_vId != vOldId)
+      m_nStatus |= MCH_ST_GEO_MODIF ;
   // restituisco presenza geometria da lavorare
    return ( ! m_vId.empty()) ;
 }
@@ -612,15 +617,17 @@ Drilling::Apply( bool bRecalc, bool bPostApply)
       return false ;
 
   // aggiorno dati geometrici dell'utensile
-   bool bToolChanged = true ;
-   if ( ! UpdateToolData( &bToolChanged)) {
+   if ( ! UpdateToolData()) {
       m_pMchMgr->SetLastError( 2101, "Error in Drilling : UpdateToolData failed") ;
       return false ;
    }
 
+  // se modificata geometria, necessario ricalcolo
+   if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
+      bRecalc = true ;
+
   // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ! bToolChanged  &&  
-        ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
+   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
      // confermo i percorsi di lavorazione e i fori non lavorati
       m_nDrillings = nCurrDrillings ;
       m_vUndrilledId = vCurrUndrilledId ;
@@ -662,6 +669,12 @@ Drilling::Apply( bool bRecalc, bool bPostApply)
       return false ;
    }
 
+  // verifico se tavola basculante
+   bool bTiltTab = false ;
+   m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab, m_vtTiltingAx)  &&  bTiltTab) ;
+  // verifico se testa da sopra (Z+)
+   m_bAboveHead = m_pMchMgr->GetHeadAbove( m_TParams.m_sHead) ;
+
   // se lavorazione standard
    if ( m_Params.m_nSubType == DRI_SUB_STD) {
       if ( ! StandardProcess( bRecalc, GDB_ID_NULL, nClId))
@@ -679,16 +692,16 @@ Drilling::Apply( bool bRecalc, bool bPostApply)
   // assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso
    CalcAndSetBBox( nClId) ;
 
-  // eseguo aggiornamento assi macchina e collegamento con operazione precedente
-   if ( ! Update( bPostApply))
-      return false ;
-
   // se lavorazione in doppio, aggiungo geometria della parte simmetrica
    if ( ! CalcMirrorByDouble( nClId, m_Params.m_sUserNotes)) {
       m_pMchMgr->SetLastError( 2115, "Error in Drilling : Mirror for Double calculation failed") ;
       return false ;
    }
 
+  // eseguo aggiornamento assi macchina e collegamento con operazione precedente
+   if ( ! Update( bPostApply))
+      return false ;
+
   // aggiorno stato della lavorazione
    m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
   // dichiaro successiva da aggiornare
@@ -732,6 +745,47 @@ Drilling::Update( bool bPostApply)
       return false ;
    }
 
+  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+   CalcAndSetAxesBBox() ;
+
+  // se lavorazione in doppio, calcolo assi e movimenti di approccio e retrazione relativi
+   if ( GetDoubleType( m_Params.m_sUserNotes) != 0) {
+     // elimino le entità CLIMB, RISE e HOME della lavorazione in doppio
+      RemoveClimbRiseHome( false) ;
+     // recupero i dati della testa in doppio e la imposto
+      string sDblTool ; string sDblHead ; int nDblExit ;
+      bool bOk = GetDoubleToolData( sDblTool, sDblHead, nDblExit)  &&
+                 m_pMchMgr->SetCalcTool( sDblTool, sDblHead, nDblExit) ;
+     // imposto eventuale asse bloccato da lavorazione
+      SetBlockedRotAxis( m_Params.m_sBlockedAxis, true) ;
+     // eseguo il calcolo
+      if ( bOk) {
+         if ( ! CalculateDoubleAxesValues( sHint)) {
+            string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
+            if ( sInfo.empty())
+               m_pMchMgr->SetLastError( 2109, "Error in Drilling : axes values not calculable for double") ;
+            else
+               m_pMchMgr->SetLastError( 2110, "Error in Drilling : double outstroke ") ;
+            bOk = false ;
+         }
+      }
+     // ripristino testa principale
+      m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()) ;
+     // in caso di errore, esco
+      if ( ! bOk)
+         return false ;
+   }
+
+  // esecuzione eventuali personalizzazioni speciali
+   string sSpecErr ;
+   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
+      if ( ! IsEmptyOrSpaces( sSpecErr))
+         m_pMchMgr->SetLastError( 2119, sSpecErr) ;
+      else
+         m_pMchMgr->SetLastError( 2119, "Error in Drilling : special apply not calculable") ;
+      return false ;
+   }
+
   // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
    if ( ! AdjustStartEndMovements()) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
@@ -742,14 +796,11 @@ Drilling::Update( bool bPostApply)
       return false ;
    }
 
-  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
-   CalcAndSetAxesBBox() ;
-
   // esecuzione eventuali personalizzazioni
-   string sErr ;
-   if ( bPostApply  &&  ! PostApply( sErr)) {
-      if ( ! IsEmptyOrSpaces( sErr))
-         m_pMchMgr->SetLastError( 2113, sErr) ;
+   string sPostErr ;
+   if ( bPostApply  &&  ! PostApply( sPostErr)) {
+      if ( ! IsEmptyOrSpaces( sPostErr))
+         m_pMchMgr->SetLastError( 2113, sPostErr) ;
       else
          m_pMchMgr->SetLastError( 2113, "Error in Drilling : post apply not calculable") ;
       return false ;
@@ -2336,7 +2387,7 @@ Drilling::MultiHeadVerifyHole( Hole& hole, const ToolData* Tool, double dDiamTol
   // imposto elevazione da lunghezza foro con possibilità di sovrascrittura da info
    double dElev = hole.dLen ;
    double dMaxElev ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "MaxElev", dMaxElev)  &&  dElev > dMaxElev) {
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev)  &&  dElev > dMaxElev) {
       dElev = dMaxElev ;
       hole.ptIni += hole.vtDir * ( dElev - hole.dLen) ;
       hole.dLen = dElev ;
@@ -2702,7 +2753,7 @@ Drilling::GenerateHoleCl( int nInd, const SelData& nCircId, const string& sPName
   // imposto elevazione da lunghezza foro con possibilità di sovrascrittura da info
    double dElev = hole.dLen ;
    double dMaxElev ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "MaxElev", dMaxElev)  &&  dElev > dMaxElev) {
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev)  &&  dElev > dMaxElev) {
       dElev = dMaxElev ;
       hole.ptIni += hole.vtDir * ( dElev - hole.dLen) ;
       hole.dLen = ( hole.dLen > 10 * EPS_SMALL ? max( dElev, 10 * EPS_SMALL) : dElev) ;
@@ -2717,11 +2768,6 @@ Drilling::GenerateHoleCl( int nInd, const SelData& nCircId, const string& sPName
          m_pMchMgr->SetWarning( 2155, sInfo) ;
       }
    }
-  // verifico se tavola basculante
-   bool bTiltTab = false ;
-   m_bTiltingTab = ( m_pMchMgr->GetCurrMachine()->GetCurrTableIsTilting( bTiltTab, m_vtTiltingAx)  &&  bTiltTab) ;
-  // verifico se testa da sopra (Z+)
-   m_bAboveHead = m_pMchMgr->GetHeadAbove( currToolData.m_sHead) ;
   // verifiche per foro verso il basso
    m_bAggrBottom = false ; 
    if ( ! VerifyHoleFromBottom( hole, nCircId))
@@ -2734,8 +2780,8 @@ Drilling::GenerateHoleCl( int nInd, const SelData& nCircId, const string& sPName
   // assegno l'elevazione massima
    m_pGeomDB->SetInfo( nPathId, KEY_ELEV, hole.dLen) ;
   // foro normale
-   if ( m_Params.m_dStep < EPS_SMALL  ||
-        m_Params.m_dStep > hole.dLen - EPS_SMALL) {
+   if ( ( m_Params.m_dStep < EPS_SMALL  ||  m_Params.m_dStep > hole.dLen - 10 * EPS_SMALL)  &&
+        GetDoubleLastStep() > hole.dLen - 10 * EPS_SMALL) {
       if ( DoStandardDrilling( hole, nCircId, nPathId, dMHOff, vtA, currToolData)) {
         // aggiorno numero forature
          ++ m_nDrillings ;
@@ -3088,7 +3134,7 @@ Drilling::GetToolData( void) const
 
 //----------------------------------------------------------------------------
 bool
-Drilling::UpdateToolData( bool* pbChanged)
+Drilling::UpdateToolData( void)
 {
   // recupero il gestore DB utensili della macchina corrente
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
@@ -3139,9 +3185,9 @@ Drilling::UpdateToolData( bool* pbChanged)
                      m_Params.m_sToolName + ")" ;
       m_pMchMgr->SetWarning( 2154, sInfo) ;
    }
-  // se definito parametro di ritorno, lo assegno
-   if ( pbChanged != nullptr)
-      *pbChanged = bChanged ;
+  // se modificato, aggiusto lo stato
+   if ( bChanged)
+      m_nStatus = MCH_ST_TO_VERIFY ;
    return true ;
 }
 
@@ -3239,7 +3285,7 @@ Drilling::GetHoleData( SelData Id, Hole& hole)
    hole.bBlind = true ;
    // se dichiarato passante o no (1/0)
    int nOpen ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "Open", nOpen))
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_OPEN, nOpen))
       hole.bBlind = ( nOpen == 0) ;
    // se verticale ed arriva fino al fondo grezzo, allora passante
    else if ( hole.vtDir.IsZplus()  &&  hole.dThick > dRbDist - EPS_SMALL) 
@@ -3527,13 +3573,42 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHO
       if ( AddRapidMove( ptP2, bSplitArcs) == GDB_ID_NULL)
          return false ;
    }
+  // parametri per foro in doppio
+   bool bDouble = ( GetDoubleType( m_Params.m_sUserNotes) != 0)  ;
+   double dDoubleLastStep = GetDoubleLastStep() ;
+   bool dDoubleParallel = false ;
+   if ( bDouble) {
+     // nel caso di lavorazione in doppio con flag nel file .ini abilitato, prima della risalita finale, risalgo dell'ultimo step compiuto
+     // se il piano di mirror presenta una normale circa parallela alla direzione del foro ( da BTL 1 grado di tolleranza)
+      Machine* pMch = m_pMchMgr->GetCurrMachine() ;
+      if ( pMch != nullptr) {
+         string sMachIni = pMch->GetMachineDir() + "\\" + pMch->GetMachineName() + ".ini" ;
+         const char* SEC_MACH = "Customizations" ;
+         const char* KEY_DRILLING_DOUBLE = "DrillingDoubleNT" ;
+         int nDrillingDouble = GetPrivateProfileInt( SEC_MACH, KEY_DRILLING_DOUBLE, 0, sMachIni.c_str()) ;
+         if ( nDrillingDouble == 1) {
+            int nDouble = GetDoubleType( m_Params.m_sUserNotes) ;
+            Vector3d vtNorm = V_INVALID ;
+            switch ( nDouble) {
+            case 1 : vtNorm = X_AX ; break ;
+            case 2 : vtNorm = Y_AX ; break ;
+            case 3 : vtNorm = Z_AX ; break ;
+            }
+            dDoubleParallel = ( vtNorm.IsValid() && hole.vtDir * vtNorm > cos( 1. * DEGTORAD)) ;
+         }
+      }
+   }
   // ciclo di affondamento a step
    const double MIN_STEP = 1 ;
    const double APPR_STEP = 1 ;
    const double MIN_MOVE = 1 ;
-   double dStep = max( m_Params.m_dStep, MIN_STEP) ;
-   int nStep = int( ceil( hole.dLen / dStep)) ;
-   dStep = hole.dLen / nStep ;
+   double dOrigStep = max( m_Params.m_dStep, MIN_STEP) ;
+   double dSteppedLen = ( bDouble ? hole.dLen - dDoubleLastStep : hole.dLen) ;
+   int nStep = int( ceil( dSteppedLen / dOrigStep)) ;
+   double dStep = dSteppedLen / nStep ;
+   if ( bDouble)
+      ++ nStep ;
+   double dLastStep = ( bDouble ? dDoubleLastStep : dStep) ;
    if ( dReturnPos < - dStep + APPR_STEP + MIN_MOVE)
       dReturnPos = - dStep + APPR_STEP + MIN_MOVE ;
    double dCurrLen = 0 ;
@@ -3554,7 +3629,7 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHO
             return false ;
       }
      // lunghezza di fine step
-      double dEndLen = dCurrLen + dStep ;
+      double dEndLen = dCurrLen + ( i == nStep ? dLastStep : dStep) ;
      // 3 -> punto termine velocità ridotta iniziale (se previsto)
       if ( bStartSlow  &&  ( i == 1  ||  dCurrLen < dStartSlowLen + EPS_SMALL)) {
         // lunghezza di esecuzione
@@ -3573,8 +3648,14 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHO
          Point3d ptP3 = hole.ptIni - hole.vtDir * dLen ;
          if ( bHoleEnd)
             ptP3 -= hole.vtDir * dAddLen ;
-         if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
-            return false ;
+         if ( dDoubleParallel  &&  i == nStep) {
+            if ( AddLinearMove( ptP3, bSplitArcs, MCH_CL_DBP) == GDB_ID_NULL)
+               return false ;
+         }
+         else {
+            if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
+               return false ;
+         }
         // aggiorno posizione e verifico se step completato
          dCurrLen = dLen ;
          if ( bHoleEnd  ||  bStepEnd)
@@ -3598,8 +3679,14 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHO
          Point3d ptP4 = hole.ptIni - hole.vtDir * dLen ;
          if ( bHoleEnd)
             ptP4 -= hole.vtDir * dAddLen ;
-         if ( AddLinearMove( ptP4, bSplitArcs) == GDB_ID_NULL)
-            return false ;
+         if ( dDoubleParallel  &&  i == nStep) {
+            if ( AddLinearMove( ptP4, bSplitArcs, MCH_CL_DBP) == GDB_ID_NULL)
+               return false ;
+         }
+         else {
+            if ( AddLinearMove( ptP4, bSplitArcs) == GDB_ID_NULL)
+               return false ;
+         }
         // aggiorno posizione e verifico se step completato
          dCurrLen = dLen ;
          if ( bHoleEnd  ||  bStepEnd)
@@ -3622,8 +3709,14 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHO
          Point3d ptP5 = hole.ptIni - hole.vtDir * dLen ;
          if ( bHoleEnd)
             ptP5 -= hole.vtDir * dAddLen ;
-         if ( AddLinearMove( ptP5, bSplitArcs) == GDB_ID_NULL)
-            return false ;
+         if ( dDoubleParallel  &&  i == nStep) {
+            if ( AddLinearMove( ptP5, bSplitArcs, MCH_CL_DBP) == GDB_ID_NULL)
+               return false ;
+         }
+         else {
+            if ( AddLinearMove( ptP5, bSplitArcs) == GDB_ID_NULL)
+               return false ;
+         }
         // aggiorno posizione
          dCurrLen = dLen ;
       }
@@ -3632,6 +3725,16 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHO
   // 6 -> ritorno all'approccio del foro
    SetFeed( GetEndFeed()) ;
    SetFlag( 104) ;            // risalita sopra il foro
+   if ( dDoubleParallel) {
+     // aggiungo risalita aggiuntiva per lavorazione in doppio pari a due volte il LastStep
+      Point3d ptEnd ; GetCurrPos( ptEnd) ;
+      if ( AddLinearMove( ptEnd + min( 2. * dLastStep, dCurrLen) * hole.vtDir, bSplitArcs, MCH_CL_DBP) == GDB_ID_NULL)
+         return false ;
+     // aggiungo discensa di LastStep per simmetria con secondo utensile
+      GetCurrPos( ptEnd) ;
+      if ( AddLinearMove( ptEnd - dLastStep * hole.vtDir, bSplitArcs, MCH_CL_DBP) == GDB_ID_NULL)
+         return false ;
+   }
    if ( AddLinearMove( ptP1, bSplitArcs) == GDB_ID_NULL)
       return false ;
 
@@ -3666,6 +3769,22 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHO
    return true ;
 }
 
+//----------------------------------------------------------------------------
+double
+Drilling::GetDoubleLastStep( void)
+{
+  // se non è foratura in doppio, restituisco valore molto grande
+   const double FALSE_LASTSTEP = 10000 ;
+   if ( GetDoubleType( m_Params.m_sUserNotes) == 0) 
+      return FALSE_LASTSTEP ;
+  // recupero valore
+   const double MIN_LASTSTEP = 15 ;
+   double dDoubleLastStep = m_Params.m_dStep ;
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_LASTSTEP, dDoubleLastStep))
+      dDoubleLastStep = max( dDoubleLastStep, MIN_LASTSTEP)  ;
+   return dDoubleLastStep ;
+}
+
 //----------------------------------------------------------------------------
 // Debug Functions
 //----------------------------------------------------------------------------

Drilling.h

@@ -51,8 +51,14 @@ class Drilling : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_DRILLING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nDrillings == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nDrillings == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -74,7 +80,7 @@ class Drilling : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
       bool GetSkippedGeometry( SELVECTOR& vIds) const override ;
@@ -122,6 +128,7 @@ class Drilling : public Machining
       bool MultiHeadOrderConfig( TABMHDRILL& tabDrills, const VECTORHOLE& vHoles, const Vector3d& vtTool, const Vector3d& vtAux) ;
       bool MultiHeadHoleToolsConfig( const VECTORHOLE& vHoles, int nConfig, INTINTVECTOR& vConfMask) ;
       int  VerifyMultiParallelDrills( void) ;
+      double GetDoubleLastStep( void) ;
 
     /* debug functions */
      void PrintConfigs( const VECTORHOLE& vHoles) ;

EMkDllMain.cpp

@@ -31,8 +31,7 @@
 const int STR_DIM = 40 ;
 
 //-----------------------------------------------------------------------------
-static HINSTANCE s_hModule = NULL ;
-static char      s_szEMkNameVer[STR_DIM] ;
+static HINSTANCE   s_hModule = NULL ;
 
 //-----------------------------------------------------------------------------
 extern "C" int APIENTRY
@@ -62,21 +61,24 @@ DllMain( HMODULE hModule, DWORD dwReason, LPVOID lpReserved)
 const char*
 GetEMkVersion( void)
 {
-   std::string sVer ;
-
-   GetModuleVersion( s_hModule, sVer) ;
-   sprintf_s( s_szEMkNameVer, STR_DIM, "%s%s", EMK_STR, sVer.c_str()) ;
+   static char s_szEMkNameVer[STR_DIM] = "" ;
+   if ( s_szEMkNameVer[0] == '\0') {
+      static std::string sVer ;
+      GetModuleVersion( s_hModule, sVer) ;
+      sprintf_s( s_szEMkNameVer, STR_DIM, "%s%s", EMK_STR, sVer.c_str()) ;
+   }
 
    return s_szEMkNameVer ;
 }
 
 //-----------------------------------------------------------------------------
-std::string
+const std::string&
 GetEMkVer( void)
 {
-   std::string sVer ;
-   GetModuleVersion( s_hModule, sVer) ;
-   return sVer ;
+   static std::string s_sVer ;
+   if ( s_sVer.empty())
+      GetModuleVersion( s_hModule, s_sVer) ;
+   return s_sVer ;
 }
 
 //-----------------------------------------------------------------------------

EgtMachKernel.vcxproj

@@ -105,7 +105,7 @@
       <OpenMPSupport>false</OpenMPSupport>
       <PrecompiledHeader>Use</PrecompiledHeader>
       <CompileAs>CompileAsCpp</CompileAs>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>true</GenerateDebugInformation>
@@ -132,7 +132,7 @@ copy $(TargetPath) \EgtProg\DllD32</Command>
       <OpenMPSupport>true</OpenMPSupport>
       <PrecompiledHeader>Use</PrecompiledHeader>
       <CompileAs>CompileAsCpp</CompileAs>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</LanguageStandard>
       <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
     </ClCompile>
     <Link>
@@ -167,7 +167,7 @@ copy $(TargetPath) \EgtProg\DllD64</Command>
       <EnableFiberSafeOptimizations>true</EnableFiberSafeOptimizations>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <WholeProgramOptimization>false</WholeProgramOptimization>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <GenerateDebugInformation>false</GenerateDebugInformation>
@@ -202,7 +202,7 @@ copy $(TargetPath) \EgtProg\Dll32</Command>
       <EnableFiberSafeOptimizations>false</EnableFiberSafeOptimizations>
       <EnableParallelCodeGeneration>true</EnableParallelCodeGeneration>
       <WholeProgramOptimization>false</WholeProgramOptimization>
-      <LanguageStandard>stdcpp17</LanguageStandard>
+      <LanguageStandard>stdcpp20</LanguageStandard>
       <AdditionalOptions>-Wno-tautological-undefined-compare</AdditionalOptions>
     </ClCompile>
     <Link>
@@ -276,6 +276,8 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="Pocketing.cpp" />
     <ClCompile Include="PocketingData.cpp" />
     <ClCompile Include="PocketingNT.cpp" />
+    <ClCompile Include="Probing.cpp" />
+    <ClCompile Include="ProbingData.cpp" />
     <ClCompile Include="Processor.cpp" />
     <ClCompile Include="SawFinishing.cpp" />
     <ClCompile Include="SawFinishingData.cpp" />
@@ -438,6 +440,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="MachiningData.h" />
     <ClInclude Include="MachiningDataFactory.h" />
     <ClInclude Include="MachiningCreate.h" />
+    <ClInclude Include="MachiningRegister.h" />
     <ClInclude Include="MachiningsMgr.h" />
     <ClInclude Include="MachMgr.h" />
     <ClInclude Include="Milling.h" />
@@ -446,10 +449,13 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="MortisingData.h" />
     <ClInclude Include="Operation.h" />
     <ClInclude Include="OperationConst.h" />
+    <ClInclude Include="OperUserNotesConst.h" />
     <ClInclude Include="OutputConst.h" />
     <ClInclude Include="Pocketing.h" />
     <ClInclude Include="PocketingData.h" />
     <ClInclude Include="PocketingNT.h" />
+    <ClInclude Include="Probing.h" />
+    <ClInclude Include="ProbingData.h" />
     <ClInclude Include="Processor.h" />
     <ClInclude Include="resource.h" />
     <ClInclude Include="SawFinishing.h" />

EgtMachKernel.vcxproj.filters

@@ -252,6 +252,12 @@
     <ClCompile Include="PocketingNT.cpp">
       <Filter>Source Files\Operations</Filter>
     </ClCompile>
+    <ClCompile Include="ProbingData.cpp">
+      <Filter>Source Files\Machinings</Filter>
+    </ClCompile>
+    <ClCompile Include="Probing.cpp">
+      <Filter>Source Files\Operations</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="DllMain.h">
@@ -767,6 +773,18 @@
     <ClInclude Include="PocketingNT.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="MachiningRegister.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="ProbingData.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="Probing.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="OperUserNotesConst.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtMachKernel.rc">

FiveAxisMilling.cpp

@@ -17,12 +17,14 @@
 #include "DllMain.h"
 #include "FiveAxisMilling.h"
 #include "OperationConst.h"
+#include "OperUserNotesConst.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EGkArcSpecial.h"
 #include "/EgtDev/Include/EGkSfrCreate.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
+#include "/EgtDev/Include/EGkSurfBezier.h"
 #include "/EgtDev/Include/EGkUserObjFactory.h"
 #include "/EgtDev/Include/EGnStringKeyVal.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
@@ -41,6 +43,7 @@ using namespace std ;
 // 3308 = "Error in FiveAxisMilling : post apply not calculable"
 // 3309 = "Error in FiveAxisMilling : Tool loading failed"
 // 3310 = "Error in FiveAxisMilling : aggregate from bottom not allowed"
+// 3311 = "Error in FiveAxisMilling : special apply not calculable"
 // 3351 = "Warning in FiveAxisMilling : Skipped entity (xx)"
 // 3352 = "Warning in FiveAxisMilling : No machinable path"
 // 3353 = "Warning in FiveAxisMilling : Tool name changed (xx)"
@@ -49,7 +52,7 @@ using namespace std ;
 //------------------------------ Constants -----------------------------------
 static const string EMC_VAR = "EMC" ;              // tabella variabili locali per calcolo
 static const string EVAR_MACHID = ".MACHID" ;      // IN (int) identificativo della lavorazione
-static const string EVAR_GEOM = ".GEOM" ;          // IN (table) tabella delle entità da lavorare
+static const string EVAR_GEOM = ".GEOM" ;          // IN (table) tabella delle entità da lavorare
 static const string EVAR_DEPTH = ".DEPTH" ;        // IN (string) affondamento (espressione numerica)
 static const string EVAR_TINVERT = ".TOOLINVERT" ; // IN (bool) flag di inversione direzione utensile
 static const string EVAR_INVERT = ".INVERT" ;      // IN (bool) flag di inversione direzione lavorazione
@@ -67,14 +70,14 @@ 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_TTHICK = ".TTHICK" ;      // 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
 static const string EVAR_TIPFEED = ".TIPFEED" ;    // IN (num) feed di punta dell'utensile
-static const string EVAR_ISROBOT = ".ISROBOT" ;    // IN (bool) flag per indicare che la cinematica è di tipo robot
+static const string EVAR_ISROBOT = ".ISROBOT" ;    // IN (bool) flag per indicare che la cinematica è di tipo robot
 static const string EVAR_ERROR = ".ERR" ;          // OUT (int) codice di errore ( 0 = ok)
 static const string EVAR_MILLS = ".MILLS" ;        // OUT (int) numero di percorsi di lavoro
 static const string ON_PREVIEW = "OnPreview_" ;
@@ -219,6 +222,7 @@ FiveAxisMilling::FiveAxisMilling( void)
    m_TParams.m_sHead = "*" ;
    m_nStatus = MCH_ST_TO_VERIFY ;
    m_nMills = 0 ;
+   m_bRunning = false ;
 }
 
 //----------------------------------------------------------------------------
@@ -409,17 +413,17 @@ FiveAxisMilling::SetParam( int nType, const string& sVal)
 bool
 FiveAxisMilling::SetGeometry( const SELVECTOR& vIds)
 {
-  // verifico validità gestore DB geometrico
+  // verifico validità gestore DB geometrico
    if ( m_pGeomDB == nullptr)
       return false ;
-  // reset della geometria corrente
+  // copia temporanea e reset della geometria corrente
+   SELVECTOR vOldId = m_vId ;
    m_vId.clear() ;
-  // verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve o tutte facce)
-   int nType = GEO_NONE ;
+  // verifico che gli identificativi rappresentino delle entità ammissibili (curve o superfici)
    for ( const auto& Id : vIds) {
-     // test sull'entità
+     // test sull'entità
       int nSubs ;
-      if ( ! VerifyGeometry( Id, nSubs, nType)) {
+      if ( ! VerifyGeometry( Id, nSubs)) {
          string sInfo = "Warning in FiveAxisMilling : Skipped entity " + ToString( Id) ;
          m_pMchMgr->SetWarning( 3351, sInfo) ;
          continue ;
@@ -428,7 +432,8 @@ FiveAxisMilling::SetGeometry( const SELVECTOR& vIds)
       m_vId.emplace_back( Id) ;
    }
   // aggiorno lo stato
-   m_nStatus |= MCH_ST_GEO_MODIF ;
+   if ( m_vId != vOldId)
+      m_nStatus |= MCH_ST_GEO_MODIF ;
   // restituisco presenza geometria da lavorare
    return ( ! m_vId.empty()  ||  vIds.empty()) ;
 }
@@ -440,7 +445,7 @@ FiveAxisMilling::Preview( bool bRecalc)
   // reset numero percorsi di lavoro generati
    m_nMills = 0 ;
 
-  // verifico validità gestore DB geometrico e Id del gruppo
+  // verifico validità gestore DB geometrico e Id del gruppo
    if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
       return false ;
 
@@ -458,7 +463,7 @@ FiveAxisMilling::Preview( bool bRecalc)
 
   // recupero gruppo per geometria di Preview
    int nPvId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_PV) ;
-  // se non c'è, lo aggiungo
+  // se non c'è, lo aggiungo
    if ( nPvId == GDB_ID_NULL) {
       nPvId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
       if ( nPvId == GDB_ID_NULL)
@@ -541,7 +546,7 @@ FiveAxisMilling::Preview( bool bRecalc)
 bool
 FiveAxisMilling::Apply( bool bRecalc, bool bPostApply)
 {
-  // se calcoli già in corso, esco
+  // se calcoli già in corso, esco
    if ( m_bRunning) {
       LOG_DBG_INFO( GetEMkLogger(), "FiveAxisMilling::Apply already running") ;
       return true ;
@@ -560,26 +565,28 @@ FiveAxisMilling::MyApply( bool bRecalc, bool bPostApply)
    int nCurrMills = m_nMills ;
    m_nMills = 0 ;
 
-  // verifico validità gestore DB geometrico e Id del gruppo
+  // verifico validità gestore DB geometrico e Id del gruppo
    if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
       return false ;
 
   // aggiorno dati geometrici dell'utensile
-   bool bToolChanged = true ;
-   if ( ! UpdateToolData( &bToolChanged)) {
+   if ( ! UpdateToolData()) {
       m_pMchMgr->SetLastError( 3301, "Error in FiveAxisMilling : UpdateToolData failed") ;
       return false ;
    }
 
-  // non è prevista fresatura 5 assi con aggregato da sotto
+  // non è prevista fresatura 5 assi con aggregato da sotto
    if ( IsAggrBottom( m_TParams.m_sHead)) {
       m_pMchMgr->SetLastError( 3310, "Error in FiveAxisMilling : aggregate from bottom not allowed") ;
       return false ;
    }
 
+  // se modificata geometria, necessario ricalcolo
+   if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
+      bRecalc = true ;
+
   // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ! bToolChanged  &&  
-        ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
+   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
      // confermo i percorsi di lavorazione
       m_nMills = nCurrMills ;
       string sLog = string( "FiveAxisMilling apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
@@ -602,7 +609,7 @@ FiveAxisMilling::MyApply( bool bRecalc, bool bPostApply)
 
   // recupero gruppo per geometria di lavorazione (Cutter Location)
    int nClId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_CL) ;
-  // se non c'è, lo aggiungo
+  // se non c'è, lo aggiungo
    if ( nClId == GDB_ID_NULL) {
       nClId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
       if ( nClId == GDB_ID_NULL)
@@ -703,7 +710,7 @@ FiveAxisMilling::MyApply( bool bRecalc, bool bPostApply)
 bool
 FiveAxisMilling::Update( bool bPostApply)
 {
-  // verifico validità gestore DB geometrico e Id del gruppo
+  // verifico validità gestore DB geometrico e Id del gruppo
    if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
       return false ;
 
@@ -713,7 +720,7 @@ FiveAxisMilling::Update( bool bPostApply)
       return true ;
    }
 
-  // elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo) 
+  // elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo) 
    RemoveClimbRiseHome() ;
 
   // imposto eventuale asse bloccato da lavorazione
@@ -723,7 +730,9 @@ FiveAxisMilling::Update( bool bPostApply)
    string sHint = ExtractHint( m_Params.m_sUserNotes) ;
    if ( ! m_Params.m_sInitAngs.empty())
       sHint = m_Params.m_sInitAngs ;
-   if ( ! CalculateAxesValues( sHint)) {
+   double dSingConeAng = 0.1 ;
+   GetValInNotes( m_Params.m_sUserNotes, UN_SINGCONEANG, dSingConeAng) ;
+   if ( ! CalculateAxesValues( sHint, false, dSingConeAng)) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
       if ( sInfo.empty())
          m_pMchMgr->SetLastError( 3304, "Error in FiveAxisMilling : axes values not calculable") ;
@@ -732,11 +741,21 @@ FiveAxisMilling::Update( bool bPostApply)
       return false ;
    }
 
+  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+   CalcAndSetAxesBBox() ;
+
+  // esecuzione eventuali personalizzazioni speciali
+   string sSpecErr ;
+   if ( bPostApply  &&  ! PostApply( sSpecErr)) {
+      if ( ! IsEmptyOrSpaces( sSpecErr))
+         m_pMchMgr->SetLastError( 3311, sSpecErr) ;
+      else
+         m_pMchMgr->SetLastError( 3311, "Error in FiveAxisMilling : special apply not calculable") ;
+      return false ;
+   }
+
   // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
-   bool bVpl ;
-   if ( ! FromString( ExtractInfo( m_Params.m_sUserNotes, "Vpl:"), bVpl))
-      bVpl = true ;
-   if ( ! AdjustStartEndMovements( bVpl)) {
+   if ( ! AdjustStartEndMovements()) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
       if ( sInfo.empty())
          m_pMchMgr->SetLastError( 3306, "Error in FiveAxisMilling : link movements not calculable") ;
@@ -745,14 +764,11 @@ FiveAxisMilling::Update( bool bPostApply)
       return false ;
    }
 
-  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
-   CalcAndSetAxesBBox() ;
-
   // esecuzione eventuali personalizzazioni
-   string sErr ;
-   if ( bPostApply  &&  ! PostApply( sErr)) {
-      if ( ! IsEmptyOrSpaces( sErr))
-         m_pMchMgr->SetLastError( 3308, sErr) ;
+   string sPostErr ;
+   if ( bPostApply  &&  ! PostApply( sPostErr)) {
+      if ( ! IsEmptyOrSpaces( sPostErr))
+         m_pMchMgr->SetLastError( 3308, sPostErr) ;
       else
          m_pMchMgr->SetLastError( 3308, "Error in FiveAxisMilling : post apply not calculable") ;
       return false ;
@@ -876,7 +892,7 @@ FiveAxisMilling::GetToolData( void) const
 
 //----------------------------------------------------------------------------
 bool
-FiveAxisMilling::UpdateToolData( bool* pbChanged)
+FiveAxisMilling::UpdateToolData( void)
 {
   // recupero il gestore DB utensili della macchina corrente
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
@@ -927,9 +943,9 @@ FiveAxisMilling::UpdateToolData( bool* pbChanged)
                      m_Params.m_sToolName + ")" ;
       m_pMchMgr->SetWarning( 3354, sInfo) ;
    }
-  // se definito parametro di ritorno, lo assegno
-   if ( pbChanged != nullptr)
-      *pbChanged = bChanged ;
+  // se modificato, aggiusto lo stato
+   if ( bChanged)
+      m_nStatus = MCH_ST_TO_VERIFY ;
    return true ;
 }
 
@@ -937,7 +953,7 @@ FiveAxisMilling::UpdateToolData( bool* pbChanged)
 bool
 FiveAxisMilling::GetGeometry( SELVECTOR& vIds) const
 {
-  // restituisco l'elenco delle entità
+  // restituisco l'elenco delle entità
    vIds = m_vId ;
    return true ;
 }
@@ -956,14 +972,14 @@ FiveAxisMilling::AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& pt
 
 //----------------------------------------------------------------------------
 bool
-FiveAxisMilling::VerifyGeometry( SelData Id, int& nSubs, int& nType)
+FiveAxisMilling::VerifyGeometry( SelData Id, int& nSubs)
 {
-  // ammessi : tutte curve o tutte facce di trimesh
+  // ammessi : curve o superfici
    const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
    if ( pGObj == nullptr)
       return false ;
-  // se ammesse curve ed è tale
-   if ( nType != GEO_SURF  &&  ( pGObj->GetType() & GEO_CURVE) != 0) {
+  // se curva ed è tale
+   if ( ( pGObj->GetType() & GEO_CURVE) != 0) {
       const ICurve* pCurve = nullptr ;
       // se direttamente la curva
       if ( Id.nSub == SEL_SUB_ALL) {
@@ -984,25 +1000,15 @@ FiveAxisMilling::VerifyGeometry( SelData Id, int& nSubs, int& nType)
       }
       return ( pCurve != nullptr) ;
    }
-  // se altrimenti ammesse superfici trimesh ed è tale
-   else if ( nType != GEO_CURVE  &&  ( pGObj->GetType() & GEO_SURF) != 0) {
+  // se altrimenti è superficie trimesh
+   else if ( pGObj->GetType() == SRF_TRIMESH) {
       const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
-      if ( pSurf == nullptr)
-         return false ;
-      // se direttamente la superficie
-      if ( Id.nSub == SEL_SUB_ALL) {
-         nSubs = pSurf->GetFacetCount() ;
-         return true ;
-      }
-      // altrimenti faccia di superficie trimesh
-      else {
-        // se faccia non esistente
-         if ( Id.nSub > pSurf->GetFacetCount())
-            return false ;
-        // tutto bene
-         nSubs = 0 ;
-         return true ;
-      }
+      return ( pSurf != nullptr  &&  pSurf->GetFacetCount() >= 1) ;
+   }
+  // se altrimenti è superficie Bezier
+   else if ( pGObj->GetType() == SRF_BEZIER) {
+      const ISurfBezier* pSurf = ::GetSurfBezier( pGObj) ;
+      return ( pSurf != nullptr  &&  pSurf->IsValid()) ;
    }
   // altrimenti errore
    else
@@ -1014,7 +1020,7 @@ double
 FiveAxisMilling::GetApproxLinTol( void) const
 {
    double dLinTol ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "LinTol", dLinTol))
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_LINTOL, dLinTol))
       return dLinTol ;
    else
       return Operation::GetApproxLinTol() ;

FiveAxisMilling.h

@@ -35,8 +35,14 @@ class FiveAxisMilling : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_FIVEAXISMILLING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nMills == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nMills == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -59,7 +65,7 @@ class FiveAxisMilling : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 
@@ -68,7 +74,7 @@ class FiveAxisMilling : public Machining
 
    private :
       bool MyApply( bool bRecalc, bool bPostApply) ;
-      bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
+      bool VerifyGeometry( SelData Id, int& nSubs) ;
       double GetApproxLinTol( void) const override ;
 
    private :

FiveAxisMillingData.cpp

@@ -178,7 +178,7 @@ FiveAxisMillingData::GetTitle( void) const
 }
 
 //----------------------------------------------------------------------------
-int
+static int
 FindFiveAxisMillingKey( const string& sKey)
 {
    auto TheRange = equal_range( sFiveAxisMillingKey.cbegin(), sFiveAxisMillingKey.cend(), sKey) ;

GenMachining.cpp

@@ -17,6 +17,7 @@
 #include "DllMain.h"
 #include "GenMachining.h"
 #include "OperationConst.h"
+#include "OperUserNotesConst.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
@@ -40,6 +41,7 @@ using namespace std ;
 // 2807 = "Error in GenMachining : link outstroke xx"
 // 2808 = "Error in GenMachining : post apply not calculable"
 // 2809 = "Error in GenMachining : Tool loading failed"
+// 2810 = "Error in GenMachining : special apply not calculable"
 // 2851 = "Warning in GenMachining : Skipped entity (xx)"
 // 2852 = "Warning in GenMachining : No machinable path"
 // 2853 = "Warning in GenMachining : Tool name changed (xx)"
@@ -411,7 +413,8 @@ GenMachining::SetGeometry( const SELVECTOR& vIds)
   // verifico validità gestore DB geometrico
    if ( m_pGeomDB == nullptr)
       return false ;
-  // reset della geometria corrente
+  // copia temporanea e reset della geometria corrente
+   SELVECTOR vOldId = m_vId ;
    m_vId.clear() ;
   // verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve o tutte facce)
    int nType = GEO_NONE ;
@@ -427,7 +430,8 @@ GenMachining::SetGeometry( const SELVECTOR& vIds)
       m_vId.emplace_back( Id) ;
    }
   // aggiorno lo stato
-   m_nStatus |= MCH_ST_GEO_MODIF ;
+   if ( m_vId != vOldId)
+      m_nStatus |= MCH_ST_GEO_MODIF ;
   // restituisco presenza geometria da lavorare
    return ( ! m_vId.empty()  ||  vIds.empty()) ;
 }
@@ -549,15 +553,17 @@ GenMachining::Apply( bool bRecalc, bool bPostApply)
       return false ;
 
   // aggiorno dati geometrici dell'utensile
-   bool bToolChanged = true ;
-   if ( ! UpdateToolData( &bToolChanged)) {
+   if ( ! UpdateToolData()) {
       m_pMchMgr->SetLastError( 2801, "Error in GenMachining : UpdateToolData failed") ;
       return false ;
    }
 
+  // se modificata geometria, necessario ricalcolo
+   if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
+      bRecalc = true ;
+
   // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ! bToolChanged  &&  
-        ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
+   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
      // confermo i percorsi di lavorazione
       m_nMills = nCurrMills ;
       string sLog = string( "GenMachining apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
@@ -706,9 +712,22 @@ GenMachining::Update( bool bPostApply)
       return false ;
    }
 
+  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+   CalcAndSetAxesBBox() ;
+
+  // esecuzione eventuali personalizzazioni speciali
+   string sSpecErr ;
+   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
+      if ( ! IsEmptyOrSpaces( sSpecErr))
+         m_pMchMgr->SetLastError( 2810, sSpecErr) ;
+      else
+         m_pMchMgr->SetLastError( 2810, "Error in GenMachining : special apply not calculable") ;
+      return false ;
+   }
+
   // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
    bool bVpl ;
-   if ( ! FromString( ExtractInfo( m_Params.m_sUserNotes, "Vpl:"), bVpl))
+   if ( ! FromString( ExtractInfo( m_Params.m_sUserNotes, UN_VPL_COLON), bVpl))
       bVpl = true ;
    if ( ! AdjustStartEndMovements( bVpl)) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
@@ -719,14 +738,11 @@ GenMachining::Update( bool bPostApply)
       return false ;
    }
 
-  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
-   CalcAndSetAxesBBox() ;
-
-  // esecuzione eventuali personalizzazioni
-   string sErr ;
-   if ( bPostApply  &&  ! PostApply( sErr)) {
-      if ( ! IsEmptyOrSpaces( sErr))
-         m_pMchMgr->SetLastError( 2808, sErr) ;
+  // esecuzione eventuali personalizzazioni finali
+   string sPostErr ;
+   if ( bPostApply  &&  ! PostApply( sPostErr)) {
+      if ( ! IsEmptyOrSpaces( sPostErr))
+         m_pMchMgr->SetLastError( 2808, sPostErr) ;
       else
          m_pMchMgr->SetLastError( 2808, "Error in GenMachining : post apply not calculable") ;
       return false ;
@@ -850,7 +866,7 @@ GenMachining::GetToolData( void) const
 
 //----------------------------------------------------------------------------
 bool
-GenMachining::UpdateToolData( bool* pbChanged)
+GenMachining::UpdateToolData( void)
 {
   // recupero il gestore DB utensili della macchina corrente
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
@@ -901,9 +917,9 @@ GenMachining::UpdateToolData( bool* pbChanged)
                      m_Params.m_sToolName + ")" ;
       m_pMchMgr->SetWarning( 2854, sInfo) ;
    }
-  // se definito parametro di ritorno, lo assegno
-   if ( pbChanged != nullptr)
-      *pbChanged = bChanged ;
+  // se modificato, aggiusto lo stato
+   if ( bChanged)
+      m_nStatus = MCH_ST_TO_VERIFY ;
    return true ;
 }
 
@@ -976,7 +992,7 @@ double
 GenMachining::GetApproxLinTol( void) const
 {
    double dLinTol ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "LinTol", dLinTol))
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_LINTOL, dLinTol))
       return dLinTol ;
    else
       return Operation::GetApproxLinTol() ;

GenMachining.h

@@ -35,8 +35,14 @@ class GenMachining : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_GENMACHINING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nMills == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nMills == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -58,7 +64,7 @@ class GenMachining : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 

GenMachiningData.cpp

@@ -178,7 +178,7 @@ GenMachiningData::GetTitle( void) const
 }
 
 //----------------------------------------------------------------------------
-int
+static int
 FindGenMachiningKey( const string& sKey)
 {
    auto TheRange = equal_range( sGenMachiningKey.cbegin(), sGenMachiningKey.cend(), sKey) ;

MachConst.h

@@ -15,7 +15,6 @@
 
 #include <string>
 
-
 //----------------------------------------------------------------------------
 // Radice della gestione delle lavorazioni
 const std::string MACH_BASE = "MachBase" ;
@@ -78,6 +77,18 @@ const std::string MACHININGS_DIR = "Machinings" ;
 // Nome file delle lavorazioni
 const std::string MACHININGS_FILE = "Machinings.data" ;
 
+//----------------------------------------------------------------------------
+// Sezione Generale nel file INI di macchina
+const std::string GENERAL_SEC = "General" ;
+// Chiave per materiale caratteristico
+const std::string MATERIAL_KEY = "Material" ;
+
+//----------------------------------------------------------------------------
+// Sezione tastature nel file INI di macchina
+const std::string PROBING_SEC = "Probing" ;
+// Chiave (radice) per nome tastatura i-esima
+const std::string PROBING_SCRIPT_KEY = "PrbScript" ;
+
 //----------------------------------------------------------------------------
 // Sezione lavorazioni generiche nel file INI di macchina
 const std::string GENMACHINING_SEC = "GenMachining" ;
@@ -111,6 +122,8 @@ const std::string MORTISEMAKER_KEY = "MortiseMaker" ;
 const std::string CHISELMAKER_KEY = "ChiselMaker" ;
 // Chiave per generatore disegno waterjet
 const std::string WATERJETMAKER_KEY = "WaterJetMaker" ;
+// Chiave per generatore disegno tastatori
+const std::string PROBEMAKER_KEY = "ProbeMaker" ;
 // Chiave per porta utensili punte a forare (marmo)
 const std::string DRILLHOLDER_KEY = "DrillHolder" ;
 // Chiave per porta utensili lame (marmo)
@@ -153,5 +166,11 @@ const std::string NST_PARTREG_LAYER = "Region" ;
 //----------------------------------------------------------------------------
 // Minima componente zeta di versore utensile per lavorazione da sopra (-45deg)
 const double MIN_ZDIR_TOP_TOOL = -0.7072 ;
-// Minima componente zeta di versose utensile èer mortasatura quasi verticale (45deg)
+// Minima componente zeta di versore utensile per mortasatura quasi verticale (45deg)
 const double MIN_ZDIR_VERT_CHSAW = 0.7072 ;
+
+//----------------------------------------------------------------------------
+// Valore di default del peso del primo asse rotante di macchina
+static const double ROT1_WEIGHT_DFLT = 1 ;
+// Valore di default per angolo di apertura del cono di direzioni coincidenti con singolarità
+static const double SING_CONE_ANG_DFLT = 0.01 ;

MachMgr.h

@@ -125,7 +125,7 @@ class MachMgr : public IMachMgr
       int  AddRawPart( const Point3d& ptOrig, double dLen, double dWidth, double dHeight, Color cCol) override ;
       int  AddRawPartWithPart( int nPartId, int nCrvSrfId, double dOverMat, Color cCol) override ;
       bool ModifyRawPart( int nRawId, const Point3d& ptOrig, double dLen, double dWidth, double dHeight, Color cCol) override ;
-      bool ModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dZmin, double dHeight, Color cCol) override ;
+      bool ModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dHeight, Color cCol) override ;
       bool ModifyRawPartSize( int nRawId, double dLength, double dWidth, double dHeight) override ;
       bool ModifyRawPartHeight( int nRawId, double dHeight) override ;
       bool KeepRawPart( int nRawId, int nSouPhase) override ;
@@ -214,10 +214,11 @@ class MachMgr : public IMachMgr
       int  GetCurrSetup( void) const override ;
       bool GetDefaultSetupName( std::string& sName) const override ;
       bool ImportSetup( const std::string& sName) override ;
+      bool ExistsCurrSetup( void) const 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 FindToolInCurrSetup( const std::string& sTool) const override ;
+      bool GetToolSetupPosInCurrSetup( const std::string& sTool, std::string& sTcPos) const override ;
+      bool GetToolsInCurrSetupPos( const std::string& sTcPos, STRVECTOR& vsTools) const override ;
       bool UpdateCurrSetup( void) override ;
       bool EraseCurrSetup( void) override ;
      // Machinings DataBase
@@ -258,16 +259,16 @@ class MachMgr : public IMachMgr
       int  GetNextOperation( int nId) const override ;
       int  GetLastOperation( void) const override ;
       int  GetPrevOperation( int nId) const override ;
-      int  GetFirstActiveOperation( void) const override ;
-      int  GetNextActiveOperation( int nId) const override ;
-      int  GetLastActiveOperation( void) const override ;
-      int  GetPrevActiveOperation( int nId) const override ;
+      int  GetFirstActiveOperation( bool bNeedMachNotEmpty = false) const override ;
+      int  GetNextActiveOperation( int nId, bool bNeedMachNotEmpty = false) const override ;
+      int  GetLastActiveOperation( bool bNeedMachNotEmpty = false) const override ;
+      int  GetPrevActiveOperation( int nId, bool bNeedMachNotEmpty = false) const override ;
       int  GetOperationType( int nId) const override ;
       int  GetOperationPhase( int nId) const override ;
       bool SetOperationName( int nId, const std::string& sName) override ;
       std::string GetOperationName( int nId) const override ;
       int  GetOperationId( const std::string& sName) const override ;
-      bool IsOperationEmpty( int nId) const override ;
+      bool IsOperationEmpty( int nId, int nEmptyType = 0) const override ;
       bool RemoveOperation( int nId) override ;
       bool RemoveAllPhaseOperations( int nPhase) override ;
       bool RemoveAllOperations( void) override ;
@@ -313,13 +314,16 @@ class MachMgr : public IMachMgr
       bool GetMachiningParam( int nType, std::string& sVal) const override ;
       bool GetMachiningGeometry( SELVECTOR& vIds) const override ;
       bool GetMachiningSkippedGeometry( SELVECTOR& vIds) const override ;
-      bool IsMachiningEmpty( void) const override ;
+      bool IsMachiningEmpty( int nEmptyType = 0) const override ;
       bool GetMachiningStartPoint( Point3d& ptStart) const override ;
       bool GetMachiningEndPoint( Point3d& ptEnd) const override ;
+      bool GetMachiningStartAxes( bool bSkipClimb, DBLVECTOR& vAxVal) const override ;
+      bool GetMachiningEndAxes( bool bSkipRise, DBLVECTOR& vAxVal) const override ;
      // CL Entities Interrogations
       bool GetClEntMove( int nEntId, int& nMove) const override ;
       bool GetClEntFlag( int nEntId, int& nFlag, int& nFlag2) const override ;
       bool GetClEntIndex( int nEntId, int& nIndex) const override ;
+      bool GetClEntFeed( int nEntId, double& dFeed) const override ;
       bool GetClEntAxesStatus( int nEntId, int& nStatus) const override ;
       bool GetClEntAxesMask( int nEntId, int& nMask) const override ;
       bool GetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) const override ;
@@ -333,6 +337,7 @@ class MachMgr : public IMachMgr
       bool SimGetMoveInfo( int& nGmove, double& dFeed) const override ;
       bool SimSetStep( double dStep) override ;
       bool SimSetUiStatus( int nUiStatus) override ;
+      bool SimEnableToolTipTrace( bool bEnable) override ;
       bool SimGoHome( void) override ;
       bool SimExit( void) override ;
      // Generation
@@ -341,21 +346,25 @@ 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 GetAllCurrAxesNames( STRVECTOR& vAxName) const override ;
+      bool SetCalcSolCh( int nScc, bool bExact) override ;
       bool SetRotAxisBlock( const std::string& sAxis, double dVal) override ;
-      bool GetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) const override ;
       bool GetCalcTable( std::string& sTable) const override ;
       bool GetCalcTool( std::string& sTool) const override ;
       bool GetCalcHead( std::string& sHead) const override ;
       bool GetCalcExit( int& nExit) const override ;
+      bool GetCalcSolCh( int& nScc, bool& bExact) const override ;
+      bool GetAllCurrAxesNames( STRVECTOR& vAxName) const override ;
+      bool GetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) const override ;
       bool GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
                           int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) const override ;
       bool GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
                           int& nStat, DBLVECTOR& vAng1, DBLVECTOR& vAng2) const override ;
       bool GetCalcPositions( const Point3d& ptP, double dAngA, double dAngB,
-                             int& nStat, double& dX, double& dY, double& dZ) const override ;
+                             double& dX, double& dY, double& dZ) const override ;
       bool GetCalcPositions( const Point3d& ptP, const DBLVECTOR& vAng,
-                             int& nStat, double& dX, double& dY, double& dZ) const override ;
+                             double& dX, double& dY, double& dZ) const override ;
+      bool GetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vector3d& vtDirA,
+                           DBLVECTOR& vAng1, DBLVECTOR& vAng2) const override ;
       bool GetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA, double dAngB,
                                     bool bOverall, bool bBottom, Point3d& ptTip) const override ;
       bool GetCalcTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR& vAng,
@@ -460,7 +469,7 @@ class MachMgr : public IMachMgr
       bool GetCurrAxisMax( int nInd, double& dHome) const ;
       bool GetCurrAxisMin( int nInd, double& dHome) const ;
       const Frame3d& GetCurrLinAxesFrame( void) const ;
-      bool GetCurrIsCenter( void) const ;
+      bool GetCurrIsMcent( void) const ;
       bool GetCurrIsRobot( void) const ;
       bool ApplyRotAxisBlock( void) ;
       void ClearRotAxisBlock( void)
@@ -472,7 +481,6 @@ class MachMgr : public IMachMgr
       double GetCalcRot1W( void) const ;
       bool GetCalcMaxDeltaR2OnFirst( void) const ;
       bool GetCalcPartDirFromAngles( const Vector3d& vtPart, const DBLVECTOR& vAng, Vector3d& vtDir) const ;
-      bool SetCalcSolCh( int nScc, bool bExact) ;
       bool VerifyAngleOutstroke( int nInd, double dAng) const ;
       bool VerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng, bool bClear, int& nStat) const ;
       bool ExistProtectedAreas( void) const ;
@@ -480,11 +488,15 @@ class MachMgr : public IMachMgr
       bool GetOperationNewName( std::string& sName) const ;
       const ToolData* GetMachiningToolData( void) const ;
      // Simulation
-      bool SimAddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType, const Vector3d& vtMove, double dPar1, double dPar2, double dPar3) ;
+      bool SimAddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType,
+                               const Vector3d& vtMove, double dPar1, double dPar2, double dPar3) ;
+      bool SimRemoveCollisionObj( int nFrameId) ;
+      bool SimGetCollisionObj( int nPos, int& nInd, bool& bToolOn, int& nFrameId, int& nType,
+                               Vector3d& vtMove, double& dPar1, double& dPar2, double& dPar3) const ;
       bool SimExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType) ;
       bool SimOnCollision(  int nCdInd, int nObjInd, int& nErr) ;
-      bool SimSetToolForVmill( const std::string& sTool, const std::string& sHead, int nExit, int nFlag, double dPar1, double dPar2,
-                               const INTVECTOR& vVmill, bool bFirst) ;
+      bool SimSetToolForVmill( const std::string& sTool, const std::string& sHead, int nExit, int nFlag,
+                               double dPar1, double dPar2, const INTVECTOR& vVmill, bool bFirst) ;
       bool SimEnableToolsForVmill( bool bEnable) ;
       int  SimMoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt) ;
       bool SimSaveCmd( int nType, int nPar, const std::string& sPar, const std::string& sPar2) ;

MachMgrBasic.cpp

@@ -16,6 +16,7 @@
 #include "MachMgr.h"
 #include "MachConst.h"
 #include "DllMain.h"
+#include "MachiningRegister.h"
 #include "/EgtDev/Include/EMkDllMain.h"
 #include "/EgtDev/Include/EGnStringUtils.h"
 #include "/EgtDev/Include/EGnFileUtils.h"
@@ -32,6 +33,8 @@ CreateMachMgr( void)
   // verifico la chiave e le opzioni
    if ( ! GetEMkNetHwKey()  &&  ! TestKeyForEMk( GetEMkKey(), 0, GetEMkLogger()))
       return nullptr ;
+  // registro classe operazione per pocketing
+   RegisterPocketing() ;
   // creo il MachMgr 
    return static_cast<IMachMgr*> ( new(nothrow) MachMgr) ;
 }

MachMgrClEntities.cpp

@@ -76,6 +76,24 @@ MachMgr::GetClEntIndex( int nEntId, int& nIndex) const
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+MachMgr::GetClEntFeed( int nEntId, double& dFeed) const
+{
+  // default
+   dFeed = 0 ;
+  // 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 la feed
+   dFeed = pCamData->GetFeed() ;
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 MachMgr::GetClEntAxesStatus( int nEntId, int& nStatus) const

MachMgrDBTools.cpp

@@ -651,6 +651,8 @@ MachMgr::UpdateStandardToolDraw( const ToolData* pTdata, int nGenCtx, int nToolC
    pTdata->GetParam( TPA_TIPFEED, dTipFeed) ;
    string sUserNotes ;
    pTdata->GetParam( TPA_USERNOTES, sUserNotes) ;
+   string sSysNotes ;
+   pTdata->GetParam( TPA_SYSNOTES, sSysNotes) ;
   // Recupero la path dell'eventuale portautensile
    string sThPath = GetToolHolderPath( sHeadName, nExit, nType, sUserNotes) ;
   // Carico generatore disegno utensile
@@ -668,6 +670,7 @@ MachMgr::UpdateStandardToolDraw( const ToolData* pTdata, int nGenCtx, int nToolC
    bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.SPEED", dSpeed) ;
    bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.TIPFEED", dTipFeed) ;
    bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.USERNOTES", sUserNotes) ;
+   bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.SYSNOTES", sSysNotes) ;
    switch ( nType) {
    case TT_DRILL_STD :
    case TT_DRILL_LONG :
@@ -712,6 +715,15 @@ MachMgr::UpdateStandardToolDraw( const ToolData* pTdata, int nGenCtx, int nToolC
       bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.THICK", dThick) ;
       bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.CORNRAD", dCornRad) ;
       break ;
+   case TT_PROBE :
+      bOk = bOk && ExeLuaSetGlobStringVar( "TOOL.TOOLHOLDER", sThPath) ;
+      bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.TOTLEN", dTotLen) ;
+      bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.LEN", dLen) ;
+      bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.DIAM", dDiam) ;
+      bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.STEMDIAM", dStemDiam) ;
+      bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.HEIGHT", dThick) ;
+      bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.CORNRAD", dCornRad) ;
+      break ;
    default :
       return TD_INT_ERR ;
    }
@@ -808,6 +820,8 @@ MachMgr::GetToolMakerKeyFromType( int nType) const
       return WATERJETMAKER_KEY ;
    case TT_COMPO :
       return "" ;
+   case TT_PROBE :
+      return PROBEMAKER_KEY ;
    }
    return "" ;
 }
@@ -849,6 +863,10 @@ MachMgr::GetToolHolderPath( const string& sHeadName, int nExit, int nType, const
       string sKey2 = sKey + ":MILL_POLISHING" ;
       sToolHolder = GetPrivateProfileStringUtf8( TOOLHOLDER_SEC.c_str(), sKey2.c_str(), "", sMachIni.c_str()) ;
    }
+   else if ( nType == TT_PROBE) {
+      string sKey2 = sKey + ":PROBE" ;
+      sToolHolder = GetPrivateProfileStringUtf8( TOOLHOLDER_SEC.c_str(), sKey2.c_str(), "", sMachIni.c_str()) ;
+   }
    if ( sToolHolder.empty())
       sToolHolder = GetPrivateProfileStringUtf8( TOOLHOLDER_SEC.c_str(), sKey.c_str(), "", sMachIni.c_str()) ;
   // Se non trovato, provo da sezione Tools di Ini di macchina

MachMgrMachGroups.cpp

@@ -387,8 +387,10 @@ MachMgr::SetCurrMachGroup( int nId)
   // aggiorno attrezzaggio attivo
    UpdateCurrSetup() ;
   // imposto la prima fase come corrente
-   if ( ! SetCurrPhase( 1))
+   if ( ! SetCurrPhase( 1)) {
+      ResetCurrMachGroup() ;
       return false ;
+   }
   // nascondo i pezzi rimasti sotto la radice
    ShowRootParts( false) ;
   // rendo visibile il nuovo gruppo corrente e la relativa macchina

MachMgrMachines.cpp

@@ -210,8 +210,8 @@ MachMgr::GetCurrMachiningsMgr( void) const
   // se DB lavorazioni non esiste, provo a crearlo e caricarlo
    if ( m_vMachines[m_nCurrMch].pMsMgr == nullptr) {
       PtrOwner<MachiningsMgr> pMsMgr( new( nothrow) MachiningsMgr) ;
-      string sMachsFile = m_vMachines[m_nCurrMch].sDir + "\\" + MACHININGS_DIR + "\\" + MACHININGS_FILE ;
-      if ( IsNull( pMsMgr)  ||  ! pMsMgr->Load( sMachsFile, GetCurrToolsMgr()))
+      string sMachsDir = m_vMachines[m_nCurrMch].sDir + "\\" + MACHININGS_DIR ;
+      if ( IsNull( pMsMgr)  ||  ! pMsMgr->Load( sMachsDir, MACHININGS_FILE, GetCurrToolsMgr()))
          return nullptr ;
      // salvo nel vettore
       const_cast<MachineData&>(  m_vMachines[m_nCurrMch]).pMsMgr = Release( pMsMgr) ;
@@ -555,6 +555,17 @@ MachMgr::SetCalcSolCh( int nScc, bool bExact)
    return pMch->SetSolCh( nScc, bExact) ;
 }
 
+//----------------------------------------------------------------------------
+bool
+MachMgr::GetCalcSolCh( int& nScc, bool& bExact) const
+{
+   Machine* pMch = GetCurrMachine() ;
+   if ( pMch == nullptr)
+      return false ;
+  // recupero il criterio di scelta della soluzione
+   return pMch->GetSolCh( nScc, bExact) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 MachMgr::GetCalcTable( string& sTable) const
@@ -624,7 +635,7 @@ bool
 MachMgr::GetCalcMaxDeltaR2OnFirst( void) const
 {
    Machine* pMch = GetCurrMachine() ;
-   return ( ( pMch != nullptr) ? pMch->GetCurrMaxDeltaR2OnFirst() : true) ;
+   return ( ( pMch != nullptr) ? pMch->GetCurrCalcMaxDeltaR2OnFirst() : true) ;
 }
 
 //----------------------------------------------------------------------------
@@ -741,12 +752,12 @@ MachMgr::GetCurrLinAxesFrame( void) const
 
 //----------------------------------------------------------------------------
 bool
-MachMgr::GetCurrIsCenter( void) const
+MachMgr::GetCurrIsMcent( void) const
 {
    Machine* pMch = GetCurrMachine() ;
    if ( pMch == nullptr)
       return false ;
-   return ( pMch->GetCurrKinematicChainType() == KIN_CHAIN_CENTER) ;
+   return ( pMch->GetCurrKinematicChainType() == KIN_CHAIN_MCENT) ;
 }
 
 //----------------------------------------------------------------------------
@@ -780,20 +791,29 @@ MachMgr::GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
 //----------------------------------------------------------------------------
 bool
 MachMgr::GetCalcPositions( const Point3d& ptP, double dAngA, double dAngB,
-                           int& nStat, double& dX, double& dY, double& dZ) const
+                           double& dX, double& dY, double& dZ) const
 {
    DBLVECTOR vAng( 2) ; vAng[0] = dAngA ; vAng[1] = dAngB ;
    Machine* pMch = GetCurrMachine() ;
-   return ( ( pMch != nullptr) ? pMch->GetPositions( ptP, vAng, nStat, dX, dY, dZ) : false) ;
+   return ( ( pMch != nullptr) ? pMch->GetPositions( ptP, vAng, dX, dY, dZ) : false) ;
 }
 
 //----------------------------------------------------------------------------
 bool
 MachMgr::GetCalcPositions( const Point3d& ptP, const DBLVECTOR& vAng,
-                           int& nStat, double& dX, double& dY, double& dZ) const
+                           double& dX, double& dY, double& dZ) const
 {
    Machine* pMch = GetCurrMachine() ;
-   return ( ( pMch != nullptr) ? pMch->GetPositions( ptP, vAng, nStat, dX, dY, dZ) : false) ;
+   return ( ( pMch != nullptr) ? pMch->GetPositions( ptP, vAng, dX, dY, dZ) : false) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+MachMgr::GetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vector3d& vtDirA,
+                         DBLVECTOR& vAng1, DBLVECTOR& vAng2) const
+{
+   Machine* pMch = GetCurrMachine() ;
+   return ( ( pMch != nullptr) ? pMch->GetRobotAngles( ptP, vtDirT, vtDirA, vAng1, vAng2) : false) ;
 }
 
 //----------------------------------------------------------------------------

MachMgrOperations.cpp

@@ -100,48 +100,52 @@ MachMgr::GetPrevOperation( int nId) const
 
 //----------------------------------------------------------------------------
 int
-MachMgr::GetFirstActiveOperation( void) const
+MachMgr::GetFirstActiveOperation( bool bNeedMachNotEmpty) const
 {
    int nId = GetFirstOperation() ;
    int nMode ;
    while ( nId != GDB_ID_NULL  &&
-           m_pGeomDB->GetCalcMode( nId, nMode)  &&  nMode == GDB_MD_HIDDEN)
+           (( m_pGeomDB->GetCalcMode( nId, nMode)  &&  nMode == GDB_MD_HIDDEN)  ||
+            ( bNeedMachNotEmpty  &&  IsValidMachiningType( GetOperationType( nId))  &&  IsOperationEmpty( nId, NEED_ONE_TP_OK))))
       nId = GetNextOperation( nId) ;
    return nId ;
 }
 
 //----------------------------------------------------------------------------
 int
-MachMgr::GetNextActiveOperation( int nId) const
+MachMgr::GetNextActiveOperation( int nId, bool bNeedMachNotEmpty) const
 {
    int nNextId = GetNextOperation( nId) ;
    int nMode ;
    while ( nNextId != GDB_ID_NULL  &&
-           m_pGeomDB->GetCalcMode( nNextId, nMode)  &&  nMode == GDB_MD_HIDDEN)
+           (( m_pGeomDB->GetCalcMode( nNextId, nMode)  &&  nMode == GDB_MD_HIDDEN)  ||
+            ( bNeedMachNotEmpty  &&  IsValidMachiningType( GetOperationType( nNextId))  &&  IsOperationEmpty( nNextId, NEED_ONE_TP_OK))))
       nNextId = GetNextOperation( nNextId) ;
    return nNextId ;
 }
 
 //----------------------------------------------------------------------------
 int
-MachMgr::GetLastActiveOperation( void) const
+MachMgr::GetLastActiveOperation( bool bNeedMachNotEmpty) const
 {
    int nId = GetLastOperation() ;
    int nMode ;
    while ( nId != GDB_ID_NULL  &&
-           m_pGeomDB->GetCalcMode( nId, nMode)  &&  nMode == GDB_MD_HIDDEN)
+           (( m_pGeomDB->GetCalcMode( nId, nMode)  &&  nMode == GDB_MD_HIDDEN)  ||
+            ( bNeedMachNotEmpty  &&  IsValidMachiningType( GetOperationType( nId))  &&  IsOperationEmpty( nId, NEED_ONE_TP_OK))))
       nId = GetPrevOperation( nId) ;
    return nId ;
 }
 
 //----------------------------------------------------------------------------
 int
-MachMgr::GetPrevActiveOperation( int nId) const
+MachMgr::GetPrevActiveOperation( int nId, bool bNeedMachNotEmpty) const
 {
    int nPrevId = GetPrevOperation( nId) ;
    int nMode ;
    while ( nPrevId != GDB_ID_NULL  &&
-           m_pGeomDB->GetCalcMode( nPrevId, nMode)  &&  nMode == GDB_MD_HIDDEN)
+           (( m_pGeomDB->GetCalcMode( nPrevId, nMode)  &&  nMode == GDB_MD_HIDDEN)  ||
+            ( bNeedMachNotEmpty  &&  IsValidMachiningType( GetOperationType( nPrevId))  &&  IsOperationEmpty( nPrevId, NEED_ONE_TP_OK))))
       nPrevId = GetPrevOperation( nPrevId) ;
    return nPrevId ;
 }
@@ -180,14 +184,11 @@ MachMgr::GetOperationPhase( int nId) const
 bool
 MachMgr::GetOperationNewName( string& sName) const
 {
-  // il parametro nome deve essere valido
-   if ( &sName == nullptr)
-      return false ;
   // il gruppo per le operazioni deve essere presente nella macchinata corrente
    if ( GetCurrOperId() == GDB_ID_NULL)
       return false ;
   // se nome vuoto, assegno radice standard
-   if ( sName.empty())
+   if ( ! IsValidVal( sName))
       sName = "Oper" ;
   // se presenti caratteri vietati, li sostituisco
    ValidateVal( sName) ;
@@ -214,6 +215,9 @@ MachMgr::SetOperationName( int nId, const string& sName)
   // verifico che faccia parte del gruppo delle operazioni
    if ( pIter->GetParentId() != GetCurrOperId())
       return false ;
+  // verifico che il nome sia valido
+   if ( ! IsValidVal( sName))
+      return false ;
   // verifico che il nome non sia già usato da una operazione
    if ( GetOperationId( sName) != GDB_ID_NULL)
       return false ;
@@ -228,10 +232,10 @@ MachMgr::GetOperationName( int nId) const
   // recupero l'operazione
    PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGeomDB)) ;
    if ( IsNull( pIter)  ||  ! pIter->GoTo( nId))
-      return 0 ;
+      return "" ;
   // verifico che faccia parte del gruppo delle operazioni
    if ( pIter->GetParentId() != GetCurrOperId())
-      return 0 ;
+      return "" ;
   // recupero il nome dell'operazione riferita
    string sName ;
    pIter->GetName( sName) ;
@@ -243,12 +247,12 @@ int
 MachMgr::GetOperationId( const string& sName) const
 {
   // verifica dei parametri
-   if ( &sName == nullptr  ||  sName.empty())
-      return false ;
+   if ( ! IsValidVal( sName))
+      return GDB_ID_NULL ;
   // recupero l'identificativo dell'operazione con il nome indicato
    PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGeomDB)) ;
    if ( IsNull( pIter))
-      return false ;
+      return GDB_ID_NULL ;
    bool bIter = pIter->GoToFirstInGroup( GetCurrOperId()) ;
    while ( bIter) {
      // verifico il nome
@@ -263,7 +267,7 @@ MachMgr::GetOperationId( const string& sName) const
 
 //----------------------------------------------------------------------------
 bool
-MachMgr::IsOperationEmpty( int nId) const
+MachMgr::IsOperationEmpty( int nId, int nEmptyType) const
 {
   // verifiche
    if ( m_pGeomDB == nullptr  ||  m_pGeomDB->GetParentId( nId) != GetCurrOperId())
@@ -273,7 +277,7 @@ MachMgr::IsOperationEmpty( int nId) const
    if ( pOpe == nullptr)
       return true ;
   // restituisco se vuota
-   return pOpe->IsEmpty() ;
+   return pOpe->IsEmpty( nEmptyType) ;
 }
 
 //----------------------------------------------------------------------------
@@ -1279,7 +1283,7 @@ MachMgr::GetMachiningSkippedGeometry( SELVECTOR& vIds) const
 
 //----------------------------------------------------------------------------
 bool
-MachMgr::IsMachiningEmpty( void) const
+MachMgr::IsMachiningEmpty( int nEmptyType) const
 {
   // recupero la lavorazione corrente
    int nCurrMchId = GetCurrMachining() ;
@@ -1290,7 +1294,7 @@ MachMgr::IsMachiningEmpty( void) const
    if ( pMch == nullptr)
       return true ;
   // restituisco lo stato
-   return pMch->IsEmpty() ;
+   return pMch->IsEmpty( nEmptyType) ;
 }
 
 //----------------------------------------------------------------------------
@@ -1324,3 +1328,35 @@ MachMgr::GetMachiningEndPoint( Point3d& ptEnd) const
   // restituisco il punto finale dell'ultimo percorso di lavorazione
    return pMch->GetEndPoint( ptEnd)  ;
 }
+
+//----------------------------------------------------------------------------
+bool
+MachMgr::GetMachiningStartAxes( bool bSkipClimb, DBLVECTOR& vAxVal) const
+{
+  // recupero la lavorazione corrente
+   int nCurrMchId = GetCurrMachining() ;
+   if ( nCurrMchId == GDB_ID_NULL)
+      return false ;
+  // ne recupero il gestore
+   Machining* pMch = GetMachining( m_pGeomDB->GetUserObj( nCurrMchId)) ;
+   if ( pMch == nullptr)
+      return false ;
+  // recupero i valori
+   return pMch->GetInitialAxesValues( bSkipClimb, vAxVal) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+MachMgr::GetMachiningEndAxes( bool bSkipRise, DBLVECTOR& vAxVal) const
+{
+  // recupero la lavorazione corrente
+   int nCurrMchId = GetCurrMachining() ;
+   if ( nCurrMchId == GDB_ID_NULL)
+      return false ;
+  // ne recupero il gestore
+   Machining* pMch = GetMachining( m_pGeomDB->GetUserObj( nCurrMchId)) ;
+   if ( pMch == nullptr)
+      return false ;
+  // recupero i valori
+   return pMch->GetFinalAxesValues( bSkipRise, vAxVal) ;
+}

MachMgrRawParts.cpp

@@ -28,6 +28,8 @@
 #include "/EgtDev/Include/EGkSfrCreate.h"
 #include "/EgtDev/Include/EGkStmStandard.h"
 #include "/EgtDev/Include/EGkStmFromCurves.h"
+#include "/EgtDev/Include/EGkSurfBezier.h"
+#include "/EgtDev/Include/EGkCAvSilhouetteSurfTm.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
 #include "/EgtDev/Include/EXeConst.h"
 
@@ -284,7 +286,7 @@ MachMgr::AddRawPart( int nCrvId, double dOverMat, double dZmin, double dHeight,
   // assegno la fase al gruppo
    m_pGeomDB->SetInfo( nRawId, MACH_RAW_PHASE, m_nCurrPhase) ;
   // creo solido e outline
-   bOk = bOk && ModifyRawPart( nRawId, nCrvId, dOverMat, dZmin, dHeight, cCol) ;
+   bOk = bOk && ModifyRawPart( nRawId, nCrvId, dOverMat, dHeight, cCol) ;
   // se qualcosa è andato storto, cancello tutto
    if ( ! bOk) {
       m_pGeomDB->Erase( nRawId) ;
@@ -296,7 +298,7 @@ MachMgr::AddRawPart( int nCrvId, double dOverMat, double dZmin, double dHeight,
 
 //----------------------------------------------------------------------------
 bool
-MachMgr::ModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dZmin, double dHeight, Color cCol)
+MachMgr::ModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dHeight, Color cCol)
 {
   // verifica validità grezzo
    if ( ! VerifyRawPart( nRawId))
@@ -337,7 +339,7 @@ MachMgr::ModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dZmin, d
    if ( IsNull( pOffsCrv))
       return false ;
   // creo il solido
-   PtrOwner<ISurfTriMesh> pStm( GetSurfTriMeshByExtrusion( pOffsCrv, Vector3d(0,0,dHeight), true)) ;
+   PtrOwner<ISurfTriMesh> pStm( GetSurfTriMeshByExtrusion( pOffsCrv, Vector3d( 0, 0, dHeight), true)) ;
    if ( IsNull( pStm))
       return false ;
   // cancello eventuali vecchi solidi e curve di outline
@@ -375,6 +377,10 @@ MachMgr::AddRawPart( int nSurfId, Color cCol)
    int nRawGroupId = GetCurrRawGroupId() ;
    if ( nRawGroupId == GDB_ID_NULL)
       return GDB_ID_NULL ;
+  // verifico che la superficie sia chiusa
+   const ISurf* pSurf = GetSurf( m_pGeomDB->GetGeoObj( nSurfId)) ;
+   if ( pSurf == nullptr  ||  ! pSurf->IsClosed())
+      return GDB_ID_NULL ;
   // recupero l'ingombro della superficie in globale
    BBox3d b3Surf ;
    if ( ! m_pGeomDB->GetGlobalBBox( nSurfId, b3Surf))
@@ -388,8 +394,23 @@ MachMgr::AddRawPart( int nSurfId, Color cCol)
    bool bOk = m_pGeomDB->SetName( nRawId, MACH_RAW_PART) ;
   // assegno la fase al gruppo
    m_pGeomDB->SetInfo( nRawId, MACH_RAW_PHASE, m_nCurrPhase) ;
-  // copio la superficie nel gruppo
-   int nId = m_pGeomDB->CopyGlob( nSurfId, GDB_ID_NULL, nRawId) ;
+  // creo il grezzo
+   int nId = GDB_ID_NULL ;
+  // partendo da superficie Trimesh copio 
+   if ( pSurf->GetType() == SRF_TRIMESH)
+      nId = m_pGeomDB->CopyGlob( nSurfId, GDB_ID_NULL, nRawId) ;
+  // partendo da superficie Bezier devo recuperare la Trimesh ausiliaria e copiarla
+   else if ( pSurf->GetType() == SRF_BEZIER) {
+      const ISurfBezier* pSbez = GetSurfBezier( pSurf) ;
+      const ISurfTriMesh* pAuxStm = ( pSbez != nullptr ? pSbez->GetAuxSurf() : nullptr) ;
+      PtrOwner<ISurfTriMesh> pStm( pAuxStm != nullptr ? pAuxStm->Clone() : nullptr) ;
+      if ( ! IsNull( pStm)) {
+         Frame3d frSbez ;
+         m_pGeomDB->GetGlobFrame( nSurfId, frSbez) ;
+         pStm->LocToLoc( frSbez, frRaw) ;
+         nId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nRawId, Release( pStm)) ;
+      }
+   }
    bOk = bOk && ( nId != GDB_ID_NULL) ;
   // assegno il nome al solido
    bOk = bOk && m_pGeomDB->SetName( nId, MACH_RAW_SOLID) ;
@@ -406,37 +427,70 @@ MachMgr::AddRawPart( int nSurfId, Color cCol)
       if ( IsNull( pCrvCompo))
          return GDB_ID_NULL ;
      // recupero la superficie trimesh
-      ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nId)) ;
+      const ISurfTriMesh* pStm = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nId)) ;
       if ( pStm == nullptr)
          return GDB_ID_NULL ;
      // recupero l'ingombro della superficie in locale
       BBox3d b3Srf ;
       pStm->GetLocalBBox( b3Srf) ;
      // ne calcolo la silhouette secondo Z+
-      POLYLINEVECTOR vPL ;
       bool bSilh = false ;
-      if ( pStm->GetSilhouette( Z_AX, 10.0, vPL)  &&  vPL.size() > 0) {
-        // cerco il contorno esterno
-         int nInd = - 1 ;
-         double dMaxArea = 0 ;
-         for ( int i = 0 ; i < int( vPL.size()) ; ++ i) {
-            double dArea ;
-            if ( vPL[i].GetAreaXY( dArea)  &&  abs( dArea) > dMaxArea) {
-               if ( dArea < 0)
-                  vPL[i].Invert() ;
-               dMaxArea = abs( dArea) ;
-               nInd = i ;
+      const int NUM_TRIA_LIM = 500 ;
+      if ( pStm->GetTriangleCount() < NUM_TRIA_LIM) {
+         POLYLINEVECTOR vPL ;
+         if ( pStm->GetSilhouette( Z_AX, 10.0, vPL)  &&  ! vPL.empty()) {
+           // cerco il contorno esterno
+            int nInd = - 1 ;
+            double dMaxArea = 0 ;
+            for ( int i = 0 ; i < int( vPL.size()) ; ++ i) {
+               double dArea ;
+               if ( vPL[i].GetAreaXY( dArea)  &&  abs( dArea) > dMaxArea) {
+                  if ( dArea < 0)
+                     vPL[i].Invert() ;
+                  dMaxArea = abs( dArea) ;
+                  nInd = i ;
+               }
+            }
+           // ne deduco la curva
+            PtrOwner<ICurveComposite> pCrvSilh( CreateCurveComposite()) ;
+            if ( nInd >= 0  &&  pCrvSilh->FromPolyLine( vPL[nInd])) {
+               pCrvSilh->SetExtrusion( Z_AX) ;
+               Plane3d plProj ;
+               plProj.Set( b3Srf.GetMin(), Z_AX) ;
+               pCrvCompo.Set( GetCurveComposite( ProjectCurveOnPlane( *pCrvSilh, plProj))) ;
+               if ( ! IsNull( pCrvCompo)) {
+                  pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
+                  bSilh = true ;
+               }
             }
          }
-        // ne deduco la curva
-         PtrOwner<ICurveComposite> pCrvSilh( CreateCurveComposite()) ;
-         if ( nInd >= 0  &&  pCrvSilh->FromPolyLine( vPL[nInd])) {
-            pCrvSilh->SetExtrusion( Z_AX) ;
-            Plane3d plProj ;
-            plProj.Set( b3Srf.GetMin(), Z_AX) ;
-            pCrvCompo.Set( GetCurveComposite( ProjectCurveOnPlane( *pCrvSilh, plProj))) ;
-            pCrvCompo->MergeCurves( 10 * EPS_SMALL, 10 * EPS_ANG_SMALL) ;
-            bSilh = ( ! IsNull( pCrvCompo)) ;
+      }
+      else {
+         PtrOwner<ICAvParSilhouettesSurfTm> pCavParSilh( CreateCAvParSilhouettesSurfTm()) ;
+         if ( ! IsNull( pCavParSilh)) {
+            Frame3d frSrf( b3Srf.GetMin()) ;
+            const double SILH_TOL = 1.0 ;
+            POLYLINEVECTOR vPL ;
+            if ( pCavParSilh->SetData( { pStm}, frSrf, SILH_TOL)  &&
+                 pCavParSilh->GetSilhouette( 0, vPL)) {
+              // cerco il contorno esterno
+               int nInd = - 1 ;
+               double dMaxArea = 0 ;
+               for ( int i = 0 ; i < int( vPL.size()) ; ++ i) {
+                  double dArea ;
+                  if ( vPL[i].GetAreaXY( dArea)  &&  abs( dArea) > dMaxArea) {
+                     if ( dArea < 0)
+                        vPL[i].Invert() ;
+                     dMaxArea = abs( dArea) ;
+                     nInd = i ;
+                  }
+               }
+              // ne deduco la curva
+               if ( nInd >= 0  &&  pCrvCompo->FromPolyLine( vPL[nInd])) {
+                  pCrvCompo->SetExtrusion( Z_AX) ;
+                  bSilh = true ;
+               }
+            }
          }
       }
      // non riuscita, la calcolo come contorno del box
@@ -450,7 +504,9 @@ MachMgr::AddRawPart( int nSurfId, Color cCol)
          PL.AddUPoint( 2, ptMin + Vector3d( dDimX, dDimY,0)) ;
          PL.AddUPoint( 3, ptMin + Vector3d( 0, dDimY,0)) ;
          PL.AddUPoint( 4, ptMin) ;
-         if ( ! pCrvCompo->FromPolyLine( PL)  &&  ! pCrvCompo->SetExtrusion( Z_AX))
+         if ( pCrvCompo->FromPolyLine( PL))
+            pCrvCompo->SetExtrusion( Z_AX) ;
+         else
             bOk = false ;
       }
      // inserisco la curva composita nel DB
@@ -604,12 +660,12 @@ MachMgr::AddRawPart( int nSfrUpId, int nSfrDownId, double dHeight, Color cCol)
       bOk = bOk && ( nSurfUpId != GDB_ID_NULL) ;
       bOk = bOk && m_pGeomDB->SetName( nSurfUpId, MACH_RAW_UP_REG) ;
       bOk = bOk && m_pGeomDB->SetMaterial( nSurfUpId, cCol) ;
-      bOk = bOk && m_pGeomDB->SetStatus( nSurfUpId, GDB_ST_OFF) ;
+      bOk = bOk && m_pGeomDB->SetMode( nSurfUpId, GDB_MD_HIDDEN) ;
       int nSurfDownId = ( bOk ? m_pGeomDB->CopyGlob( nSfrDownId, GDB_ID_NULL, nRawId) : GDB_ID_NULL) ;
       bOk = bOk && ( nSurfDownId != GDB_ID_NULL) ;
       bOk = bOk && m_pGeomDB->SetName( nSurfDownId, MACH_RAW_DOWN_REG) ;
       bOk = bOk && m_pGeomDB->SetMaterial( nSurfDownId, cCol) ;
-      bOk = bOk && m_pGeomDB->SetStatus( nSurfDownId, GDB_ST_OFF) ;
+      bOk = bOk && m_pGeomDB->SetMode( nSurfDownId, GDB_MD_HIDDEN) ;
    }
 
   // se qualcosa è andato storto, cancello tutto

MachMgrSetup.cpp

@@ -71,6 +71,13 @@ MachMgr::ImportSetup( const string& sName)
    return m_stuMgr.Save() ;
 }
 
+//----------------------------------------------------------------------------
+bool
+MachMgr::ExistsCurrSetup( void) const
+{
+   return m_stuMgr.Exists() ;
+}
+
 //----------------------------------------------------------------------------
 bool
 MachMgr::VerifyCurrSetup( STRVECTOR& vsErrors)
@@ -125,21 +132,21 @@ MachMgr::VerifyCurrSetup( STRVECTOR& vsErrors)
 
 //----------------------------------------------------------------------------
 bool
-MachMgr::FindToolInCurrSetup( const string& sTool)
+MachMgr::FindToolInCurrSetup( const string& sTool) const
 {
    return m_stuMgr.FindTool( sTool) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-MachMgr::GetToolSetupPosInCurrSetup( const string& sTool, string& sTcPos)
+MachMgr::GetToolSetupPosInCurrSetup( const string& sTool, string& sTcPos) const
 {
    return m_stuMgr.GetToolSetupPos( sTool, sTcPos) ;
 }
 
 //----------------------------------------------------------------------------
 bool
-MachMgr::GetToolsInCurrSetupPos( const string& sTcPos, STRVECTOR& vsTools)
+MachMgr::GetToolsInCurrSetupPos( const string& sTcPos, STRVECTOR& vsTools) const
 {
    return m_stuMgr.GetToolsInSetupPos( sTcPos, vsTools) ;
 }

MachMgrSimulation.cpp

@@ -130,6 +130,17 @@ MachMgr::SimSetUiStatus( int nUiStatus)
    return m_pSimul->SetUiStatus( nUiStatus) ;
 }
 
+//----------------------------------------------------------------------------
+bool
+MachMgr::SimEnableToolTipTrace( bool bEnable)
+{
+  // verifico simulatore
+   if ( m_pSimul == nullptr)
+      return false ;
+  // imposto abilitazione disegno traccia della punta utensile
+   return m_pSimul->EnableToolTipTrace( bEnable) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 MachMgr::SimGoHome( void)
@@ -165,6 +176,29 @@ MachMgr::SimAddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType, co
    return m_pSimul->AddCollisionObj( nInd, bToolOn, nFrameId, nType, vtMove, dPar1, dPar2, dPar3) ;
 }
 
+//----------------------------------------------------------------------------
+bool
+MachMgr::SimRemoveCollisionObj( int nFrameId)
+{
+  // verifico simulatore
+   if ( m_pSimul == nullptr)
+      return false ;
+  // rimuovo gli oggetti da verificare per la collisione con il grezzo con FrameId indicato
+   return m_pSimul->RemoveCollisionObj( nFrameId) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+MachMgr::SimGetCollisionObj( int nPos, int& nInd, bool& bToolOn, int& nFrameId, int& nType,
+                             Vector3d& vtMove, double& dPar1, double& dPar2, double& dPar3) const
+{
+  // verifico simulatore
+   if ( m_pSimul == nullptr)
+      return false ;
+  // recupero i dati dell'oggetto di collisione di posizione indicata nel relativo vettore
+   return m_pSimul->GetCollisionObj( nPos, nInd, bToolOn, nFrameId, nType, vtMove, dPar1, dPar2, dPar3) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 MachMgr::SimExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType)

Machine.cpp

@@ -34,6 +34,7 @@ Machine::Machine( void)
 {
    m_pMchMgr = nullptr ;
    m_pGeomDB = nullptr ;
+   m_nContextId = 0 ;
    m_nGroupId = GDB_ID_NULL ;
    m_nTempGroupId = GDB_ID_NULL ;
    m_dAxisMaxAdjust = EPS_SMALL ;
@@ -42,14 +43,17 @@ Machine::Machine( void)
    m_dExitMaxRotAdj = 10 * EPS_ANG_SMALL ;
    m_dAngDeltaMinForHome = INFINITO ;
    m_nMultiProcess = 0 ;
+   m_nLinkAxesMoveOrder = 0 ;
    m_nNewLinkMgr = 0 ;
    m_nCalcTabId = GDB_ID_NULL ;
    m_nCalcHeadId = GDB_ID_NULL ;
    m_nCalcExitId = GDB_ID_NULL ;
    m_nCalcToolId = GDB_ID_NULL ;
-   m_dCalcRot1W = 1 ;
+   m_dCalcRot1W = ROT1_WEIGHT_DFLT ;
+   m_dSingConeAng = SING_CONE_ANG_DFLT ;
    m_bCalcMaxDeltaR2On1 = true ;
    m_nCalcSolCh = MCH_SCC_NONE ;
+   m_bSolChExact = false ;
    m_dCalcTLen = 0 ;
    m_dCalcTRad = 0 ;
    m_dCalcTOvLen = 0 ;
@@ -87,6 +91,7 @@ Machine::Clear( void)
   // reset membri
    m_pMchMgr = nullptr ;
    m_pGeomDB = nullptr ;
+   m_nContextId = 0 ;
    m_sName.clear() ;
    m_sMachineDir.clear() ;
    m_nGroupId = GDB_ID_NULL ;
@@ -106,6 +111,7 @@ Machine::Init( const string& sMachineName, const string& sMachineDir, MachMgr* p
       return false ;
    m_pMchMgr = pMchMgr ;
    m_pGeomDB = m_pMchMgr->GetGeomDB() ;
+   m_nContextId = m_pMchMgr->GetContextId() ;
   // verifico direttorio dati macchina
    m_sMachineDir = sMachineDir ;
    if ( ! ExistsDirectory( m_sMachineDir))
@@ -135,9 +141,7 @@ Machine::Init( const string& sMachineName, const string& sMachineDir, MachMgr* p
   // in caso di errore, cancello tutta la geometria
    if ( ! bOk) {
       m_pGeomDB->Erase( m_nGroupId) ;
-      m_pGeomDB->Erase( m_nTempGroupId) ;
       m_nGroupId = GDB_ID_NULL ;
-      m_nTempGroupId = GDB_ID_NULL ;
       m_sName.clear() ;
       m_sMachineDir.clear() ;
    }
@@ -293,8 +297,8 @@ Machine::AdjustTable( int nLay, const Point3d& ptRef1)
 //----------------------------------------------------------------------------
 bool
 Machine::LoadMachineAxis( const string& sName, const string& sParent, const string& sToken, bool bInvert,
-                          double dOffset, int nType, const Point3d& ptPos, const Vector3d& vtDir, const STROKE& Stroke,
-                          double dHome, bool bAdjustAux, const string& sGeo, const STRVECTOR& vsAux)
+                          double dOffset, int nType, int nUse, const Point3d& ptPos, const Vector3d& vtDir,
+                          const STROKE& Stroke, double dHome, bool bAdjustAux, const string& sGeo, const STRVECTOR& vsAux)
 {
   // verifico sia di tipo ammesso
    if ( nType != MCH_AT_LINEAR  &&  nType != MCH_AT_ROTARY) {
@@ -334,7 +338,7 @@ Machine::LoadMachineAxis( const string& sName, const string& sParent, const stri
    Axis* pAxis = new(nothrow) Axis ;
    if ( pAxis == nullptr)
       return false ;
-   pAxis->Set( sName, sToken, bInvert, dOffset, nType, ptPos, vtDir, Stroke, dHome) ;
+   pAxis->Set( sName, sToken, bInvert, dOffset, nType, nUse, ptPos, vtDir, Stroke, dHome) ;
    m_pGeomDB->SetUserObj( nLay, pAxis) ;
   // verifico il vettore rappresentativo dell'asse
    if ( ! AdjustAxis( nLay, sPart, sName, nType, ptPos, vtDir, bAdjustAux))

Machine.h

@@ -88,8 +88,10 @@ class Machine
                { return m_dAngDeltaMinForHome ; }
       bool GetMultiProcess( int nOpt = 1) const
                { return ( m_nMultiProcess >= nOpt) ; }
+      int  GetLinkAxesMoveOrder( void) const
+               { return m_nLinkAxesMoveOrder ; }
       bool GetNewLinkMgr( int nOpt = 1) const
-               { return ( m_nNewLinkMgr >= nOpt) ; }
+               { return ( m_nNewLinkMgr >= nOpt  ||  m_nCalcChainType == KIN_CHAIN_ROBOT) ; }
       bool LoadTool( const std::string& sHead, int nExit, const std::string& sTool) ;
       bool GetLoadedTool( const std::string& sHead, int nExit, std::string& sTool) const ;
       bool UnloadTool( const std::string& sHead, int nExit) ;
@@ -98,6 +100,7 @@ class Machine
       bool LoadAllTools( void) ;
       bool UnloadAllTools( void) ;
       bool ResetHeadSet( const std::string& sHead) ;
+      const STRVECTOR& GetHSet( const std::string& sHead) const ;
       bool GetAxisToken( const std::string& sAxis, std::string& sToken) const ;
       bool GetAxisInvert( const std::string& sAxis, bool& bInvert) const ;
       bool GetAxisOffset( const std::string& sAxis, double& dOffset) const ;
@@ -133,7 +136,11 @@ class Machine
       bool IsCurrToolFloating( void) const ;
       double GetCurrRot1W( void) const
                 { return m_dCalcRot1W ; }
-      bool GetCurrMaxDeltaR2OnFirst( void) const
+      bool SetSingConeAng( double dAng)
+                { m_dSingConeAng = dAng ; return true ;}
+      double GetCurrSingConeAng( void) const
+                { return m_dSingConeAng ; }
+      bool GetCurrCalcMaxDeltaR2OnFirst( void) const
                 { return m_bCalcMaxDeltaR2On1 ; }
       std::string GetKinematicAxis( int nInd) const ;
       bool BlockKinematicRotAxis( const std::string& sName, double dVal) ;
@@ -143,6 +150,8 @@ class Machine
       bool IsKinematicRotAxisBlocked( int nInd) const ;
       bool GetKinematicRotAxisBlocked( int nInd, std::string& sName, double& dVal) const ;
       bool SetSolCh( int nScc, bool bExact) ;
+      bool GetSolCh( int& nScc, bool& bExact)
+                { nScc = m_nCalcSolCh ; bExact = m_bSolChExact ; return true ; }
       int  GetCurrLinAxes( void) const ;
       int  GetCurrRotAxes( void) const ;
       bool GetCurrAxisName( int nInd, std::string& sAxName) const ;
@@ -165,7 +174,7 @@ class Machine
       bool GetAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
                       int& nStat, DBLVECTOR& vAng1, DBLVECTOR& vAng2) const ;
       bool GetPositions( const Point3d& ptP, const DBLVECTOR& vAng,
-                         int& nStat, double& dX, double& dY, double& dZ) const ;
+                         double& dX, double& dY, double& dZ) const ;
       bool GetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vector3d& vtDirA,
                            DBLVECTOR& vAng1, DBLVECTOR& vAng2) const ;
       bool GetNoseFromPositions( double dX, double dY, double dZ, const DBLVECTOR& vAng,
@@ -182,7 +191,7 @@ class Machine
       bool VerifyAngleOutstroke( int nInd, double dAng) const ;
       bool VerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng, bool bClear, int& nStat) const ;
       bool ExistProtectedAreas( void) const ;
-      bool VerifyProtectedAreas( double dX, double dY, double dZ, const DBLVECTOR& vAng, int nLinkType, int& nStat) ;
+      bool VerifyProtectedAreas( double dX, double dY, double dZ, const DBLVECTOR& vAng, int& nStat) ;
       bool VerifyOutstroke( const std::string& sAxName, double dVal) const ;
       std::string GetOutstrokeInfo( bool bMM = true) const ;
       void ResetOutstrokeInfo( void) const
@@ -226,8 +235,8 @@ class Machine
                              const STRVECTOR& vsColl, const std::string& sGeo, const STRVECTOR& vsAux) ;
       bool AdjustTable( int nLay, const Point3d& ptRef1) ;
       bool LoadMachineAxis( const std::string& sName, const std::string& sParent, const std::string& sToken, bool bInvert,
-                            double dOffset, int nType, const Point3d& ptPos, const Vector3d& vtDir, const STROKE& Stroke,
-                            double dHome, bool bAdjustAux, const std::string& sGeo, const STRVECTOR& vsAux) ;
+                            double dOffset, int nType, int nUse, const Point3d& ptPos, const Vector3d& vtDir,
+                            const STROKE& Stroke, double dHome, bool bAdjustAux, const std::string& sGeo, const STRVECTOR& vsAux) ;
       bool AdjustAxis( int nLay, const std::string& sPart, const std::string& sName,
                        int nType, const Point3d& ptPos, const Vector3d& vtDir, bool bAdjustAux) ;
       bool ModifyMachineAxisPosition( const std::string& sName, const Point3d& ptPos) ;
@@ -259,7 +268,6 @@ class Machine
       TcPos* GetTcPos( int nGroup) const ;
       Exit* GetExit( int nGroup) const ;
       bool AddHeadToSet( const std::string& sHSet, const std::string& sName) ;
-      const STRVECTOR& GetHSet( const std::string& sHead) const ;
       bool EnableHeadInSet( const std::string& sHead) ;
       bool LoadTool( Exit* pExit, const std::string& sTool) ;
       bool ModifyMachineHeadAuxDirection( const std::string& sHead, const Vector3d& vtADir) ;
@@ -289,6 +297,7 @@ class Machine
       // generali
       MachMgr*      m_pMchMgr ;              // puntatore al gestore di tutte le lavorazioni
       IGeomDB*      m_pGeomDB ;              // puntatore al DB geometrico
+      int           m_nContextId ;           // indice contesto corrente (1-based)
       LuaMgr        m_LuaMgr ;               // interprete lua della macchina
       Writer        m_Writer ;               // scrittore di file di testo
       // dati macchina
@@ -303,6 +312,7 @@ class Machine
       double        m_dExitMaxRotAdj ;       // massima rotazione di aggiustamento uscita da geometria a descrizione cinematica
       double        m_dAngDeltaMinForHome ;  // minima differenza angolare da valore precedente per scegliere di stare vicino a home
       int           m_nMultiProcess ;        // codice di macchina multi-processo (con stima speciale e simulazione ad hoc)
+      int           m_nLinkAxesMoveOrder ;   // codice ordine interpolazione assi nei collegamenti (0=interpolati, ...)
       int           m_nNewLinkMgr ;          // codice del nuovo gestore link tra lavorazioni (0=vecchio, 1=nuovo)
       INTVECTOR     m_vLinkedRawParts ;      // elenco dei grezzi agganciati a gruppi della macchina
       INTVECTOR     m_vLinkedFixtures ;      // elenco dei bloccaggi agganciati a gruppi della macchina
@@ -313,6 +323,7 @@ class Machine
       int           m_nCalcExitId ;          // uscita corrente per calcoli
       int           m_nCalcToolId ;          // utensile corrente per calcoli
       double        m_dCalcRot1W ;           // peso del primo asse rotante per i confronti
+      double        m_dSingConeAng ;         // angolo di apertura del cono di direzioni considerate coincidenti con asse singolare 
       bool          m_bCalcMaxDeltaR2On1 ;   // flag utilizzo controllo massimo delta secondo asse rotante su inizio lavorazione
       int           m_nCalcSolCh ;           // criterio di scelta della soluzione
       bool          m_bSolChExact ;          // flag per scelta soluzione da soddisfare esattamente
@@ -365,9 +376,16 @@ class Machine
       static int LuaEmtAddRapidMove( lua_State* L) ;
       static int LuaEmtAddLinearMove( lua_State* L) ;
       static int LuaEmtAddArcMove( lua_State* L) ;
+      static int LuaEmtAddClimb( lua_State* L) ;
+      static int LuaEmtRemoveClimb( lua_State* L) ;
+      static int LuaEmtAddRise( lua_State* L) ;
+      static int LuaEmtRemoveRise( lua_State* L) ;
       static int LuaEmtGetMoveType( lua_State* L) ;
       static int LuaEmtGetAxesPos( lua_State* L) ;
       static int LuaEmtGetBackAuxDir( lua_State* L) ;
+      static int LuaEmtGetInitialAxesPos( lua_State* L) ;
+      static int LuaEmtGetFinalAxesPos( lua_State* L) ;
+      static int LuaEmtGetCurrAxesHomePos( lua_State* L) ;
       static int LuaEmtLinkRawPartToGroup( lua_State* L) ;
       static int LuaEmtGetAllLinkedRawParts( lua_State* L) ;
       static int LuaEmtUnlinkRawPartFromGroup( lua_State* L) ;
@@ -384,6 +402,8 @@ class Machine
       static int LuaEmtSetWarning( lua_State* L) ;
       static int LuaEmtAddCollisionObj( lua_State* L) ;
       static int LuaEmtAddCollisionObjEx( lua_State* L) ;
+      static int LuaEmtRemoveCollisionObj( lua_State* L) ;
+      static int LuaEmtGetCollisionObj( lua_State* L) ;
       static int LuaEmtExecCollisionCheck( lua_State* L) ;
       static int LuaEmtOnCollision( lua_State* L) ;
       static int LuaEmtSetToolForVmill( lua_State* L) ;
@@ -400,15 +420,15 @@ Machine::LuaSetGlobVar( const std::string& sVar, const T& Val)
 {
   // imposto contesto corretto
    int nOldCtx = ExeGetCurrentContext() ;
-   if ( nOldCtx != m_pMchMgr->GetContextId())
-      ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
+   if ( nOldCtx != m_nContextId)
+      ExeSetCurrentContext( m_nContextId) ;
   // imposto l'oggetto corrente per Lua
    Machine* pOldMchLua = m_pMchLua ;
    m_pMchLua = this ;
   // eseguo l'assegnamento
    bool bOk = ::LuaSetGlobVar( m_LuaMgr.GetLuaState(), sVar, Val) ;
   // ripristino contesto originale
-   if ( nOldCtx != m_pMchMgr->GetContextId())
+   if ( nOldCtx != m_nContextId)
       ExeSetCurrentContext( nOldCtx) ;
   // ripristino dell'oggetto corrente per Lua
    m_pMchLua = pOldMchLua ;
@@ -422,15 +442,15 @@ Machine::LuaGetGlobVar( const std::string& sVar, T& Val)
 {
   // imposto contesto corretto
    int nOldCtx = ExeGetCurrentContext() ;
-   if ( nOldCtx != m_pMchMgr->GetContextId())
-      ExeSetCurrentContext( m_pMchMgr->GetContextId()) ;
+   if ( nOldCtx != m_nContextId)
+      ExeSetCurrentContext( m_nContextId) ;
   // imposto l'oggetto corrente per Lua
    Machine* pOldMchLua = m_pMchLua ;
    m_pMchLua = this ;
   // eseguo la lettura
    bool bOk = ::LuaGetGlobVar( m_LuaMgr.GetLuaState(), sVar, Val) ;
   // ripristino contesto originale
-   if ( nOldCtx != m_pMchMgr->GetContextId())
+   if ( nOldCtx != m_nContextId)
       ExeSetCurrentContext( nOldCtx) ;
   // ripristino dell'oggetto corrente per Lua
    m_pMchLua = pOldMchLua ;

MachineAxes.cpp

@@ -266,6 +266,14 @@ Machine::GetAxisHomePos( const string& sAxis, double& dHomeVal) const
 bool
 Machine::IsDispositionAxis( int nAxisId, int nTableId) const
 {
+  // se non dichiarato o ausiliario
+   const Axis* pAx = GetAxis( nAxisId) ;
+   if ( pAx == nullptr  ||  pAx->GetUse() == MCH_AU_AUXILIAR)
+      return false ;
+  // se dichiarato di disposizione
+   if ( pAx->GetUse() == MCH_AU_DISPOSITION)
+      return true ;
+  // altrimenti è di tipo generale e va bene solo se dipende direttamente o indirettamente dalla tavola
   // se direttamente dipendente dalla tavola
    int nParentId = m_pGeomDB->GetParentId( nAxisId) ;
    if ( ( nTableId != GDB_ID_NULL  &&  nParentId == nTableId)  ||  IsTableGroup( nParentId))

MachineCalc.cpp

@@ -48,7 +48,6 @@ static const string EVAR_R1 = ".R1" ;                    // (num) valore del pri
 static const string EVAR_R2 = ".R2" ;                    // (num) valore del secondo asse rotante
 static const string EVAR_R3 = ".R3" ;                    // (num) valore del terzo asse rotante
 static const string EVAR_R4 = ".R4" ;                    // (num) valore del quarto asse rotante
-static const string EVAR_LINKTYPE = ".LINKTYPE" ;        // (int) tipo collegamento (0=No, 1=Inizio, 2=Fine, 3=Link))
 static const string EVAR_ERROR = ".ERR" ;                // OUT (int) codice di errore ( 0 = ok)
 static const string EVAR_STAT = ".STAT" ;                // OUT (int) codice di stato ( 0 = ok)
 static const string EVAR_AUXINFO = ".AUXINFO" ;          // OUT (string) stringa con info ausiliarie
@@ -76,7 +75,7 @@ Machine::SetCurrTable( const string& sTable)
    m_pGeomDB->SetStatus( m_nCalcTabId, GDB_ST_ON) ;
   // lancio eventuale funzione lua di personalizzazione
    if ( LuaExistsFunction( ON_SET_TABLE)) {
-     // salvo eventuale variabile EMC_VAR già presente
+     // salvo eventuale variabile EMC_VAR già presente
       bool bOldEMC = LuaChangeNameGlobVar( EMC_VAR, EMC_VAR_BACKUP) ;
      // definisco variabili
       bool bOk = LuaCreateGlobTable( EMC_VAR) ;
@@ -86,7 +85,7 @@ Machine::SetCurrTable( const string& sTable)
       bOk = bOk && LuaCallFunction( ON_SET_TABLE) ;
      // reset variabili
       bOk = bOk && LuaResetGlobVar( EMC_VAR) ;
-     // ripristino eventuale variabile EMC_VAR già presente
+     // ripristino eventuale variabile EMC_VAR già presente
       if ( bOldEMC)
          LuaChangeNameGlobVar( EMC_VAR_BACKUP, EMC_VAR) ;
      // restituisco risultato
@@ -283,7 +282,7 @@ Machine::SetCurrTool( const string& sTool, const string& sHead, int nExit)
    if ( ! sTool.empty()) {
      // carico anche gli utensili su eventuali altre uscite della testa
       LoadTools( sHead, nExit) ;
-     // carico l'utensile (si sostituisce ad altro già presente sulla stessa uscita)
+     // carico l'utensile (si sostituisce ad altro già presente sulla stessa uscita)
       if ( ! LoadTool( sHead, nExit, sTool)) {
          string sOut = "Missing tool " + sTool ;
          LOG_ERROR( GetEMkLogger(), sOut.c_str())
@@ -333,7 +332,7 @@ Machine::SetCurrTool( const string& sTool, const string& sHead, int nExit)
    m_dCalcTOvRad = dTOvDiam / 2 ;
   // lancio eventuale funzione lua di personalizzazione
    if ( LuaExistsFunction( ON_SET_HEAD)) {
-     // salvo eventuale variabile EMC_VAR già presente
+     // salvo eventuale variabile EMC_VAR già presente
       bool bOldEMC = LuaChangeNameGlobVar( EMC_VAR, EMC_VAR_BACKUP) ;
      // definisco variabili
       bool bOk = LuaCreateGlobTable( EMC_VAR) ;
@@ -351,7 +350,7 @@ Machine::SetCurrTool( const string& sTool, const string& sHead, int nExit)
       bOk = bOk && LuaCallFunction( ON_SET_HEAD) ;
      // reset variabili
       bOk = bOk && LuaResetGlobVar( EMC_VAR) ;
-     // ripristino eventuale variabile EMC_VAR già presente
+     // ripristino eventuale variabile EMC_VAR già presente
       if ( bOldEMC)
          LuaChangeNameGlobVar( EMC_VAR_BACKUP, EMC_VAR) ;
      // in caso di errore esco
@@ -372,7 +371,9 @@ Machine::ResetCurrTool( void)
    m_nCalcHeadId = GDB_ID_NULL ;
    m_nCalcExitId = GDB_ID_NULL ;
    m_nCalcToolId = GDB_ID_NULL ;
-   m_dCalcRot1W = 1 ;
+   m_dCalcRot1W = ROT1_WEIGHT_DFLT ;
+   m_dSingConeAng = SING_CONE_ANG_DFLT ;
+   m_bCalcMaxDeltaR2On1 = true ;
    m_nCalcSolCh = MCH_SCC_NONE ;
    m_dCalcTLen = 0 ;
    m_dCalcTRad = 0 ;
@@ -541,67 +542,120 @@ Machine::CalculateKinematicChain( void)
       nHParId = m_pGeomDB->GetParentId( nHParId) ;
    }
 
-  // se non ci sono assi, né lineari né rotanti, sicuramente errore
+  // se non ci sono assi, né lineari né rotanti, sicuramente errore
    if ( m_nTabLinAxes == 0  &&  m_nHeadLinAxes == 0  &&
         m_nTabRotAxes == 0  &&  m_nHeadRotAxes == 0) {
       LOG_ERROR( GetEMkLogger(), "Errors in Axes : none have been found")
       return false ;
    }
 
-  // se nessun asse lineare deve essere un robot (in futuro va permesso un lineare di tavola)
+  // se nessun asse lineare deve essere un robot (in futuro andrà permesso un lineare di testa o di tavola)
    if ( m_nTabLinAxes == 0  &&  m_nHeadLinAxes == 0) {
-     // verifico ci siano 6 assi rotanti tutti di testa (in futuro va permesso un rotante di tavola) 
-      if ( m_nTabRotAxes != 0  ||  m_nHeadRotAxes != 6) {
+     // se 6 assi rotanti tutti di testa
+      if ( m_nTabRotAxes == 0  &&  m_nHeadRotAxes == 6) {
+        // riordino gli assi rotanti
+         swap( m_vCalcRotAx[0], m_vCalcRotAx[5]) ;
+         swap( m_vCalcRotAx[1], m_vCalcRotAx[4]) ;
+         swap( m_vCalcRotAx[2], m_vCalcRotAx[3]) ;
+        // determino il riferimento canonico del robot
+         if ( ! m_frRobot.Set( m_vCalcRotAx[0].ptPos, m_vCalcRotAx[0].vtDir, m_vCalcRotAx[3].vtDir)) {
+            LOG_ERROR( GetEMkLogger(), "Robot with errors in Rotary Axes : impossible canonic frame")
+            return false ;
+         }
+        // porto tutti gli assi cinematici e i dati testa nel riferimento canonico
+         for ( int i = 0 ; i < m_nHeadRotAxes ; ++ i) {
+            m_vCalcRotAx[i].ptPos.ToLoc( m_frRobot) ;
+            m_vCalcRotAx[i].vtDir.ToLoc( m_frRobot) ;
+         }
+         m_ptCalcPos.ToLoc( m_frRobot) ;
+         m_vtCalcDir.ToLoc( m_frRobot) ;
+         m_vtCalcADir.ToLoc( m_frRobot) ;
+        // direzione assi rotanti deve essere Z Y Y X Y X
+         if ( ! m_vCalcRotAx[0].vtDir.IsZ()  ||
+              ! m_vCalcRotAx[1].vtDir.IsY()  ||
+              ! m_vCalcRotAx[2].vtDir.IsY()  ||
+              ! m_vCalcRotAx[3].vtDir.IsX()  ||
+              ! m_vCalcRotAx[4].vtDir.IsY()  ||
+              ! m_vCalcRotAx[5].vtDir.IsX()) {
+            LOG_ERROR( GetEMkLogger(), "Robot with errors in Rotary Axes : not ZYY-XYX")
+            return false ;
+         }
+        // verifico che gli ultimi 3 assi formino un polso sferico (ovvero passino per uno stesso punto)
+         if ( abs( m_vCalcRotAx[3].ptPos.y - m_vCalcRotAx[5].ptPos.y) > EPS_SMALL  ||
+              abs( m_vCalcRotAx[3].ptPos.z - m_vCalcRotAx[5].ptPos.z) > EPS_SMALL  ||
+              abs( m_vCalcRotAx[4].ptPos.z - m_vCalcRotAx[3].ptPos.z) > EPS_SMALL) {
+            LOG_ERROR( GetEMkLogger(), "Robot with errors in Rotary Axes : not spherical Wrist")
+            return false ;
+         }
+        // calcolo il centro del polso in coordinate globali (R5.x, R6.y, R5.z)
+         Point3d ptCenG( m_vCalcRotAx[4].ptPos.x, m_vCalcRotAx[5].ptPos.y, m_vCalcRotAx[4].ptPos.z) ;
+        // recupero il riferimento dell'uscita (da posizione, direzione utensile e direzione ausiliaria)
+         Frame3d frExit ;
+         if ( ! frExit.Set( m_ptCalcPos, m_vtCalcDir, m_vtCalcADir))
+            return false ;
+        // calcolo il centro del polso in locale a questo riferimento
+         m_ptWristCen = GetToLoc( ptCenG, frExit) ;
+        // calcolo la direzione di riferimento del polso in locale a questo riferimento
+         m_vtWristRef = GetToLoc( m_vCalcRotAx[5].vtDir, frExit) ;
+        // dichiaro tipo robot
+         m_nCalcChainType = KIN_CHAIN_ROBOT ;
+         return true ;
+      }
+     // se altrimenti 6 assi rotanti tutti di tavola
+      else if ( m_nTabRotAxes == 6  &&  m_nHeadRotAxes == 0) {
+        // riordino gli assi rotanti
+         swap( m_vCalcRotAx[0], m_vCalcRotAx[5]) ;
+         swap( m_vCalcRotAx[1], m_vCalcRotAx[4]) ;
+         swap( m_vCalcRotAx[2], m_vCalcRotAx[3]) ;
+        // determino il riferimento canonico del robot
+         if ( ! m_frRobot.Set( m_vCalcRotAx[0].ptPos, m_vCalcRotAx[0].vtDir, m_vCalcRotAx[3].vtDir)) {
+            LOG_ERROR( GetEMkLogger(), "Robot with errors in Rotary Axes : impossible canonic frame")
+            return false ;
+         }
+        // porto tutti gli assi cinematici e i dati testa nel riferimento canonico
+         for ( int i = 0 ; i < m_nTabRotAxes ; ++ i) {
+            m_vCalcRotAx[i].ptPos.ToLoc( m_frRobot) ;
+            m_vCalcRotAx[i].vtDir.ToLoc( m_frRobot) ;
+         }
+         m_ptCalcPos.ToLoc( m_frRobot) ;
+         m_vtCalcDir.ToLoc( m_frRobot) ;
+         m_vtCalcADir.ToLoc( m_frRobot) ;
+        // direzione assi rotanti deve essere Z Y Y X Y X
+         if ( ! m_vCalcRotAx[0].vtDir.IsZ()  ||
+              ! m_vCalcRotAx[1].vtDir.IsY()  ||
+              ! m_vCalcRotAx[2].vtDir.IsY()  ||
+              ! m_vCalcRotAx[3].vtDir.IsX()  ||
+              ! m_vCalcRotAx[4].vtDir.IsY()  ||
+              ! m_vCalcRotAx[5].vtDir.IsX()) {
+            LOG_ERROR( GetEMkLogger(), "Robot with errors in Rotary Axes : not ZYY-XYX")
+            return false ;
+         }
+        // verifico che gli ultimi 3 assi formino un polso sferico (ovvero passino per uno stesso punto)
+         if ( abs( m_vCalcRotAx[3].ptPos.y - m_vCalcRotAx[5].ptPos.y) > EPS_SMALL  ||
+              abs( m_vCalcRotAx[3].ptPos.z - m_vCalcRotAx[5].ptPos.z) > EPS_SMALL  ||
+              abs( m_vCalcRotAx[4].ptPos.z - m_vCalcRotAx[3].ptPos.z) > EPS_SMALL) {
+            LOG_ERROR( GetEMkLogger(), "Robot with errors in Rotary Axes : not spherical Wrist")
+            return false ;
+         }
+        // calcolo il centro del polso in coordinate globali (R5.x, R6.y, R5.z)
+         Point3d ptCenG( m_vCalcRotAx[4].ptPos.x, m_vCalcRotAx[5].ptPos.y, m_vCalcRotAx[4].ptPos.z) ;
+        // recupero il riferimento dell'uscita (da posizione, direzione utensile e direzione ausiliaria)
+         Frame3d frExit ;
+         if ( ! frExit.Set( m_ptCalcPos, m_vtCalcDir, m_vtCalcADir))
+            return false ;
+        // calcolo il centro del polso in locale a questo riferimento
+         m_ptWristCen = GetToLoc( ptCenG, frExit) ;
+        // calcolo la direzione di riferimento del polso in locale a questo riferimento
+         m_vtWristRef = GetToLoc( m_vCalcRotAx[5].vtDir, frExit) ;
+        // dichiaro tipo robot
+         m_nCalcChainType = KIN_CHAIN_ROBOT ;
+         return true ;
+      }
+     // altrimenti errore
+      else {
          LOG_ERROR( GetEMkLogger(), "Robot with errors in Rotary Axes : number or type")
          return false ;
       }
-     // riordino gli assi rotanti
-      swap( m_vCalcRotAx[0], m_vCalcRotAx[5]) ;
-      swap( m_vCalcRotAx[1], m_vCalcRotAx[4]) ;
-      swap( m_vCalcRotAx[2], m_vCalcRotAx[3]) ;
-     // determino il riferimento canonico del robot
-      if ( ! m_frRobot.Set( m_vCalcRotAx[0].ptPos, m_vCalcRotAx[0].vtDir, m_vCalcRotAx[3].vtDir)) {
-         LOG_ERROR( GetEMkLogger(), "Robot with errors in Rotary Axes : impossible canonic frame")
-         return false ;
-      }
-     // porto tutti gli assi cinematici e i dati testa nel riferimento canonico
-      for ( int i = 0 ; i < m_nHeadRotAxes ; ++ i) {
-         m_vCalcRotAx[i].ptPos.ToLoc( m_frRobot) ;
-         m_vCalcRotAx[i].vtDir.ToLoc( m_frRobot) ;
-      }
-      m_ptCalcPos.ToLoc( m_frRobot) ;
-      m_vtCalcDir.ToLoc( m_frRobot) ;
-      m_vtCalcADir.ToLoc( m_frRobot) ;
-     // direzione assi rotanti deve essere Z Y Y X Y X
-      if ( ! m_vCalcRotAx[0].vtDir.IsZ()  ||
-           ! m_vCalcRotAx[1].vtDir.IsY()  ||
-           ! m_vCalcRotAx[2].vtDir.IsY()  ||
-           ! m_vCalcRotAx[3].vtDir.IsX()  ||
-           ! m_vCalcRotAx[4].vtDir.IsY()  ||
-           ! m_vCalcRotAx[5].vtDir.IsX()) {
-         LOG_ERROR( GetEMkLogger(), "Robot with errors in Rotary Axes : not ZYY-XYX")
-         return false ;
-      }
-     // verifico che gli ultimi 3 assi formino un polso sferico (ovvero passino per uno stesso punto)
-      if ( abs( m_vCalcRotAx[3].ptPos.y - m_vCalcRotAx[5].ptPos.y) > EPS_SMALL  ||
-           abs( m_vCalcRotAx[3].ptPos.z - m_vCalcRotAx[5].ptPos.z) > EPS_SMALL  ||
-           abs( m_vCalcRotAx[4].ptPos.z - m_vCalcRotAx[3].ptPos.z) > EPS_SMALL) {
-         LOG_ERROR( GetEMkLogger(), "Robot with errors in Rotary Axes : not spherical Wrist")
-         return false ;
-      }
-     // calcolo il centro del polso in coordinate globali (R5.x, R6.y, R5.z)
-      Point3d ptCenG( m_vCalcRotAx[4].ptPos.x, m_vCalcRotAx[5].ptPos.y, m_vCalcRotAx[4].ptPos.z) ;
-     // recupero il riferimento dell'uscita (da posizione, direzione utensile e direzione ausiliaria)
-      Frame3d frExit ;
-      if ( ! frExit.Set( m_ptCalcPos, m_vtCalcDir, m_vtCalcADir))
-         return false ;
-     // calcolo il centro del polso in locale a questo riferimento
-      m_ptWristCen = GetToLoc( ptCenG, frExit) ;
-     // calcolo la direzione di riferimento del polso in locale a questo riferimento
-      m_vtWristRef = GetToLoc( m_vCalcRotAx[5].vtDir, frExit) ;
-     // dichiaro tipo robot
-      m_nCalcChainType = KIN_CHAIN_ROBOT ;
-      return true ;
    }
 
   // verifiche sugli assi lineari :
@@ -666,7 +720,7 @@ Machine::CalculateKinematicChain( void)
          }
       }
    }
-   // se 3 va bene ( uno dovrà poi avere valore assegnato)
+   // se 3 va bene ( uno dovrà poi avere valore assegnato)
    else if ( m_vCalcRotAx.size() == 3) {
       int n2ndHeadRotAx = - 1 ;
      // se tutti e tre di testa, devo invertire il primo con il terzo
@@ -688,7 +742,7 @@ Machine::CalculateKinematicChain( void)
          }
       }
    }
-   // se più di 3
+   // se più di 3
    else {
      // altrimenti non ancora gestito, quindi errore
       LOG_ERROR( GetEMkLogger(), "Rotary Axes not manageable")
@@ -705,7 +759,7 @@ Machine::CalculateKinematicChain( void)
            // non sono ammessi due assi di questo tipo 
             if ( m_nHeadSpecRotAxis != -1)
                return false ;
-           // la tavola non deve avere più di un asse lineare
+           // la tavola non deve avere più di un asse lineare
             if ( m_nTabLinAxes > 1)
                return false ;
            // se ha un asse lineare deve essere allineato con il rotante speciale 
@@ -730,7 +784,7 @@ Machine::CalculateKinematicChain( void)
       }
    }
   // dichiaro tipo centro di lavoro
-   m_nCalcChainType = KIN_CHAIN_CENTER ;
+   m_nCalcChainType = KIN_CHAIN_MCENT ;
    return true ;
 }
 
@@ -754,7 +808,7 @@ Machine::AddKinematicAxis( bool bOnHead, int nId)
    kAx.vtDir = pAx->GetDir() ;
    kAx.stroke = pAx->GetStroke() ;
    kAx.dHomeVal = pAx->GetHomeVal() ;
-  // ne determino l'indice di posizione nella sua catena cinematica (assegno valore negato perchè provvisorio)
+  // ne determino l'indice di posizione nella sua catena cinematica (assegno valore negato perchè provvisorio)
    if ( kAx.bHead) {
       ( kAx.bLinear ? ++ m_nHeadLinAxes : ++ m_nHeadRotAxes) ;
       kAx.nInd = - ( m_nHeadLinAxes + m_nHeadRotAxes) ;
@@ -977,7 +1031,7 @@ Machine::GetAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
            // aggiorno direzioni utensile e ausiliaria richieste
             vtDirTm.Rotate( m_vCalcRotAx[i].vtDir, m_vCalcRotAx[i].dFixVal) ;
             vtDirAm.Rotate( m_vCalcRotAx[i].vtDir, m_vCalcRotAx[i].dFixVal) ;
-           // aggiorno eventuali assi già inseriti (sicuramente di tavola)
+           // aggiorno eventuali assi già inseriti (sicuramente di tavola)
             for ( size_t j = 0 ; int( j) < nNumRotAx ; ++ j) {
                RotAx[j].ptPos.Rotate( m_vCalcRotAx[i].ptPos, m_vCalcRotAx[i].vtDir, m_vCalcRotAx[i].dFixVal) ;
                RotAx[j].vtDir.Rotate( m_vCalcRotAx[i].vtDir, m_vCalcRotAx[i].dFixVal) ;
@@ -1066,7 +1120,7 @@ Machine::GetMyAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
   // componente versore fresa desiderato su direzione primo asse rotante
    double dCompTSuAxR1 = vtDirTn * vtAx1 ; 
 
-  // se c'è secondo asse rotante, si calcola angolo per avere il componente appena calcolato
+  // se c'è secondo asse rotante, si calcola angolo per avere il componente appena calcolato
    bool bDet = true ;
    Vector3d vtDirH1, vtDirH2 ;
    Vector3d vtDirI1, vtDirI2 ;
@@ -1172,8 +1226,30 @@ Machine::GetMyAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
       vtDirI1.Rotate( vtAx1, dAngA1) ;
    }
 
+  // verifica per direzione singolare (direzione fresa molto vicina a direzione primo asse rotante)
+   if ( nNumRotAx == 2  &&  nStat == 2  &&  abs( dAngB2 - dAngB1) < 2 * m_dSingConeAng) {
+      nStat = 1 ;
+      bDet1 = false ;
+      dAngB1 = ( dAngB1 + dAngB2) / 2 ;
+     // ripristino direzioni fresa e ausiliaria su testa
+      vtDirH1.Rotate( vtAx1, -dAngA1) ;
+      vtDirI1.Rotate( vtAx1, -dAngA1) ;
+     // provo a determinare primo angolo con la direzione ausiliaria
+      bool bDetX ;
+      Vector3d vtSccDir ;
+      bool bSccDir = GetSccDir( m_nCalcSolCh, vtDirAn, vtSccDir) ;
+      vtDirI1.GetRotation( vtSccDir, vtAx1, dAngA1, bDetX) ;
+      if ( bDetX)
+         bDet1 = bSccDir ;
+      else
+         dAngA1 = 0 ;
+     // aggiornamento direzioni fresa e ausiliaria su testa
+      vtDirH1.Rotate( vtAx1, dAngA1) ;
+      vtDirI1.Rotate( vtAx1, dAngA1) ;
+   }
+
   // verifiche per criterio scelta soluzione
-   if ( nStat >= 2) {
+   if ( nStat == 2) {
       if ( ! VerifyScc( vtDirI2, vtDirAn, m_nCalcSolCh, m_bSolChExact))
          -- nStat ;
    }
@@ -1189,7 +1265,7 @@ Machine::GetMyAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
    }
 
   // verifiche dei limiti di corsa
-   if ( nStat >= 2) {
+   if ( nStat == 2) {
      // se non riesco ad aggiustare, elimino
       if ( ! AdjustAngleInStroke( RotAx1.stroke, dAngA2)  ||
            ( nNumRotAx == 2  &&  ! AdjustAngleInStroke( RotAx2.stroke, dAngB2)))
@@ -1209,7 +1285,7 @@ Machine::GetMyAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
    }
 
   // modifico stato per angolo indeterminato
-   if ( ( nStat >= 2  &&  ! bDet2)  ||   ( nStat >= 1  &&  ! bDet1))
+   if ( ( nStat == 2  &&  ! bDet2)  ||   ( nStat >= 1  &&  ! bDet1))
       nStat = - nStat ;
 
    return true ;
@@ -1218,10 +1294,10 @@ Machine::GetMyAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
 //----------------------------------------------------------------------------
 bool
 Machine::GetPositions( const Point3d& ptP, const DBLVECTOR& vAng,
-                       int& nStat, double& dX, double& dY, double& dZ) const
+                       double& dX, double& dY, double& dZ) const
 {
   // la posizione deve essere espressa rispetto allo ZERO MACCHINA
-  // il punto è dato rispetto alla posizione home della tavola
+  // il punto è dato rispetto alla posizione home della tavola
 
   // verifico che siano stati assegnati gli angoli necessari, altrimenti errore
    if ( vAng.size() < m_vCalcRotAx.size())
@@ -1263,7 +1339,7 @@ Machine::GetPositions( const Point3d& ptP, const DBLVECTOR& vAng,
   // assegno l'offset testa
    Vector3d vtDtHe = ORIG - m_ptCalcPos ;
 
-  // calcolo il recupero degli assi : è l'opposto dello spostamento della posizione
+  // calcolo il recupero degli assi : è l'opposto dello spostamento della posizione
    Vector3d vtDtAx = m_ptCalcPos - ptPosH ;
    
   // calcolo il recupero di lunghezza utensile
@@ -1279,7 +1355,6 @@ Machine::GetPositions( const Point3d& ptP, const DBLVECTOR& vAng,
    dZ = ptPos.z ;
 
   // tutto ok
-   nStat = 0 ;
    return true ;
 }
 
@@ -1287,7 +1362,7 @@ Machine::GetPositions( const Point3d& ptP, const DBLVECTOR& vAng,
 bool
 Machine::GetDirection( const Vector3d& vtDir, const DBLVECTOR& vAng, Vector3d& vtNew) const
 {
-  // è espressa nel riferimento di macchina (tiene conto delle sole rotazioni di testa)
+  // è espressa nel riferimento di macchina (tiene conto delle sole rotazioni di testa)
 
   // verifico dimensione vettore angoli rispetto al numero di assi rotanti
    if ( vAng.size() < m_vCalcRotAx.size())
@@ -1314,7 +1389,7 @@ Machine::GetDirection( const Vector3d& vtDir, const DBLVECTOR& vAng, Vector3d& v
 bool
 Machine::GetBackDirection( const Vector3d& vtDir, const DBLVECTOR& vAng, Vector3d& vtNew) const
 {
-  // è espressa nel riferimento del pezzo (tiene conto delle rotazioni di testa e al contrario di quelle di tavola)
+  // è espressa nel riferimento del pezzo (tiene conto delle rotazioni di testa e al contrario di quelle di tavola)
 
   // verifico dimensione vettore angoli rispetto al numero di assi rotanti
    if ( vAng.size() < m_vCalcRotAx.size())
@@ -1342,14 +1417,14 @@ Machine::GetNoseFromPositions( double dX, double dY, double dZ, const DBLVECTOR&
                                Point3d& ptNose) const
 {
   // la posizione deve essere espressa rispetto allo ZERO MACCHINA
-  // è espressa nel riferimento di macchina (tiene conto delle sole traslazioni e rotazioni di testa)
+  // è espressa nel riferimento di macchina (tiene conto delle sole traslazioni e rotazioni di testa)
 
   // verifico dimensione vettore angoli rispetto al numero di assi rotanti
    if ( vAng.size() < m_vCalcRotAx.size())
       return false ;
 
   // se centro di lavoro
-   if ( m_nCalcChainType == KIN_CHAIN_CENTER) {
+   if ( m_nCalcChainType == KIN_CHAIN_MCENT) {
      // aggiorno posizione testa a riposo mediante ciclo inverso sugli assi rotanti di testa
       ptNose = m_ptCalcPos ;
       for ( int i = int( m_vCalcRotAx.size()) - 1 ; i >= 0 ; -- i) {
@@ -1394,15 +1469,15 @@ Machine::GetTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR&
                               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
+  // è 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())
       return false ;
 
   // se centro di lavoro
-   if ( m_nCalcChainType == KIN_CHAIN_CENTER) {
+   if ( m_nCalcChainType == KIN_CHAIN_MCENT) {
      // aggiorno posizione tip utensile a riposo mediante ciclo inverso sugli assi rotanti di testa
       ptTip = m_ptCalcPos - m_vtCalcDir * m_dCalcTLen ;
       for ( int i = int( m_vCalcRotAx.size()) - 1 ; i >= 0 ; -- i) {
@@ -1472,9 +1547,9 @@ Machine::GetTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR&
      // se richiesto ingombro totale
       if ( bOverall)
          ptTip -= vtDirT * max( m_dCalcTOvLen - m_dCalcTLen, 0.) ;
-     // se richiesto punto più basso e direzione fresa non esattamente verticale
+     // se richiesto punto più basso e direzione fresa non esattamente verticale
       if ( bBottom  &&  ! vtDirT.IsZplus()  &&  ! vtDirT.IsZminus()) {
-        // calcolo la direzione perpendicolare più verticale possibile
+        // calcolo la direzione perpendicolare più verticale possibile
          Vector3d vtCorr = FromUprightOrtho( vtDirT) ;
         // correggo il tip
          if ( bOverall)
@@ -1505,7 +1580,7 @@ Machine::GetAuxDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) const
 bool
 Machine::GetPartDirFromAngles( const Vector3d& vtPart, const DBLVECTOR& vAng, Vector3d& vtDir) const
 {
-  // è espressa nel riferimento di macchina (tiene conto delle sole rotazioni di tavola e asse rotante speciale di testa)
+  // è espressa nel riferimento di macchina (tiene conto delle sole rotazioni di tavola e asse rotante speciale di testa)
 
   // verifico dimensione vettore angoli rispetto al numero di assi rotanti
    if ( vAng.size() < m_vCalcRotAx.size())
@@ -1625,8 +1700,19 @@ Machine::AdjustAngleInStroke( const STROKE& Stroke, double& dAng) const
          dAng += ANG_FULL ;
       while ( dAng > Stroke.Max)
          dAng -= ANG_FULL ;
-     // verifico
-      return ( dAng >= Stroke.Min   &&  dAng <= Stroke.Max) ;
+     // se nei limiti, tutto bene
+      if ( dAng >= Stroke.Min  &&  dAng <= Stroke.Max)
+         return true ;
+     // altrimenti, determino il valore con il minimo outstroke
+      if ( dAng < Stroke.Min) {
+         if ( abs( dAng - Stroke.Min) > abs( dAng + ANG_FULL - Stroke.Max))
+            dAng += ANG_FULL ;  
+      }
+      else {
+         if ( abs( dAng - Stroke.Max) > abs( dAng - ANG_FULL - Stroke.Min))
+            dAng -= ANG_FULL ;
+      }
+      return false ;
    }
   // altrimenti asse rotante senza corsa
    else {
@@ -1651,10 +1737,10 @@ Machine::AdjustAngleInStroke( const STROKE& Stroke, double& dAng) const
 bool
 Machine::GetNearestAngleInStroke( int nInd, double dAngRef, double& dAng) const
 {
-  // se angolo fittizio (non esiste l'asse rotante corrispondente), non c'è alcunchè da fare
+  // se angolo fittizio (non esiste l'asse rotante corrispondente), non c'è alcunchè da fare
    if ( nInd < 0  ||  nInd >= int( m_vCalcRotAx.size()))
       return true ;
-  // cerco l'angolo più vicino stando nella corsa
+  // cerco l'angolo più vicino stando nella corsa
    while ( dAng - dAngRef > ANG_STRAIGHT + EPS_ANG_ZERO  &&  dAng - ANG_FULL >= m_vCalcRotAx[nInd].stroke.Min)
       dAng -= ANG_FULL ;
    while ( dAng - dAngRef < -ANG_STRAIGHT + EPS_ANG_ZERO  &&  dAng + ANG_FULL <= m_vCalcRotAx[nInd].stroke.Max)
@@ -1667,10 +1753,10 @@ Machine::GetNearestAngleInStroke( int nInd, double dAngRef, double& dAng) const
 bool
 Machine::LimitAngleToStroke( int nInd, double& dAng) const
 {
-  // se angolo fittizio (non esiste l'asse rotante corrispondente), non c'è alcunchè da fare
+  // se angolo fittizio (non esiste l'asse rotante corrispondente), non c'è alcunchè da fare
    if ( nInd < 0  ||  nInd >= int( m_vCalcRotAx.size()))
       return true ;
-  // se angolo fuori corsa, lo porto all'estremo più vicino
+  // se angolo fuori corsa, lo porto all'estremo più vicino
    dAng = Clamp( dAng, m_vCalcRotAx[nInd].stroke.Min, m_vCalcRotAx[nInd].stroke.Max) ;
    return true ;
 }
@@ -1703,44 +1789,52 @@ Machine::VerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng
    DBLVECTOR vLin( 3) ; vLin[0] = dX ; vLin[1] = dY ; vLin[2] = dZ ;
    for ( size_t i = 0 ; i < m_vCalcLinAx.size()  &&  i < vLin.size() ; ++ i) {
       if ( vLin[i] < m_vCalcLinAx[i].stroke.Min) {
+         if ( nStat == 0) {
+            m_OutstrokeInfo.sAxName = GetAxis( m_vCalcLinAx[i].nGrpId)->GetName() ;
+            m_OutstrokeInfo.sAxToken = GetAxis( m_vCalcLinAx[i].nGrpId)->GetToken() ;
+            m_OutstrokeInfo.bLinear = true ;
+            m_OutstrokeInfo.dExtra = vLin[i] - m_vCalcLinAx[i].stroke.Min ;
+            m_OutstrokeInfo.sAuxInfo = " (L" + ToString( int(i) + 1) + "-) " ;
+         }
          nStat += ( 1 << ( 2 * i)) ;
-         m_OutstrokeInfo.sAxName = GetAxis( m_vCalcLinAx[i].nGrpId)->GetName() ;
-         m_OutstrokeInfo.sAxToken = GetAxis( m_vCalcLinAx[i].nGrpId)->GetToken() ;
-         m_OutstrokeInfo.bLinear = true ;
-         m_OutstrokeInfo.dExtra = vLin[i] - m_vCalcLinAx[i].stroke.Min ;
-         m_OutstrokeInfo.sAuxInfo = " (L" + ToString( int(i) + 1) + "-) " ;
       }
-      else if( vLin[i] > m_vCalcLinAx[i].stroke.Max) {
+      else if ( vLin[i] > m_vCalcLinAx[i].stroke.Max) {
+         if ( nStat == 0) {
+            m_OutstrokeInfo.sAxName = GetAxis( m_vCalcLinAx[i].nGrpId)->GetName() ;
+            m_OutstrokeInfo.sAxToken = GetAxis( m_vCalcLinAx[i].nGrpId)->GetToken() ;
+            m_OutstrokeInfo.bLinear = true ;
+            m_OutstrokeInfo.dExtra = vLin[i] - m_vCalcLinAx[i].stroke.Max ;
+            m_OutstrokeInfo.sAuxInfo = " (L" + ToString( int(i) + 1) + "+) " ;
+         }
          nStat += ( 2 << ( 2 * i)) ;
-         m_OutstrokeInfo.sAxName = GetAxis( m_vCalcLinAx[i].nGrpId)->GetName() ;
-         m_OutstrokeInfo.sAxToken = GetAxis( m_vCalcLinAx[i].nGrpId)->GetToken() ;
-         m_OutstrokeInfo.bLinear = true ;
-         m_OutstrokeInfo.dExtra = vLin[i] - m_vCalcLinAx[i].stroke.Max ;
-         m_OutstrokeInfo.sAuxInfo = " (L" + ToString( int(i) + 1) + "+) " ;
       }
    }
   // verifica degli assi rotanti
    for ( size_t i = 0 ; i < m_vCalcRotAx.size()  &&  i < vAng.size() ; ++ i) {
       if ( vAng[i] < m_vCalcRotAx[i].stroke.Min) {
+         if ( nStat == 0) {
+            m_OutstrokeInfo.sAxName = GetAxis( m_vCalcRotAx[i].nGrpId)->GetName() ;
+            m_OutstrokeInfo.sAxToken = GetAxis( m_vCalcRotAx[i].nGrpId)->GetToken() ;
+            m_OutstrokeInfo.bLinear = false ;
+            m_OutstrokeInfo.dExtra = vAng[i] - m_vCalcRotAx[i].stroke.Min ;
+            m_OutstrokeInfo.sAuxInfo = " (R" + ToString( int(i) + 1) + "-) " ;
+         }
          nStat += ( 64 << ( 2 * i)) ;
-         m_OutstrokeInfo.sAxName = GetAxis( m_vCalcRotAx[i].nGrpId)->GetName() ;
-         m_OutstrokeInfo.sAxToken = GetAxis( m_vCalcRotAx[i].nGrpId)->GetToken() ;
-         m_OutstrokeInfo.bLinear = false ;
-         m_OutstrokeInfo.dExtra = vAng[i] - m_vCalcRotAx[i].stroke.Min ;
-         m_OutstrokeInfo.sAuxInfo = " (R" + ToString( int(i) + 1) + "-) " ;
       }
-      else if( vAng[i] > m_vCalcRotAx[i].stroke.Max) {
+      else if ( vAng[i] > m_vCalcRotAx[i].stroke.Max) {
+         if ( nStat == 0) {
+            m_OutstrokeInfo.sAxName = GetAxis( m_vCalcRotAx[i].nGrpId)->GetName() ;
+            m_OutstrokeInfo.sAxToken = GetAxis( m_vCalcRotAx[i].nGrpId)->GetToken() ;
+            m_OutstrokeInfo.bLinear = false ;
+            m_OutstrokeInfo.dExtra = vAng[i] - m_vCalcRotAx[i].stroke.Max ;
+            m_OutstrokeInfo.sAuxInfo = " (R" + ToString( int(i) + 1) + "+) " ;
+         }
          nStat += ( 128 << ( 2 * i)) ;
-         m_OutstrokeInfo.sAxName = GetAxis( m_vCalcRotAx[i].nGrpId)->GetName() ;
-         m_OutstrokeInfo.sAxToken = GetAxis( m_vCalcRotAx[i].nGrpId)->GetToken() ;
-         m_OutstrokeInfo.bLinear = false ;
-         m_OutstrokeInfo.dExtra = vAng[i] - m_vCalcRotAx[i].stroke.Max ;
-         m_OutstrokeInfo.sAuxInfo = " (R" + ToString( int(i) + 1) + "+) " ;
       }
    }
   // verifica delle aree protette
    if ( nStat == 0)
-      return const_cast<Machine*>( this)->VerifyProtectedAreas( dX, dY, dZ, vAng, 0, nStat) ;
+      return const_cast<Machine*>( this)->VerifyProtectedAreas( dX, dY, dZ, vAng, nStat) ;
 
    return true ;
 }
@@ -1754,20 +1848,17 @@ Machine::VerifyOutstroke( double dX, double dY, double dZ, const DBLVECTOR& vAng
 
 //----------------------------------------------------------------------------
 bool
-Machine::VerifyProtectedAreas( double dX, double dY, double dZ, const DBLVECTOR& vAng, int nLinkType, int& nStat)
+Machine::VerifyProtectedAreas( double dX, double dY, double dZ, const DBLVECTOR& vAng, int& nStat)
 {
-  // se non esiste funzione gestione aree protette, non devo fare alcunchè
+  // se non esiste funzione gestione aree protette, non devo fare alcunchè
    if ( ! LuaExistsFunction( ON_VERIFY_PROTECTEDAREAS))
       return true ;
-  // se non è collegamento e aree protette solo per questi, non devo fare alcunchè
-   if ( nLinkType == 0  &&  m_nNewLinkMgr == 1)
-      return true ;
   // default
    bool bOk = true ;
    int nErr = 99 ;
-  // salvo eventuale variabile EMC_VAR già presente
+  // salvo eventuale variabile EMC_VAR già presente
    bool bOldEMC = LuaChangeNameGlobVar( EMC_VAR, EMC_VAR_BACKUP) ;
-  // definisco variabili (nelle disposizioni l'utensile non è definito e non ha nome)
+  // definisco variabili (nelle disposizioni l'utensile non è definito e non ha nome)
    string sTool, sHead ; int nExit ;
    bOk = bOk && LuaCreateGlobTable( EMC_VAR) ;
    bOk = bOk && LuaSetGlobVar( EMC_VAR + EVAR_VER, GetEMkVer()) ;
@@ -1785,7 +1876,6 @@ Machine::VerifyProtectedAreas( double dX, double dY, double dZ, const DBLVECTOR&
       bOk = bOk && LuaSetGlobVar( EMC_VAR + EVAR_R3, vAng[2]) ;
    if ( vAng.size() >= 4)
       bOk = bOk && LuaSetGlobVar( EMC_VAR + EVAR_R4, vAng[3]) ;
-   bOk = bOk && LuaSetGlobVar( EMC_VAR + EVAR_LINKTYPE, nLinkType) ;
   // chiamo funzione
    bOk = bOk && LuaCallFunction( ON_VERIFY_PROTECTEDAREAS) ;
   // recupero il risultato
@@ -1807,7 +1897,7 @@ Machine::VerifyProtectedAreas( double dX, double dY, double dZ, const DBLVECTOR&
    }
   // reset variabili
    bOk = LuaResetGlobVar( EMC_VAR) && bOk ;
-  // ripristino eventuale variabile EMC_VAR già presente
+  // ripristino eventuale variabile EMC_VAR già presente
    if ( bOldEMC)
       LuaChangeNameGlobVar( EMC_VAR_BACKUP, EMC_VAR) ;
   // esco
@@ -1854,16 +1944,16 @@ Machine::VerifyOutstroke( const string& sAxName, double dVal) const
 string
 Machine::GetOutstrokeInfo( bool bMM) const
 {
-  // se non c'è extracorsa, ritorno stringa vuota
+  // se non c'è extracorsa, ritorno stringa vuota
    if ( m_OutstrokeInfo.sAxName.empty())
       return "" ;
   // creo stringa con info opportune
    if ( m_OutstrokeInfo.sAxName == AXIS_NAME_PROTECTEDAREAS)
       return m_OutstrokeInfo.sAuxInfo ;
    else if ( bMM  ||  ! m_OutstrokeInfo.bLinear)
-      return m_OutstrokeInfo.sAxToken + "=" + ToString( m_OutstrokeInfo.dExtra, 1) + m_OutstrokeInfo.sAuxInfo ;
+      return m_OutstrokeInfo.sAxToken + "=" + ToString( m_OutstrokeInfo.dExtra, 2) + m_OutstrokeInfo.sAuxInfo ;
    else
-      return m_OutstrokeInfo.sAxToken + "=" + ToString( m_OutstrokeInfo.dExtra / ONEINCH, 2) + m_OutstrokeInfo.sAuxInfo ;
+      return m_OutstrokeInfo.sAxToken + "=" + ToString( m_OutstrokeInfo.dExtra / ONEINCH, 3) + m_OutstrokeInfo.sAuxInfo ;
 }
 
 //----------------------------------------------------------------------------
@@ -2150,7 +2240,10 @@ Machine::GetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vecto
    Vector3d vtDirAL = GetToLoc( vtDirA, m_frRobot) ;
   // riferimento utensile
    Frame3d frTool ;
-   frTool.Set( ORIG, vtDirTL, vtDirAL) ;
+   if ( ! frTool.Set( ORIG, vtDirTL, vtDirAL)) {
+      LOG_ERROR( GetEMkLogger(), "Error : tool reference not defined (robot)")
+      return false ;
+   }
   // deduco la posizione richiesta del centro del polso
    Point3d ptCen = ptPL + m_ptWristCen.x * frTool.VersX() +
                           m_ptWristCen.y * frTool.VersY() +
@@ -2182,7 +2275,14 @@ Machine::GetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vecto
    double dCosB = ( dDistR2R3 * dDistR2R3 + dDistR2Cen * dDistR2Cen - dDistR3R5 * dDistR3R5) / ( 2 * dDistR2R3 * dDistR2Cen) ;
    double dCosC = ( dDistR3R5 * dDistR3R5 + dDistR2Cen * dDistR2Cen - dDistR2R3 * dDistR2R3) / ( 2 * dDistR3R5 * dDistR2Cen) ;
    if ( abs( dCosB) > 1  ||  abs( dCosC) > 1) {
-      LOG_ERROR( GetEMkLogger(), "Error : position unreachable (robot)")
+      double dDeltaOut = dDistR2Cen - ( dDistR2R3 + dDistR3R5) ;
+      double dDeltaIn = dDistR2Cen - abs( dDistR2R3 - dDistR3R5) ;
+      string sErr = "Error : position for the robot unreachable" ;
+      if ( dDeltaOut > 0)
+         sErr += " (Out=" + ToString( dDeltaOut, 3) + ")" ;
+      else if ( dDeltaIn < 0)
+         sErr += " (In=" + ToString( dDeltaIn, 3) + ")" ;
+      LOG_ERROR( GetEMkLogger(), sErr.c_str())
       return false ;
    }
    double dAngB = acos( dCosB) * RADTODEG ;
@@ -2241,5 +2341,30 @@ Machine::GetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vecto
    vAng1.push_back( dAng6) ;
    vAng2.push_back( dAng6 + ( dAng6 > EPS_ANG_ZERO ? -ANG_STRAIGHT : ANG_STRAIGHT)) ;
 
+  // verifiche dei limiti di corsa
+   bool bAng1 = true, bAng2 = true ;
+   for ( int i = 0 ; i < int( vAng1.size()) ; ++ i) {
+      if ( ! AdjustAngleInStroke( m_vCalcRotAx[i].stroke, vAng1[i]))
+         bAng1 = false ;
+      if ( ! AdjustAngleInStroke( m_vCalcRotAx[i].stroke, vAng2[i]))
+         bAng2 = false ;
+   }
+   if ( bAng2) {
+      if ( ! bAng1) {
+         vAng1 = vAng2 ;
+         vAng2.clear() ;
+         swap( bAng1, bAng2) ;
+      }
+   }
+   else {
+      vAng2.clear() ;
+   }
+   if ( ! bAng1) {
+      int nStat ;
+      VerifyOutstroke( 0, 0, 0, vAng1, true, nStat) ;
+      LOG_ERROR( GetEMkLogger(), GetOutstrokeInfo().c_str())
+      return false ;
+   }
+
    return true ;
 }

MachineLua.cpp

@@ -37,6 +37,7 @@ static const string FLD_EXITMAXADJUST = "ExitMaxAdjust" ;
 static const string FLD_EXITMAXROTADJ = "ExitMaxRotAdj" ;
 static const string FLD_ANGDELTAMINFORHOME = "AngDeltaMinForHome" ;
 static const string FLD_MULTIPROCESS = "MultiProcess" ;
+static const string FLD_LINKAXESMOVEORDER = "LinkAxesMoveOrder" ;
 static const string FLD_NEWLINKMGR = "NewLinkMgr" ;
 static const string FLD_NAME = "Name" ;
 static const string FLD_PARENT = "Parent" ;
@@ -44,6 +45,7 @@ static const string FLD_GEO = "Geo" ;
 static const string FLD_AUX = "Aux" ;
 static const string FLD_TOKEN = "Token" ;
 static const string FLD_TYPE = "Type" ;
+static const string FLD_USE = "Use" ;
 static const string FLD_INVERT = "Invert" ;
 static const string FLD_AXIS_OFFSET = "Offset" ;
 static const string FLD_REF1 = "Ref1" ;
@@ -119,6 +121,13 @@ Machine::LuaInit( const string& sMachineName)
    m_LuaMgr.RegisterFunction( "EmtAddRapidMove", Machine::LuaEmtAddRapidMove) ;
    m_LuaMgr.RegisterFunction( "EmtAddLinearMove", Machine::LuaEmtAddLinearMove) ;
    m_LuaMgr.RegisterFunction( "EmtAddArcMove", Machine::LuaEmtAddArcMove) ;
+   m_LuaMgr.RegisterFunction( "EmtAddClimb", Machine::LuaEmtAddClimb) ;
+   m_LuaMgr.RegisterFunction( "EmtRemoveClimb", Machine::LuaEmtRemoveClimb) ;
+   m_LuaMgr.RegisterFunction( "EmtAddRise", Machine::LuaEmtAddRise) ;
+   m_LuaMgr.RegisterFunction( "EmtRemoveRise", Machine::LuaEmtRemoveRise) ;
+   m_LuaMgr.RegisterFunction( "EmtGetInitialAxesPos", Machine::LuaEmtGetInitialAxesPos) ;
+   m_LuaMgr.RegisterFunction( "EmtGetFinalAxesPos", Machine::LuaEmtGetFinalAxesPos) ;
+   m_LuaMgr.RegisterFunction( "EmtGetCurrAxesHomePos", Machine::LuaEmtGetCurrAxesHomePos) ;
   // registro le funzioni di lettura entità CL per lua
    m_LuaMgr.RegisterFunction( "EmtGetMoveType", Machine::LuaEmtGetMoveType) ;
    m_LuaMgr.RegisterFunction( "EmtGetAxesPos", Machine::LuaEmtGetAxesPos) ;
@@ -135,6 +144,10 @@ Machine::LuaInit( const string& sMachineName)
    m_LuaMgr.RegisterFunction( "EmtAddCollisionObj", Machine::LuaEmtAddCollisionObj) ;
   // registro la funzione estesa per aggiungere un oggetto da verificare per la collisione in simulazione
    m_LuaMgr.RegisterFunction( "EmtAddCollisionObjEx", Machine::LuaEmtAddCollisionObjEx) ;
+  // registro la funzione per rimuovere oggetti con dato FrameId da verificare per la collisione in simulazione
+   m_LuaMgr.RegisterFunction( "EmtRemoveCollisionObj", Machine::LuaEmtRemoveCollisionObj) ;
+  // registro la funzione per avere i dati dell'oggetto con posizione indicata nel vettore da verificare per la collisione in simulazione
+   m_LuaMgr.RegisterFunction( "EmtGetCollisionObj", Machine::LuaEmtGetCollisionObj) ;
   // registro la funzione di esecuzione della verifica di collisione in simulazione
    m_LuaMgr.RegisterFunction( "EmtExecCollisionCheck", Machine::LuaEmtExecCollisionCheck) ;
   // registro la funzione di gestione della collisione in simulazione
@@ -351,6 +364,9 @@ Machine::LuaEmtGeneral( lua_State* L)
   // lettura eventuale campo 'MultiProcess' dalla tabella (0=no, 1=si, 2=si con simulazione MP)
    int nMultiProcess = 0 ;
    LuaGetTabFieldParam( L, 1, FLD_MULTIPROCESS, nMultiProcess) ;
+  // lettura eventuale campo "LinkAxesMoveOrder" dalla tabella(0=interpolati, ...)
+   int nLinkAxesMoveOrder = 0 ;
+   LuaGetTabFieldParam( L, 1, FLD_LINKAXESMOVEORDER, nLinkAxesMoveOrder) ;
   // lettura eventuale campo 'NewLinkMgr' dalla tabella (0=old, 1 =new)
    int nNewLinkMgr = 0 ;
    LuaGetTabFieldParam( L, 1, FLD_NEWLINKMGR, nNewLinkMgr) ;
@@ -406,6 +422,8 @@ Machine::LuaEmtGeneral( lua_State* L)
 
   // imposto codice per macchina multiprocesso
    m_pMchLua->m_nMultiProcess = nMultiProcess ;
+  // imposto codice per ordine interpolazione assi nei collegamenti
+   m_pMchLua->m_nLinkAxesMoveOrder = nLinkAxesMoveOrder ;
   // imposto codice per gestione link tra lavorazioni
    m_pMchLua->m_nNewLinkMgr = nNewLinkMgr ;
 
@@ -530,6 +548,9 @@ Machine::LuaEmtAxis( lua_State* L)
   // lettura campo 'Type' dalla tabella
    int nType ;
    LuaCheckTabFieldParam( L, 1, FLD_TYPE, nType)
+  // lettura eventuale campo 'Use' della tabella (default General)
+   int nUse = MCH_AU_GENERAL ;
+   LuaGetTabFieldParam( L, 1, FLD_USE, nUse) ;
   // lettura campo 'Pos' dalla tabella
    Point3d ptPos ;
    LuaCheckTabFieldParam( L, 1, FLD_POS, ptPos)
@@ -563,7 +584,7 @@ Machine::LuaEmtAxis( lua_State* L)
 
   // carico i dati dell'asse
    if ( ! m_pMchLua->LoadMachineAxis( sName, sParent, sToken, bInvert, dOffset,
-                                      nType, ptPos, vtDir, Stroke, dHome, bAdjustAux, sGeo, vsAux))
+                                      nType, nUse, ptPos, vtDir, Stroke, dHome, bAdjustAux, sGeo, vsAux))
       return luaL_error( L, " Load Machine Axis failed") ;
 
   // restituisco l'indice dell'asse
@@ -1411,6 +1432,65 @@ Machine::LuaEmtAddCollisionObjEx( lua_State* L)
    return 1 ;
 }
 
+//----------------------------------------------------------------------------
+int
+Machine::LuaEmtRemoveCollisionObj( lua_State* L)
+{
+  // 1 parametro : nFrameId 
+   int nFrameId ;
+   LuaCheckParam( L, 1, nFrameId)
+   LuaClearStack( L) ;
+  // verifico ci sia una macchina attiva
+   if ( m_pMchLua == nullptr)
+      return luaL_error( L, " Unknown Machine") ;
+  // assegno i dati
+   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimRemoveCollisionObj( nFrameId)) ;
+  // assegno risultato
+   LuaSetParam( L, bOk) ;
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+int
+Machine::LuaEmtGetCollisionObj( lua_State* L)
+{
+  // 1 parametro : nPos 
+   int nPos ;
+   LuaCheckParam( L, 1, nPos)
+   LuaClearStack( L) ;
+  // verifico ci sia una macchina attiva
+   if ( m_pMchLua == nullptr)
+      return luaL_error( L, " Unknown Machine") ;
+  // recupero i dati
+   int nInd ;
+   bool bToolOn ;
+   int nFrameId ;
+   int nType ;
+   Vector3d vtMove ;
+   double dPar1 ;
+   double dPar2 ;
+   double dPar3 ;
+   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr  &&
+                m_pMchLua->m_pMchMgr->SimGetCollisionObj( nPos, nInd, bToolOn, nFrameId, nType, vtMove, dPar1, dPar2, dPar3)) ;
+  // assegno risultato
+   if ( bOk) {
+      LuaSetParam( L, true) ;
+      LuaSetParam( L, nInd) ;
+      LuaSetParam( L, bToolOn) ;
+      LuaSetParam( L, nFrameId) ;
+      LuaSetParam( L, nType) ;
+      LuaSetParam( L, vtMove) ;
+      LuaSetParam( L, dPar1) ;
+      LuaSetParam( L, dPar2) ;
+      LuaSetParam( L, dPar3) ;
+      return 9 ;  
+   }
+   else {
+      LuaSetParam( L, false) ;
+      return 1 ;
+   }
+}
+
 //----------------------------------------------------------------------------
 int
 Machine::LuaEmtExecCollisionCheck( lua_State* L)

MachineLuaCL.cpp

@@ -16,6 +16,7 @@
 #include "MachMgr.h"
 #include "DllMain.h"
 #include "CamData.h"
+#include "Operation.h"
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
@@ -32,7 +33,7 @@ using namespace std ;
 int
 Machine::LuaEmtAddRapidStart( lua_State* L)
 {
-  // 6 o 7 parametri : nPathId, ptP, vtTool, vtCorr, vtAux, nFlag [, bToolShow]
+  // 6, 7 o 8 parametri : nPathId, ptP, vtTool, vtCorr, vtAux, nFlag [, nFlag2] [, bToolShow]
    int nPathId ;
    LuaCheckParam( L, 1, nPathId)
    Point3d ptP ;
@@ -45,8 +46,12 @@ Machine::LuaEmtAddRapidStart( lua_State* L)
    LuaCheckParam( L, 5, vtAux)
    int nFlag ;
    LuaCheckParam( L, 6, nFlag)
+   int nFlag2 = 0 ;
    bool bToolShow = false ;
-   LuaGetParam( L, 7, bToolShow) ;
+   if ( LuaGetParam( L, 7, nFlag2))
+      LuaGetParam( L, 8, bToolShow) ;
+   else
+      LuaGetParam( L, 7, bToolShow) ;
    LuaClearStack( L) ;
   // verifico ci sia una macchina attiva valida
    if ( m_pMchLua == nullptr  ||
@@ -72,6 +77,7 @@ Machine::LuaEmtAddRapidStart( lua_State* L)
       pCam->SetEndPoint( ptP) ;
       pCam->SetFeed( 0) ;
       pCam->SetFlag( nFlag) ;
+      pCam->SetFlag2( nFlag2) ;
       pCam->SetToolShow( bToolShow) ;
      // associo questo oggetto a quello geometrico
       m_pMchLua->m_pGeomDB->SetUserObj( nId, Release( pCam)) ;
@@ -88,7 +94,7 @@ Machine::LuaEmtAddRapidStart( lua_State* L)
 int
 Machine::LuaEmtAddRapidMove( lua_State* L)
 {
-  // 7 o 8 parametri : nPathId, ptIni, ptFin, vtTool, vtCorr, vtAux, nFlag [, bToolShow]
+  // 7, 8 o 9 parametri : nPathId, ptIni, ptFin, vtTool, vtCorr, vtAux, nFlag [, nFlag2] [, bToolShow]
    int nPathId ;
    LuaCheckParam( L, 1, nPathId)
    Point3d ptIni ;
@@ -103,8 +109,12 @@ Machine::LuaEmtAddRapidMove( lua_State* L)
    LuaCheckParam( L, 6, vtAux)
    int nFlag ;
    LuaCheckParam( L, 7, nFlag)
+   int nFlag2 = 0 ;
    bool bToolShow = false ;
-   LuaGetParam( L, 8, bToolShow) ;
+   if ( LuaGetParam( L, 8, nFlag2))
+      LuaGetParam( L, 9, bToolShow) ;
+   else
+      LuaGetParam( L, 8, bToolShow) ;
    LuaClearStack( L) ;
   // verifico ci sia una macchina attiva valida
    if ( m_pMchLua == nullptr  ||
@@ -130,6 +140,7 @@ Machine::LuaEmtAddRapidMove( lua_State* L)
       pCam->SetEndPoint( ptFin) ;
       pCam->SetFeed( 0) ;
       pCam->SetFlag( nFlag) ;
+      pCam->SetFlag2( nFlag2) ;
       pCam->SetToolShow( bToolShow) ;
      // associo questo oggetto a quello geometrico
       m_pMchLua->m_pGeomDB->SetUserObj( nId, Release( pCam)) ;
@@ -146,7 +157,7 @@ Machine::LuaEmtAddRapidMove( lua_State* L)
 int
 Machine::LuaEmtAddLinearMove( lua_State* L)
 {
-  // 8 o 9 parametri : nPathId, ptIni, ptFin, vtTool, vtCorr, vtAux, dFeed, nFlag [, bToolShow]
+  // 8, 9 o 10 parametri : nPathId, ptIni, ptFin, vtTool, vtCorr, vtAux, dFeed, nFlag [, nFlag2] [, bToolShow]
    int nPathId ;
    LuaCheckParam( L, 1, nPathId)
    Point3d ptIni ;
@@ -163,8 +174,12 @@ Machine::LuaEmtAddLinearMove( lua_State* L)
    LuaCheckParam( L, 7, dFeed)
    int nFlag ;
    LuaCheckParam( L, 8, nFlag)
+   int nFlag2 = 0 ;
    bool bToolShow = false ;
-   LuaGetParam( L, 9, bToolShow) ;
+   if ( LuaGetParam( L, 9, nFlag2))
+      LuaGetParam( L, 10, bToolShow) ;
+   else
+      LuaGetParam( L, 9, bToolShow) ;
    LuaClearStack( L) ;
   // verifico ci sia una macchina attiva valida
    if ( m_pMchLua == nullptr  ||
@@ -190,6 +205,7 @@ Machine::LuaEmtAddLinearMove( lua_State* L)
       pCam->SetEndPoint( ptFin) ;
       pCam->SetFeed( dFeed) ;
       pCam->SetFlag( nFlag) ;
+      pCam->SetFlag2( nFlag2) ;
       pCam->SetToolShow( bToolShow) ;
      // associo questo oggetto a quello geometrico
       m_pMchLua->m_pGeomDB->SetUserObj( nId, Release( pCam)) ;
@@ -276,6 +292,189 @@ Machine::LuaEmtAddArcMove( lua_State* L)
    return 1 ;
 }
 
+//----------------------------------------------------------------------------
+int
+Machine::LuaEmtAddClimb( lua_State* L)
+{
+  // 5 o 6 parametri : nMachId, vAxVal, nMask, nFlag, nFlag2 [, sInfo]
+   int nMachId ;
+   LuaCheckParam( L, 1, nMachId)
+   DBLVECTOR vAxVal ;
+   LuaCheckParam( L, 2, vAxVal)
+   int nMask ;
+   LuaCheckParam( L, 3, nMask)
+   int nFlag ;
+   LuaCheckParam( L, 4, nFlag)
+   int nFlag2 ;
+   LuaCheckParam( L, 5, nFlag2)
+   string sInfo = "" ;
+   LuaGetParam( L, 6, sInfo) ;
+   LuaClearStack( L) ;
+  // verifico ci sia una macchina attiva valida
+   if ( m_pMchLua == nullptr  ||
+        m_pMchLua->m_pMchMgr == nullptr  ||  m_pMchLua->m_pGeomDB == nullptr)
+      return luaL_error( L, " Unknown Machine") ;
+  // recupero l'operazione
+   Operation* pOper = GetOperation( m_pMchLua->m_pGeomDB->GetUserObj( nMachId)) ;
+  // imposto la discesa (primo movimento del primo percorso della lavorazione)
+   bool bOk = ( pOper != nullptr && pOper->AddSpecialClimb( vAxVal, ( nMask >= 0), GDB_ID_NULL, nFlag, nFlag2, nMask, sInfo, false)) ;
+   if ( ! bOk)
+      return luaL_error( L, " Error in EmtAddClimb") ;
+   LuaSetParam( L, bOk) ;
+
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+int
+Machine::LuaEmtRemoveClimb( lua_State* L)
+{
+  // 1 parametro : nMachId
+   int nMachId ;
+   LuaCheckParam( L, 1, nMachId)
+   LuaClearStack( L) ;
+  // verifico ci sia una macchina attiva valida
+   if ( m_pMchLua == nullptr  ||
+        m_pMchLua->m_pMchMgr == nullptr  ||  m_pMchLua->m_pGeomDB == nullptr)
+      return luaL_error( L, " Unknown Machine") ;
+  // recupero l'operazione
+   Operation* pOper = GetOperation( m_pMchLua->m_pGeomDB->GetUserObj( nMachId)) ;
+  // elimino le discese (primi movimenti "CLIMB" del primo percorso della lavorazione)
+   bool bOk = ( pOper != nullptr && pOper->RemoveClimb()) ;
+   LuaSetParam( L, bOk) ;
+
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+int
+Machine::LuaEmtAddRise( lua_State* L)
+{
+  // 5 o 6 parametri : nMachId, vAxVal, nMask, nFlag, nFlag2 [, sInfo]
+   int nMachId ;
+   LuaCheckParam( L, 1, nMachId)
+   DBLVECTOR vAxVal ;
+   LuaCheckParam( L, 2, vAxVal)
+   int nMask ;
+   LuaCheckParam( L, 3, nMask)
+   int nFlag ;
+   LuaCheckParam( L, 4, nFlag)
+   int nFlag2 ;
+   LuaCheckParam( L, 5, nFlag2)
+   string sInfo = "" ;
+   LuaGetParam( L, 6, sInfo) ;
+   LuaClearStack( L) ;
+  // verifico ci sia una macchina attiva valida
+   if ( m_pMchLua == nullptr  ||
+        m_pMchLua->m_pMchMgr == nullptr  ||  m_pMchLua->m_pGeomDB == nullptr)
+      return luaL_error( L, " Unknown Machine") ;
+  // recupero l'operazione
+   Operation* pOper = GetOperation( m_pMchLua->m_pGeomDB->GetUserObj( nMachId)) ;
+  // aggiungo la risalita (ultimo movimento dell'ultimo percorso della lavorazione)
+   bool bOk = ( pOper != nullptr && pOper->AddSpecialRise( vAxVal, ( nMask >= 0), GDB_ID_NULL, nFlag, nFlag2, nMask, sInfo)) ;
+   if ( ! bOk)
+      return luaL_error( L, " Error in EmtAddRise") ;
+   LuaSetParam( L, bOk) ;
+
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+int
+Machine::LuaEmtRemoveRise( lua_State* L)
+{
+  // 1 parametro : nMachId
+   int nMachId ;
+   LuaCheckParam( L, 1, nMachId)
+   LuaClearStack( L) ;
+  // verifico ci sia una macchina attiva valida
+   if ( m_pMchLua == nullptr  ||
+        m_pMchLua->m_pMchMgr == nullptr  ||  m_pMchLua->m_pGeomDB == nullptr)
+      return luaL_error( L, " Unknown Machine") ;
+  // recupero l'operazione
+   Operation* pOper = GetOperation( m_pMchLua->m_pGeomDB->GetUserObj( nMachId)) ;
+  // elimino le risalite (ultimi movimenti "RISE" dell'ultimo percorso della lavorazione)
+   bool bOk = ( pOper != nullptr && pOper->RemoveRise()) ;
+   LuaSetParam( L, bOk) ;
+
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+int
+Machine::LuaEmtGetInitialAxesPos( lua_State* L)
+{
+  // 1 o 2 parametri : nMachId [, bSkipClimb]
+   int nMachId ;
+   LuaCheckParam( L, 1, nMachId)
+   bool bSkipClimb = true ;
+   LuaGetParam( L, 2, bSkipClimb) ;
+   LuaClearStack( L) ;
+  // verifico ci sia una macchina attiva valida
+   if ( m_pMchLua == nullptr  ||
+        m_pMchLua->m_pMchMgr == nullptr  ||  m_pMchLua->m_pGeomDB == nullptr)
+      return luaL_error( L, " Unknown Machine") ;
+  // recupero l'operazione
+   Operation* pOper = GetOperation( m_pMchLua->m_pGeomDB->GetUserObj( nMachId)) ;
+  // acquisico il valore iniziale degli assi macchina
+   DBLVECTOR vAxesVal ;
+   bool bOk = ( pOper != nullptr  &&  pOper->GetInitialAxesValues( bSkipClimb, vAxesVal)) ;
+   if ( bOk)
+      LuaSetParam( L, vAxesVal) ;
+   else
+      LuaSetParam( L) ;
+
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+int
+Machine::LuaEmtGetFinalAxesPos( lua_State* L)
+{
+  // 1 o 2 parametri : nMachId [, bSkipRise]
+   int nMachId ;
+   LuaCheckParam( L, 1, nMachId)
+   bool bSkipRise = true ;
+   LuaGetParam( L, 2, bSkipRise) ;
+   LuaClearStack( L) ;
+  // verifico ci sia una macchina attiva valida
+   if ( m_pMchLua == nullptr  ||
+        m_pMchLua->m_pMchMgr == nullptr  ||  m_pMchLua->m_pGeomDB == nullptr)
+      return luaL_error( L, " Unknown Machine") ;
+  // recupero l'operazione
+   Operation* pOper = GetOperation( m_pMchLua->m_pGeomDB->GetUserObj( nMachId)) ;
+  // acquisico il valore finale degli assi macchina
+   DBLVECTOR vAxesVal ;
+   bool bOk = ( pOper != nullptr  &&  pOper->GetFinalAxesValues( bSkipRise, vAxesVal)) ;
+   if ( bOk)
+      LuaSetParam( L, vAxesVal) ;
+   else
+      LuaSetParam( L) ;
+
+   return 1 ;
+}
+
+//----------------------------------------------------------------------------
+int
+Machine::LuaEmtGetCurrAxesHomePos( lua_State* L)
+{
+  // nessun parametro
+   LuaClearStack( L) ;
+  // verifico ci sia una macchina attiva valida
+   if ( m_pMchLua == nullptr  ||
+        m_pMchLua->m_pMchMgr == nullptr  ||  m_pMchLua->m_pGeomDB == nullptr)
+      return luaL_error( L, " Unknown Machine") ;
+  // acquisisco la posizione di home degli assi della catena cinematica corrente
+   DBLVECTOR vAxHomeVal ;
+   bool bOk = m_pMchLua->GetAllCurrAxesHomePos( vAxHomeVal) ;
+   if ( bOk)
+      LuaSetParam( L, vAxHomeVal) ;
+   else
+      LuaSetParam( L) ;
+
+   return 1 ;
+}
+
 //----------------------------------------------------------------------------
 int
 Machine::LuaEmtGetMoveType( lua_State* L)

MachineStruConst.h

@@ -81,6 +81,13 @@ enum MchAxisType { MCH_AT_NONE = 0,
                    MCH_AT_LINEAR = 1,
                    MCH_AT_ROTARY = 2} ;
 
+//----------------------------------------------------------------------------
+// Uso di assi della macchina
+enum MchAxisUse { MCH_AU_NONE = 0,
+                  MCH_AU_GENERAL = 1,
+                  MCH_AU_DISPOSITION = 2,
+                  MCH_AU_AUXILIAR = 3} ;
+
 //----------------------------------------------------------------------------
 // Tipo di testa della macchina
 enum MchHeadType { MCH_HT_NONE = 0,
@@ -97,7 +104,7 @@ enum MchSelType { MCH_SLT_FIXEDEXITS = 0,
 //----------------------------------------------------------------------------
 // Tipo della catena cinematica
 enum KinChainType { KIN_CHAIN_NONE = 0,
-                    KIN_CHAIN_CENTER = 1,
+                    KIN_CHAIN_MCENT = 1,
                     KIN_CHAIN_ROBOT = 2} ;
 
 //----------------------------------------------------------------------------

Machining.h

@@ -8,6 +8,7 @@
 //
 //
 // Modifiche : 07.06.15 DS Creazione modulo.
+//             24.02.26 RE Aggiunta Gestione Preview per Utensile e Testa
 //
 //
 //----------------------------------------------------------------------------
@@ -40,7 +41,7 @@ class Machining : public Operation
       virtual bool GetParam( int nType, int& nVal) const = 0 ;
       virtual bool GetParam( int nType, double& dVal) const = 0 ;
       virtual bool GetParam( int nType, std::string& sVal) const = 0 ;
-      virtual bool UpdateToolData( bool* pbChanged = nullptr) = 0 ;
+      virtual bool UpdateToolData( void) = 0 ;
       virtual const ToolData& GetToolData( void) const = 0 ;
       virtual bool GetGeometry( SELVECTOR& vIds) const = 0 ;
       virtual bool GetSkippedGeometry( SELVECTOR& vIds) const
@@ -49,19 +50,39 @@ class Machining : public Operation
    public :
       bool GetStartPoint( Point3d& ptStart) const ;
       bool GetEndPoint( Point3d& ptEnd) const ;
-      bool PrepareToolPreview( void) const ;
-      bool RemoveToolPreview( void) const ;
+      bool ChangeToolPreviewShow( int nFlag) ;
+      bool PrepareToolPreview( void) ;
+      bool RemoveToolPreview( void) ;
       int  GetToolPreviewStepCount( void) const ;
       int  ToolPreview( int nEntId, int nStep) const ;
-      bool ActivateDrillingUnit( int nHeadId, const INTVECTOR& vActExit) const ;
 
    protected :
       Machining( void) ;
+      ~Machining( void) ;
+      bool SpecialApply( std::string& sErr) ;
       bool PostApply( std::string& sErr) ;
+      int  GetDoubleType( const std::string& sUserNotes) ;
+      bool GetDoubleToolData( std::string& sDblTool, std::string& sDblHead, int& nDblExit) const ;
+      bool CalcMirrorByDouble( int nClId, const std::string& sUserNotes) ;
+      bool ActivateDrillingUnit( int nHeadId, const INTVECTOR& vActExit) const ;
 
    private :
       int  GetToolPreviewNext( int nEntId, int nParentId, int nStId) const ;
       int  GetToolPreviewPrev( int nEntId, int nParentId, int nStId) const ;
+      bool MyPrepareToolPreview( bool bDouble) ;
+      bool MyChangeToolPreviewShow( int nLookFlag, bool bDouble) ;
+      bool MyToolPreview( int nEntId, bool bDouble) const ;
+
+   private :
+      int m_nLookFlag ;                      // flag di Visualizzazione per Preview
+     // lavorazione singola
+      int m_nPreviewHeadId ;                 // Id del gruppo testa di Preview
+      int m_nPreviewToolTip ;                // Id del gruppo contenente il punto ToolTip
+      INTVECTOR m_vPreviewAxisIds ;          // indici degli assi di Preview
+     // lavorazione in doppio
+      int m_nPreviewHeadIdDBL ;              // Id della testa di Preview
+      int m_nPreviewToolTipDBL ;             // Id del gruppo contenente il punto di ToolTip
+      INTVECTOR m_vPreviewAxisIdsBBL ;       // indici degli assi di Preview
 } ;
 
 //----------------------------------------------------------------------------

MachiningConst.h

@@ -107,7 +107,8 @@ GetMachiningTitle( int nMchType)
                                     "SurfRoughing",
                                     "SurfFinishing",
                                     "Waterjetting",
-                                    "5AxisMilling"} ;
+                                    "5AxisMilling",
+                                    "Probing"} ;
    switch ( nMchType) {
    case MT_DRILLING : return MchTitle[1] ;
    case MT_SAWING : return MchTitle[2] ;
@@ -122,7 +123,7 @@ GetMachiningTitle( int nMchType)
    case MT_SURFFINISHING : return MchTitle[11] ;
    case MT_WATERJETTING : return MchTitle[12] ;
    case MT_FIVEAXISMILLING : return MchTitle[13] ;
-
+   case MT_PROBING : return MchTitle[14] ;
    }
    return MchTitle[0] ;
 }

MachiningDataFactory.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2015
+//  EgalTech 2015-2025
 //----------------------------------------------------------------------------
-// File : MachiningDataFactory.h       Data : 05.06.15      Versione : 1.6f1
+// File : MachiningDataFactory.h       Data : 31.10.25      Versione : 2.7k1
 // Contenuto : Factory della classe MachiningData.
 //
 //
@@ -26,35 +26,6 @@
 #define MCHDATA_CREATE( nType)              MachiningDataFactory::Create( nType)
 #define MCHDATA_GETLIST( vsList)            MachiningDataFactory::GetList( vsList)
 
-//----------------------------------------------------------------------------
-template <typename T> 
-class MachiningDataRegister
-{
-   public :
-      static bool DoRegister( int nType, const std::string& sName)
-         {  if ( ! MachiningDataFactory::Register( nType, sName, Create))
-               return false ;
-            GetTypePrivate() = nType ;
-            GetNamePrivate() = sName ;
-            return true ; }
-      static MachiningData* Create( void) 
-         {  return new(nothrow) T ; }
-      static int GetType( void) 
-         { return GetTypePrivate() ; }
-      static const std::string& GetName( void) 
-         { return GetNamePrivate() ; }
-
-   private :
-      MachiningDataRegister( void)  {}
-      ~MachiningDataRegister( void) {}
-      static int& GetTypePrivate( void) 
-         { static int s_nType ;
-           return s_nType ; }
-      static std::string& GetNamePrivate( void) 
-         { static std::string s_sName ;
-           return s_sName ; }
-} ;
-
 //----------------------------------------------------------------------------
 class MachiningDataFactory
 {
@@ -108,3 +79,32 @@ class MachiningDataFactory
            return s_CreatorMap ;
          }
 } ;
+
+//----------------------------------------------------------------------------
+template <typename T> 
+class MachiningDataRegister
+{
+   public :
+      static bool DoRegister( int nType, const std::string& sName)
+         {  if ( ! MachiningDataFactory::Register( nType, sName, Create))
+               return false ;
+            GetTypePrivate() = nType ;
+            GetNamePrivate() = sName ;
+            return true ; }
+      static MachiningData* Create( void) 
+         {  return new( std::nothrow) T ; }
+      static int GetType( void) 
+         { return GetTypePrivate() ; }
+      static const std::string& GetName( void) 
+         { return GetNamePrivate() ; }
+
+   private :
+      MachiningDataRegister( void)  {}
+      ~MachiningDataRegister( void) {}
+      static int& GetTypePrivate( void) 
+         { static int s_nType ;
+           return s_nType ; }
+      static std::string& GetNamePrivate( void) 
+         { static std::string s_sName ;
+           return s_sName ; }
+} ;

MachiningRegister.h

@@ -0,0 +1,43 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2025-2025
+//----------------------------------------------------------------------------
+// File : MachiningRegister.h        Data : 02.05.25        Versione : 2.7e1
+// Contenuto : Funzioni per registrazione dinamica oggetti delle lavorazioni      
+//             (per decidere tra versioni diverse di una lavorazione). 
+//
+//
+// Modifiche : 02.05.25 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "OperationConst.h"
+#include "Pocketing.h"
+#include "PocketingNT.h"
+#include "/EgtDev/Include/EGkUserObjFactory.h"
+#include "/EgtDev/Include/EgtIniFile.h"
+
+//----------------------------------------------------------------------------
+// Registrazione dinamica delle svuotature da parametro nel file Ini dell'eseguibile
+inline bool
+RegisterPocketing( void)
+{
+   const char* SEC_MACH = "Mach" ;
+   const char* KEY_POCKETING = "Pocketing" ;
+   static bool bFirst = true ;
+   if ( bFirst) {
+      std::string sIniPath ;
+      ExeGetIniFile( sIniPath) ;
+      int nPockType = GetPrivateProfileInt( SEC_MACH, KEY_POCKETING, 2, sIniPath.c_str()) ;
+      if ( nPockType == 2)
+         UserObjRegister<PocketingNT>::DoRegister( GetOperationClass( OPER_POCKETING)) ;
+      else
+         UserObjRegister<Pocketing>::DoRegister( GetOperationClass( OPER_POCKETING)) ;
+      std::string sInfo = "Mach-Pocketing=" + ToString( nPockType) ;
+      LOG_INFO( GetEMkLogger(), sInfo.c_str())
+      bFirst = false ;
+   }
+   return true ;
+}

MachiningsMgr.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2025
 //----------------------------------------------------------------------------
-// File : MachiningsMgr.cpp       Data : 29.03.24          Versione : 2.6d1
+// File : MachiningsMgr.cpp       Data : 09.06.25          Versione : 2.7f2
 // Contenuto : Implementazione gestore database lavorazioni.
 //
 //
@@ -17,6 +17,7 @@
 //             09.11.20 DS Agg. per nuovi parametri tagli di lama (MF_CURR_VER = 1011).
 //             04.02.22 DS Agg. per nuovi parametri svuotature con epicicli (MF_CURR_VER = 1012).
 //             29.03.24 DS Agg. parametro APPROX_LINTOL (MF_CURR_VER = 1013).
+//             29.03.24 DS Agg. tastatura (MF_CURR_VER = 1014).
 //
 //----------------------------------------------------------------------------
 
@@ -43,7 +44,7 @@ const string MF_HEADER = "[HEADER]" ;
 const string MF_VERSION = "VERSION" ;
 const string MF_TOTAL = "TOTAL" ;
 const string MF_SIZE = "SIZE" ;
-const int    MF_CURR_VER = 1013 ;
+const int    MF_CURR_VER = 1014 ;
 const string MF_GENERAL = "[GENERAL]" ;
 const string MF_3AXCOMP = "3AXCOMP" ;
 const bool   MF_CURR_3AXCOMP = false ;
@@ -125,11 +126,12 @@ MachiningsMgr::Clear( bool bReset)
 
 //----------------------------------------------------------------------------
 bool
-MachiningsMgr::Load( const string& sMachsFile, const ToolsMgr* pTsMgr)
+MachiningsMgr::Load( const string& sMachsDir, const string& sMachsFile, const ToolsMgr* pTsMgr)
 {
   // Salvo la path del file con i dati
-   m_sMachsFile = sMachsFile ;
-   string sOut = "MachiningsMgr Init : " + m_sMachsFile ;
+   m_sMachsDir = sMachsDir ;
+   m_sMachsPath = m_sMachsDir + "\\" + sMachsFile ;
+   string sOut = "MachiningsMgr Init : " + m_sMachsPath ;
    LOG_INFO( GetEMkLogger(), sOut.c_str())
 
   // Verifico il gestore degli utensili
@@ -158,9 +160,15 @@ MachiningsMgr::Reload( void)
 
   // Inizializzo lo scanner
    Scanner TheScanner ;
-   if ( ! TheScanner.Init( m_sMachsFile, ";")) {
+   if ( ! TheScanner.Init( m_sMachsPath, ";")) {
       LOG_ERROR( GetEMkLogger(), "ReloadMachinings : Error on Init")
-      return false ;
+      if ( ExistsDirectory( m_sMachsDir)  &&  ! ExistsFile( m_sMachsPath)) {
+         m_nDbVer = MF_CURR_VER ;
+         m_bModified = true ;
+         return true ;
+      }
+      else
+         return false ;
    }
 
   // variabili di stato della lettura
@@ -399,17 +407,17 @@ MachiningsMgr::Save( bool bCompressed) const
       return true ;
 
   // Faccio copia di backup del file originale
-   CopyFileEgt( m_sMachsFile, m_sMachsFile + ".bak") ;
+   CopyFileEgt( m_sMachsPath, m_sMachsPath + ".bak") ;
 
   // Inizializzo il writer
    Writer TheWriter ;
-   if ( ! TheWriter.Init( m_sMachsFile, bCompressed)) {
+   if ( ! TheWriter.Init( m_sMachsPath, bCompressed)) {
       LOG_ERROR( GetEMkLogger(), "SaveMachinings : Error on Init")
       return false ;
    }
 
   // Scrivo linea di inizio file
-   string sOut = "; --- " + m_sMachsFile + "  " + CurrDateTime() + " ---" ;
+   string sOut = "; --- " + m_sMachsPath + "  " + CurrDateTime() + " ---" ;
    if ( ! TheWriter.OutText( sOut)) {
       LOG_ERROR( GetEMkLogger(), "SaveMachinings : Error on Start")
       return false ;
@@ -848,7 +856,7 @@ MachiningsMgr::SetCurrMachiningParam( int nType, double dVal)
    }
   // se feed
    else if ( nType == MPA_FEED  ||  nType == MPA_STARTFEED  ||  nType == MPA_ENDFEED  ||
-             nType == MPA_TIPFEED  ||  nType == MPA_VERTFEED  ||  nType == MPA_BACKFEED) {
+             nType == MPA_TIPFEED  ||  nType == MPA_VERTFEED  ||  nType == MPA_BACKFEED  ||  nType == MPA_SIDEANGFEED) {
      // recupero valore da utensile
       const ToolData* pTdata ;
       if ( ! m_pCurrMach->GetTool( m_pTsMgr, pTdata))

MachiningsMgr.h

@@ -27,7 +27,7 @@ class MachiningsMgr
    public :
       MachiningsMgr( void) ;
       ~MachiningsMgr( void) ;
-      bool Load( const std::string& sMachsFile, const ToolsMgr* pTsMgr) ;
+      bool Load( const std::string& sMachsDir, const std::string& sMachsFile, const ToolsMgr* pTsMgr) ;
       bool Reload( void) ;
       bool Save( bool bCompressed = true) const ;
       bool GetMachiningNewName( std::string& sName) const ;
@@ -108,8 +108,9 @@ class MachiningsMgr
       typedef STRUUID_MAP::const_iterator STRUUID_CITER ;
 
    private :
-      // path file lavorazioni
-      std::string      m_sMachsFile ;
+      // dir e path file lavorazioni
+      std::string      m_sMachsDir ;
+      std::string      m_sMachsPath ;
       // flag di dati modificati
       mutable bool     m_bModified ;
       // versione DB caricato

Milling.cpp

@@ -21,6 +21,7 @@
 #include "Milling.h"
 #include "GeoConst.h"
 #include "OperationConst.h"
+#include "OperUserNotesConst.h"
 #include "/EgtDev/Include/EXeCmdLogOff.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
@@ -76,6 +77,7 @@ const double LIM_SIN_DIFF_DIR = 0.175 ;
 // 2323 = "Error in Milling : machining depth (xxx) bigger than MaxDepth (yyy)"
 // 2324 = "Error in Milling : LeadOut must be out of rawpart"
 // 2325 = "Error in Milling : Mirror for Double calculation failed" 
+// 2326 = "Error in Milling : special apply not calculable"
 // 2351 = "Warning in Milling : Skipped entity (xx)"
 // 2352 = "Warning in Milling : No machinable path"
 // 2353 = "Warning in Milling : Tool name changed (xx)"
@@ -377,7 +379,7 @@ Milling::SetParam( int nType, int nVal)
       if ( ! m_Params.VerifyFaceUse( nVal))
          return false ;
       if ( nVal != m_Params.m_nFaceUse)
-         m_nStatus |= MCH_ST_PARAM_MODIF ;
+         m_nStatus |= ( MCH_ST_PARAM_MODIF | MCH_ST_GEO_MODIF) ;
       m_Params.m_nFaceUse = nVal ;
       return true ;
    }
@@ -576,8 +578,17 @@ Milling::SetParam( int nType, const string& sVal)
       m_Params.m_sSysNotes = sVal ;
       return true ;
    case MPA_USERNOTES :
-      if ( sVal != m_Params.m_sUserNotes)
+      if ( sVal != m_Params.m_sUserNotes) {
          m_nStatus |= MCH_ST_PARAM_MODIF ;
+         Vector3d vtNew ; GetValInNotes( sVal, UN_VTFACEUSE, vtNew) ;
+         Vector3d vtOri ; GetValInNotes( m_Params.m_sUserNotes, UN_VTFACEUSE, vtOri) ;
+         if ( ! AreSameVectorApprox( vtNew, vtOri))
+            m_nStatus |= MCH_ST_GEO_MODIF ;
+         INTVECTOR vnNew ; GetValInNotes( sVal, UN_EDGESFACEUSE, vnNew) ;
+         INTVECTOR vnOri ; GetValInNotes( m_Params.m_sUserNotes, UN_EDGESFACEUSE, vnOri) ;
+         if ( vnNew != vnOri)
+            m_nStatus |= MCH_ST_GEO_MODIF ;
+      }
       m_Params.m_sUserNotes = sVal ;
       return true ;
    case MPA_INITANGS :
@@ -601,7 +612,8 @@ Milling::SetGeometry( const SELVECTOR& vIds)
   // verifico validità gestore DB geometrico
    if ( m_pGeomDB == nullptr)
       return false ;
-  // reset della geometria corrente
+  // copia temporanea e reset della geometria corrente
+   SELVECTOR vOldId = m_vId ;
    m_vId.clear() ;
   // verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve, tutti testi o tutte facce)
    int nType = GEO_NONE ;
@@ -617,7 +629,8 @@ Milling::SetGeometry( const SELVECTOR& vIds)
       m_vId.emplace_back( Id) ;
    }
   // aggiorno lo stato
-   m_nStatus |= MCH_ST_GEO_MODIF ;
+   if ( m_vId != vOldId)
+      m_nStatus |= MCH_ST_GEO_MODIF ;
   // restituisco presenza geometria da lavorare
    return ( ! m_vId.empty()  ||  vIds.empty()) ;
 }
@@ -718,16 +731,18 @@ Milling::Apply( bool bRecalc, bool bPostApply)
       return false ;
 
   // aggiorno dati geometrici dell'utensile
-   bool bToolChanged = true ;
-   if ( ! UpdateToolData( &bToolChanged)) {
+   if ( ! UpdateToolData()) {
       m_pMchMgr->SetLastError( 2301, "Error in Milling : UpdateToolData failed") ;
       return false ;
    }
    m_nHeadSolCh = m_pMchMgr->GetCurrMachine()->GetHeadSolCh( m_TParams.m_sHead) ;
 
+  // se modificata geometria, necessario ricalcolo
+   if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
+      bRecalc = true ;
+
   // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ! bToolChanged  &&  
-        ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
+   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
      // confermo i percorsi di lavorazione
       m_nMills = nCurrMills ;
       string sLog = string( "Milling apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
@@ -834,16 +849,16 @@ Milling::Apply( bool bRecalc, bool bPostApply)
   // assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso
    CalcAndSetBBox( nClId) ;
 
-  // eseguo aggiornamento assi macchina e collegamento con operazione precedente
-   if ( ! Update( bPostApply))
-      return false ;
-
   // se lavorazione in doppio, aggiungo geometria della parte simmetrica
    if ( ! CalcMirrorByDouble( nClId, m_Params.m_sUserNotes)) {
       m_pMchMgr->SetLastError( 2325, "Error in Milling : Mirror for Double calculation failed") ;
       return false ;
    }
 
+  // eseguo aggiornamento assi macchina e collegamento con operazione precedente
+   if ( ! Update( bPostApply))
+      return false ;
+
   // aggiorno stato della lavorazione
    m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
   // dichiaro successiva da aggiornare
@@ -887,7 +902,48 @@ Milling::Update( bool bPostApply)
       return false ;
    }
 
-  // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
+  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+   CalcAndSetAxesBBox() ;
+
+  // se lavorazione in doppio, calcolo assi e movimenti di approccio e retrazione relativi
+   if ( GetDoubleType( m_Params.m_sUserNotes) != 0) {
+     // elimino le entità CLIMB, RISE e HOME della lavorazione in doppio
+      RemoveClimbRiseHome( false) ;
+     // recupero i dati della testa in doppio e la imposto
+      string sDblTool ; string sDblHead ; int nDblExit ;
+      bool bOk = GetDoubleToolData( sDblTool, sDblHead, nDblExit)  &&
+                 m_pMchMgr->SetCalcTool( sDblTool, sDblHead, nDblExit) ;
+     // imposto eventuale asse bloccato da lavorazione
+      SetBlockedRotAxis( m_Params.m_sBlockedAxis, true) ;
+     // eseguo il calcolo
+      if ( bOk) {
+         if ( ! CalculateDoubleAxesValues( sHint)) {
+            string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
+            if ( sInfo.empty())
+               m_pMchMgr->SetLastError( 2317, "Error in Milling : axes values not calculable for double") ;
+            else
+               m_pMchMgr->SetLastError( 2318, "Error in Milling : double outstroke ") ;
+            bOk = false ;
+         }
+      }
+     // ripristino testa principale
+      m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()) ;
+     // in caso di errore, esco
+      if ( ! bOk)
+         return false ;
+   }
+
+  // esecuzione eventuali personalizzazioni speciali
+   string sSpecErr ;
+   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
+      if ( ! IsEmptyOrSpaces( sSpecErr))
+         m_pMchMgr->SetLastError( 2326, sSpecErr) ;
+      else
+         m_pMchMgr->SetLastError( 2326, "Error in Milling : special apply not calculable") ;
+      return false ;
+   }
+
+  // gestione movimenti all'inizio e fine di ogni singolo percorso di lavorazione
    if ( ! AdjustStartEndMovements()) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
       if ( sInfo.empty())
@@ -897,14 +953,11 @@ Milling::Update( bool bPostApply)
       return false ;
    }
 
-  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
-   CalcAndSetAxesBBox() ;
-
-  // esecuzione eventuali personalizzazioni
-   string sErr ;
-   if ( bPostApply  &&  ! PostApply( sErr)) {
-      if ( ! IsEmptyOrSpaces( sErr))
-         m_pMchMgr->SetLastError( 2321, sErr) ;
+  // esecuzione eventuali personalizzazioni finali
+   string sPostErr ;
+   if ( bPostApply  &&  ! PostApply( sPostErr)) {
+      if ( ! IsEmptyOrSpaces( sPostErr))
+         m_pMchMgr->SetLastError( 2321, sPostErr) ;
       else
          m_pMchMgr->SetLastError( 2321, "Error in Milling : post apply not calculable") ;
       return false ;
@@ -1109,7 +1162,7 @@ Milling::GetToolData( void) const
 
 //----------------------------------------------------------------------------
 bool
-Milling::UpdateToolData( bool* pbChanged)
+Milling::UpdateToolData( void)
 {
   // recupero il gestore DB utensili della macchina corrente
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
@@ -1160,9 +1213,9 @@ Milling::UpdateToolData( bool* pbChanged)
                       m_Params.m_sToolName + ")" ;
       m_pMchMgr->SetWarning( 2354, sInfo) ;
    }
-  // se definito parametro di ritorno, lo assegno
-   if ( pbChanged != nullptr)
-      *pbChanged = bChanged ;
+  // se modificato, aggiusto lo stato
+   if ( bChanged)
+      m_nStatus = MCH_ST_TO_VERIFY ;
    return true ;
 }
 
@@ -1376,10 +1429,14 @@ Milling::GetCurves( SelData Id, ICURVEPLIST& lstPC)
          nToolDir = TOOL_PARAL ;
       int nFaceUse = ( m_Params.m_nFaceUse & 31) ;
       Vector3d vtFaceUse ;
-      if ( GetValInNotes( m_Params.m_sUserNotes, "VtFaceUse", vtFaceUse)  &&  ! vtFaceUse.IsSmall())
+      if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTFACEUSE, vtFaceUse)  &&  ! vtFaceUse.IsSmall())
          nFaceUse = FACE_VERSOR ;
+      INTVECTOR vnEdgesFaceUse ;
+      if ( GetValInNotes( m_Params.m_sUserNotes, UN_EDGESFACEUSE, vnEdgesFaceUse)  &&  ! vnEdgesFaceUse.empty())
+         nFaceUse = FACE_EDGES ;
       double dSawThick = ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 ? m_TParams.m_dThick : 0) ;
-      AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, vtFaceUse, dSawThick) ;
+      if ( ! AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, vtFaceUse, vnEdgesFaceUse, dSawThick))
+         return false ;
      // la restituisco
       lstPC.emplace_back( Release( pCrvCompo)) ;
       return true ;
@@ -1404,8 +1461,11 @@ Milling::GetCurves( SelData Id, ICURVEPLIST& lstPC)
          nToolDir = TOOL_PARAL ;
       int nFaceUse = ( m_Params.m_nFaceUse & 31) ;
       Vector3d vtFaceUse ;
-      if ( GetValInNotes( m_Params.m_sUserNotes, "VtFaceUse", vtFaceUse)  &&  ! vtFaceUse.IsSmall())
+      if ( GetValInNotes( m_Params.m_sUserNotes, UN_VTFACEUSE, vtFaceUse)  &&  ! vtFaceUse.IsSmall())
          nFaceUse = FACE_VERSOR ;
+      INTVECTOR vnEdgesFaceUse ;
+      if ( GetValInNotes( m_Params.m_sUserNotes, UN_EDGESFACEUSE, vnEdgesFaceUse)  &&  ! vnEdgesFaceUse.empty())
+         nFaceUse = FACE_EDGES ;
       double dSawThick = ( ( m_TParams.m_nType & TF_SAWBLADE) != 0 ? m_TParams.m_dThick : 0) ;
      // determino intervallo di chunk
       int nCstart = 0 ;
@@ -1414,6 +1474,10 @@ Milling::GetCurves( SelData Id, ICURVEPLIST& lstPC)
          nCstart = Id.nSub ;
          nCend = nCstart + 1 ;
       }
+      else if ( nFaceUse == FACE_EDGES) {
+         nCstart = 0 ;
+         nCend = nCstart + 1 ;
+      }
      // ciclo sui chunk
       for ( int nC = nCstart ; nC < nCend ; ++ nC) {
         // recupero i contorni del chunk
@@ -1428,7 +1492,8 @@ Milling::GetCurves( SelData Id, ICURVEPLIST& lstPC)
            // la porto in globale
             pCrvCompo->ToGlob( frGlob) ;
            // sistemazioni varie
-            AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, vtFaceUse, dSawThick) ;
+            if ( ! AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, vtFaceUse, vnEdgesFaceUse, dSawThick))
+               return false ;
            // la restituisco
             lstPC.emplace_back( Release( pCrvCompo)) ;
          }
@@ -1834,13 +1899,13 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
       return false ;
   // eventuale imposizione massima elevazione da note utente
    double dMaxElev ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "MaxElev", dMaxElev)  &&  dElev > dMaxElev)
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev)  &&  dElev > dMaxElev)
       dElev = dMaxElev ;
   // eventuale aggiuntivo all'elevazione per l'oscillazione
    double dAddElev = ( bPathOscEnable ? abs( m_Params.m_dOscHeight) : 0) ;
   // eventuale elevazione di fianco (solo per lama)
    double dSideElev = 0 ;
-   GetValInNotes( m_Params.m_sUserNotes, "SideElev", dSideElev) ;
+   GetValInNotes( m_Params.m_sUserNotes, UN_SIDEELEV, dSideElev) ;
 
   // verifico che lo step dell'utensile sia sensato
    double dOkStep = 0 ;
@@ -1960,7 +2025,7 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
 
   // recupero eventuale flag di inizio forzato fuori dal grezzo
    int nStartOutRaw = 0 ;
-   GetValInNotes( m_Params.m_sUserNotes, "OutRaw", nStartOutRaw) ;
+   GetValInNotes( m_Params.m_sUserNotes, UN_OUTRAW, nStartOutRaw) ;
    m_bStartOutRaw = (( nStartOutRaw & 1) != 0) ;
    m_bEndOutRaw = (( nStartOutRaw & 2) != 0) ;
 
@@ -2841,11 +2906,11 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                      return false ;
                   Vector3d vtToolOrt = OrthoCompo( ptP1 - ptCurr, vtTool) ;
                   if ( vtToolOrt.Len() > 100 * EPS_SMALL) {
-                     if ( AddLinearMove( ptP1 - vtToolOrt, bSplitArcs) == GDB_ID_NULL)
+                     if ( AddLinearMove( ptP1 - vtToolOrt, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
                         return false ;
                   }
                  // movimento standard
-                  if ( AddLinearMove( ptP1, bSplitArcs) == GDB_ID_NULL)
+                  if ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
                      return false ;
                }
               // se attacco a zigzag o a spirale, non affondo
@@ -2857,7 +2922,7 @@ Milling::AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                else {
                   bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_POLISHING) ;
                   SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
-                  if ( ! SameAsCurrPos( ptP1)  &&  AddLinearMove( ptP1, bSplitArcs) == GDB_ID_NULL)
+                  if ( ! SameAsCurrPos( ptP1)  &&  AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
                      return false ;
                }
             }
@@ -3282,7 +3347,9 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                            dSawStartElev = dSawStartElev2 ;
                            bSideStart = true ;
                         }
-                     }               
+                     }  
+                     if ( bSideStart)
+                        bMidRetract = true ;
                      if ( ! bGeomAboveStart  &&  ! bAhUnderStart  &&  ! bUhAboveStart  &&  ! bSideStart  &&  bOk) {
                         m_pMchMgr->SetLastError( 2314, "Error in Milling : LeadIn must be out of rawpart") ;
                         bOk = false ;
@@ -3473,6 +3540,8 @@ Milling::AddOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool
                            bSideEnd = true ;
                         }
                      }
+                     if ( bSideEnd)
+                        bMidRetract = true ;
                      if ( ! bGeomAboveEnd  &&  ! bAhUnderEnd  &&  ! bUhAboveEnd  &&  ! bSideEnd  &&  bOk) {
                         m_pMchMgr->SetLastError( 2324, "Error in Milling : LeadOut must be out of rawpart") ;
                         bOk = false ;
@@ -3936,7 +4005,7 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT
   // recupero eventuale superficie trimesh chiusa per trim/extend
    int nTriExtCstm = GDB_ID_NULL ;
    int nTesId ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "TrimExt", nTesId)) {
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_TRIMEXT, nTesId)) {
       const ISurfTriMesh* pTes = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nTesId)) ;
       if ( pTes != nullptr  &&  pTes->IsClosed())
          nTriExtCstm = nTesId ;
@@ -4034,7 +4103,7 @@ Milling::AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtT
             else {
                bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_NOTIP  ||  m_TParams.m_nType == TT_MILL_POLISHING) ;
                SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
-               if ( AddLinearMove( ptP1, bSplitArcs) == GDB_ID_NULL)
+               if ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
                   return false ;
             }
            // aggiungo attacco
@@ -4112,7 +4181,7 @@ Milling::AddSawOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtT
   // recupero eventuale superficie trimesh chiusa per trim/extend
    int nTriExtCstm = GDB_ID_NULL ;
    int nTesId ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "TrimExt", nTesId)) {
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_TRIMEXT, nTesId)) {
       const ISurfTriMesh* pTes = GetSurfTriMesh( m_pGeomDB->GetGeoObj( nTesId)) ;
       if ( pTes != nullptr  &&  pTes->IsClosed())
          nTriExtCstm = nTesId ;
@@ -4213,7 +4282,7 @@ Milling::AddSawOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtT
             else {
                bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_NOTIP  ||  m_TParams.m_nType == TT_MILL_POLISHING) ;
                SetFeed( bReturn ? GetEndFeed() : ( bStartFeed ? GetStartFeed() : GetTipFeed())) ;
-               if ( AddLinearMove( ptP1, bSplitArcs) == GDB_ID_NULL)
+               if ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
                   return false ;
             }
            // aggiungo attacco
@@ -4381,7 +4450,7 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
       SetFlag( 0) ;
       bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_NOTIP  ||  m_TParams.m_nType == TT_MILL_POLISHING) ;
       SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
-      if ( ! AreSamePointApprox( ptP1, ptP)  &&  AddLinearMove( ptP, bSplitArcs) == GDB_ID_NULL)
+      if ( ! AreSamePointApprox( ptP1, ptP)  &&  AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
          return false ;
    }
   // sono sopra il pezzo ma non abbastanza
@@ -4394,7 +4463,7 @@ Milling::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
       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, bSplitArcs) == GDB_ID_NULL)
+      if ( AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
          return false ;
    }
   // altrimenti
@@ -4498,7 +4567,7 @@ Milling::AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, co
    }
   // affondo al punto iniziale in feed
    SetFeed( GetStartFeed()) ;
-   if ( AddLinearMove( ptP, bSplitArcs) == GDB_ID_NULL)
+   if ( AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
       return false ;
 
    return true ;
@@ -4511,7 +4580,7 @@ Milling::AddDirectApproach( const Point3d& ptP, bool bSplitArcs)
   // affondo diretto al punto iniziale
    SetFlag( 0) ;
    SetFeed( GetStartFeed()) ;
-   if ( AddLinearMove( ptP, bSplitArcs) == GDB_ID_NULL)
+   if ( AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
       return false ;
    return true ;
 }
@@ -4545,7 +4614,7 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
         // 4 -> movimento di risalita sopra il punto finale
          SetFeed( GetEndFeed()) ;
          Point3d ptP4 = ptP + vtAppr * ( dElev + dAppr) ;
-         if ( AddLinearMove( ptP4, bSplitArcs) == GDB_ID_NULL)
+         if ( AddLinearMove( ptP4, bSplitArcs, MCH_CL_SAFEOUT) == GDB_ID_NULL)
             return false ;
       }
       else {
@@ -4553,7 +4622,7 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
          Point3d ptP4a = ptP + vtAppr * ( dElev + dAppr) ;
          if ( dElev + dAppr > EPS_SMALL) {
             SetFeed( GetEndFeed()) ;
-            if ( AddLinearMove( ptP4a, bSplitArcs) == GDB_ID_NULL)
+            if ( AddLinearMove( ptP4a, bSplitArcs, MCH_CL_SAFEOUT) == GDB_ID_NULL)
                return false ;
          }
         // 4b -> movimento di risalita sopra il punto finale
@@ -4568,7 +4637,7 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
         // 4 -> movimento di risalita sopra il punto finale
          SetFeed( GetEndFeed()) ;
          Point3d ptP4 = ptP + Z_AX * ( min( dElevZ, 0.) + dAppr) ;
-         if ( AddLinearMove( ptP4, bSplitArcs) == GDB_ID_NULL)
+         if ( AddLinearMove( ptP4, bSplitArcs, MCH_CL_SAFEOUT) == GDB_ID_NULL)
             return false ;
       }
       else {
@@ -4576,7 +4645,7 @@ Milling::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ,
          Point3d ptP4a = ptP + Z_AX * ( min( dElevZ, 0.) + dAppr) ;
          if ( dElev + dAppr > EPS_SMALL) {
             SetFeed( GetEndFeed()) ;
-            if ( AddLinearMove( ptP4a, bSplitArcs) == GDB_ID_NULL)
+            if ( AddLinearMove( ptP4a, bSplitArcs, MCH_CL_SAFEOUT) == GDB_ID_NULL)
                return false ;
          }
         // 4b -> movimento di risalita sopra il punto finale
@@ -4624,7 +4693,7 @@ Milling::AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, con
    if ( dSawEndElev + dAppr > 10 * EPS_SMALL) {
       SetFeed( GetEndFeed()) ;
       ptP4 = ptP + vtRetr * ( dSawEndElev + dAppr) ;
-      if ( AddLinearMove( ptP4) == GDB_ID_NULL)
+      if ( AddLinearMove( ptP4, MCH_CL_SAFEOUT) == GDB_ID_NULL)
          return false ;
    }
   // se sopra uscita c'è spazio per sicurezza
@@ -4710,7 +4779,9 @@ Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const
    int nType = GetLeadInType() ;
    double dTang = m_Params.m_dLiTang ;
    double dPerp = m_Params.m_dLiPerp ;
-   double dElev = min( m_Params.m_dLiElev, dStElev + GetLeadInOutToler()) ;
+   double dElev = m_Params.m_dLiElev ;
+   if ( m_TParams.m_nType != TT_MILL_POLISHING)
+      dElev = min( m_Params.m_dLiElev, dStElev + GetLeadInOutToler()) ;
   // se step invertito
    if ( bInvert) {
      // va aggiustato se non zigzag o spirale
@@ -4726,7 +4797,9 @@ Milling::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const
          if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) {
             dTang = m_Params.m_dLoTang ;
             dPerp = m_Params.m_dLoPerp ;
-            dElev = min( m_Params.m_dLoElev, dStElev + GetLeadInOutToler()) ;
+            dElev = m_Params.m_dLoElev ;
+            if ( m_TParams.m_nType != TT_MILL_POLISHING)
+               dElev = min( m_Params.m_dLoElev, dStElev + GetLeadInOutToler()) ;
          }
       }
    }
@@ -4832,7 +4905,9 @@ Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d&
    int nType = GetLeadInType() ;
    double dTang = m_Params.m_dLiTang ;
    double dPerp = m_Params.m_dLiPerp ;
-   double dElev = min( m_Params.m_dLiElev, dStElev + GetLeadInOutToler()) ;
+   double dElev = m_Params.m_dLiElev ;
+   if ( m_TParams.m_nType != TT_MILL_POLISHING)
+      dElev = min( m_Params.m_dLiElev, dStElev + GetLeadInOutToler()) ;
   // se step invertito
    if ( bInvert) {
      // va aggiustato se non zigzag o spirale
@@ -4848,7 +4923,9 @@ Milling::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d&
          if ( m_Params.m_nLeadOutType != MILL_LO_AS_LI) {
             dTang = m_Params.m_dLoTang ;
             dPerp = m_Params.m_dLoPerp ;
-            dElev = min( m_Params.m_dLoElev, dStElev + GetLeadInOutToler()) ;
+            dElev = m_Params.m_dLoElev ;
+            if ( m_TParams.m_nType != TT_MILL_POLISHING)
+               dElev = min( m_Params.m_dLoElev, dStElev + GetLeadInOutToler()) ;
          }
       }
    }
@@ -5070,7 +5147,9 @@ Milling::CalcLeadOutEnd( const Point3d& ptEnd, const Vector3d& vtEnd, const Vect
    int nType = GetLeadOutType() ;
    double dTang = m_Params.m_dLoTang ;
    double dPerp = m_Params.m_dLoPerp ;
-   double dElev = min( m_Params.m_dLoElev, dEndElev + GetLeadInOutToler()) ;
+   double dElev = m_Params.m_dLoElev ;
+   if ( m_TParams.m_nType != TT_MILL_POLISHING)
+      dElev = min( m_Params.m_dLoElev, dEndElev + GetLeadInOutToler()) ;
   // se uscita come ingresso o step invertito
    if ( nType == MILL_LO_AS_LI  ||  bInvert) {
       int nLiType = GetLeadInType() ;
@@ -5089,7 +5168,9 @@ Milling::CalcLeadOutEnd( const Point3d& ptEnd, const Vector3d& vtEnd, const Vect
          dTang = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
          dPerp = dTang ;
       }
-      dElev = min( m_Params.m_dLiElev, dEndElev + GetLeadInOutToler()) ;
+     dElev = m_Params.m_dLiElev ;
+     if ( m_TParams.m_nType != TT_MILL_POLISHING)
+        dElev = min( m_Params.m_dLiElev, dEndElev + GetLeadInOutToler()) ;
    }
   // senso di rotazione da dir tg a dir esterna
    bool bCcwRot = (( ! bInvert  &&  m_Params.m_nWorkSide == MILL_WS_LEFT)  ||
@@ -5201,7 +5282,9 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d
    int nType = GetLeadOutType() ;
    double dTang = m_Params.m_dLoTang ;
    double dPerp = m_Params.m_dLoPerp ;
-   double dElev = min( m_Params.m_dLoElev, dEndElev + GetLeadInOutToler()) ;
+   double dElev = m_Params.m_dLoElev ;
+   if ( m_TParams.m_nType != TT_MILL_POLISHING)
+      dElev = min( m_Params.m_dLoElev, dEndElev + GetLeadInOutToler()) ;
   // se uscita come ingresso o step invertito
    if ( nType == MILL_LO_AS_LI  ||  bInvert) {
       int nLiType = GetLeadInType() ;
@@ -5220,7 +5303,9 @@ Milling::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d
          dTang = 0.5 * min( m_Params.m_dLiTang, m_TParams.m_dDiam) ;
          dPerp = dTang ;
       }
-      dElev = min( m_Params.m_dLiElev, dEndElev + GetLeadInOutToler()) ;
+      dElev = m_Params.m_dLiElev ;
+      if ( m_TParams.m_nType != TT_MILL_POLISHING)
+         dElev = min( m_Params.m_dLiElev, dEndElev + GetLeadInOutToler()) ;
    }
   // senso di rotazione da dir tg a dir esterna
    bool bCcwRot = (( ! bInvert  &&  m_Params.m_nWorkSide == MILL_WS_LEFT)  ||
@@ -6543,6 +6628,46 @@ Milling::CalcOffset( ICurveComposite* pCompo, double dSignOffs) const
             pCompo->ArcsBezierCurvesToArcsPerpExtr( LIN_TOL_MID, ANG_TOL_STD_DEG) ;
             return true ;
          }
+         else {
+            Point3d ptOffs ;
+            Vector3d vtOut ;
+            if ( OffsCrv.GetPointOffset( ptOffs, vtOut)) {
+               const double MIN_MOVE = 1 ;
+               Vector3d vtStart = vtOut ;
+               double dStaLen = 10 ;
+               Point3d ptStart ;
+               if ( pCompo->GetStartPoint( ptStart)) {
+                  Vector3d vtTmp = ptOffs - ptStart ;
+                  if ( vtTmp.Normalize()) {
+                     double dCosA = abs( vtTmp * vtOut) ;
+                     dStaLen = max( m_TParams.m_dDiam / 2 * sqrt( ( 1 - dCosA) / ( 1 + dCosA)), MIN_MOVE) ;
+                     vtTmp.Rotate( vtExtr, 0, 1) ;
+                     if ( vtTmp * vtOut < 0)
+                        vtTmp.Invert() ;
+                     vtStart = vtTmp ;
+                  }
+               }
+               Vector3d vtEnd = vtOut ;
+               double dEndLen = 10 ;
+               Point3d ptEnd ;
+               if ( pCompo->GetEndPoint( ptEnd)) {
+                  Vector3d vtTmp = ptOffs - ptEnd ;
+                  if ( vtTmp.Normalize()) {
+                     double dCosA = abs( vtTmp * vtOut) ;
+                     dEndLen = max( m_TParams.m_dDiam / 2 * sqrt( ( 1 - dCosA) / ( 1 + dCosA)), MIN_MOVE) ;
+                     vtTmp.Rotate( vtExtr, 0, 1) ;
+                     if ( vtTmp * vtOut < 0)
+                        vtTmp.Invert() ;
+                     vtEnd = vtTmp ;
+                  }
+               }
+               pCompo->Clear() ;
+               pCompo->AddPoint( ptOffs) ;
+               pCompo->AddLine( ptOffs + dStaLen * vtStart, false) ;
+               pCompo->AddLine( ptOffs + dEndLen * vtEnd) ;
+               return true ;
+            }
+         }
       }
    }
    return false ;

Milling.h

@@ -37,8 +37,14 @@ class Milling : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_MILLING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nMills == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nMills == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -62,7 +68,7 @@ class Milling : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 

Mortising.cpp

@@ -17,6 +17,7 @@
 #include "DllMain.h"
 #include "Mortising.h"
 #include "OperationConst.h"
+#include "OperUserNotesConst.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
@@ -45,6 +46,7 @@ using namespace std ;
 // 2511 = "Error in Mortising : post apply not calculable"
 // 2512 = "Error in Mortising : Tool MaxMaterial too small (xx)"
 // 2513 = "Error in Mortising : Closed path not allowed"
+// 2514 = "Error in Mortising : special apply not calculable"
 // 2551 = "Warning in Mortising : Skipped entity (xx)"
 // 2552 = "Warning in Mortising : Plunges not found"
 // 2553 = "Warning in Mortising : Tool name changed (xx)"
@@ -273,7 +275,7 @@ Mortising::SetParam( int nType, int nVal)
       if ( ! m_Params.VerifyFaceUse( nVal))
          return false ;
       if ( nVal != m_Params.m_nFaceUse)
-         m_nStatus |= MCH_ST_PARAM_MODIF ;
+         m_nStatus |= ( MCH_ST_PARAM_MODIF | MCH_ST_GEO_MODIF) ;
       m_Params.m_nFaceUse = nVal ;
       return true ;
    }
@@ -414,15 +416,16 @@ Mortising::SetParam( int nType, const string& sVal)
 bool
 Mortising::SetGeometry( const SELVECTOR& vIds)
 {
-  // verifico validità gestore DB geometrico
+  // verifico validità gestore DB geometrico
    if ( m_pGeomDB == nullptr)
       return false ;
-  // reset della geometria corrente
+  // copia temporanea e reset della geometria corrente
+   SELVECTOR vOldId = m_vId ;
    m_vId.clear() ;
-  // verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve o tutte facce)
+  // verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve o tutte facce)
    int nType = GEO_NONE ;
    for ( const auto& Id : vIds) {
-     // test sull'entità
+     // test sull'entità
       int nSubs ;
       if ( ! VerifyGeometry( Id, nSubs, nType)) {
          string sInfo = "Warning in Mortising : Skipped entity " + ToString( Id) ;
@@ -433,7 +436,8 @@ Mortising::SetGeometry( const SELVECTOR& vIds)
       m_vId.emplace_back( Id) ;
    }
   // aggiorno lo stato
-   m_nStatus |= MCH_ST_GEO_MODIF ;
+   if ( m_vId != vOldId)
+      m_nStatus |= MCH_ST_GEO_MODIF ;
   // restituisco presenza geometria da lavorare
    return ( ! m_vId.empty()  ||  vIds.empty()) ;
 }
@@ -445,14 +449,14 @@ Mortising::Preview( bool bRecalc)
   // reset numero percorsi di lavoro generati
    m_nMortises = 0 ;
 
-  // verifico validità gestore DB geometrico e Id del gruppo
+  // verifico validità gestore DB geometrico e Id del gruppo
    if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
       return false ;
 
   // recupero gruppo per geometria ausiliaria
    int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ;
    bool bChain = false ;
-  // se non c'è, lo aggiungo
+  // se non c'è, lo aggiungo
    if ( nAuxId == GDB_ID_NULL) {
       nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
       if ( nAuxId == GDB_ID_NULL)
@@ -480,7 +484,7 @@ Mortising::Preview( bool bRecalc)
    }
   // recupero gruppo per geometria di Preview
    int nPvId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_PV) ;
-  // se non c'è, lo aggiungo
+  // se non c'è, lo aggiungo
    if ( nPvId == GDB_ID_NULL) {
       nPvId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
       if ( nPvId == GDB_ID_NULL)
@@ -510,20 +514,22 @@ Mortising::Apply( bool bRecalc, bool bPostApply)
    int nCurrMortises = m_nMortises ;
    m_nMortises = 0 ;
 
-  // verifico validità gestore DB geometrico e Id del gruppo
+  // verifico validità gestore DB geometrico e Id del gruppo
    if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
       return false ;
 
   // aggiorno dati geometrici dell'utensile
-   bool bToolChanged = true ;
-   if ( ! UpdateToolData( &bToolChanged)) {
+   if ( ! UpdateToolData()) {
       m_pMchMgr->SetLastError( 2501, "Error in Mortising : UpdateToolData failed") ;
       return false ;
    }
 
+  // se modificata geometria, necessario ricalcolo
+   if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
+      bRecalc = true ;
+
   // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ! bToolChanged  &&  
-        ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
+   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
      // confermo i percorsi di lavorazione
       m_nMortises = nCurrMortises ;
       string sLog = string( "Mortising apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
@@ -541,7 +547,7 @@ Mortising::Apply( bool bRecalc, bool bPostApply)
   // recupero gruppo per geometria ausiliaria
    int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ;
    bool bChain = false ;
-  // se non c'è, lo aggiungo
+  // se non c'è, lo aggiungo
    if ( nAuxId == GDB_ID_NULL) {
       nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
       if ( nAuxId == GDB_ID_NULL)
@@ -558,7 +564,7 @@ Mortising::Apply( bool bRecalc, bool bPostApply)
 
   // recupero gruppo per vista ausiliaria
    int nAuxViewId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUXVIEW) ;
-  // se non c'è, lo aggiungo
+  // se non c'è, lo aggiungo
    if ( nAuxViewId == GDB_ID_NULL) {
       nAuxViewId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
       if ( nAuxViewId == GDB_ID_NULL)
@@ -574,7 +580,7 @@ Mortising::Apply( bool bRecalc, bool bPostApply)
 
   // recupero gruppo per geometria di lavorazione (Cutter Location)
    int nClId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_CL) ;
-  // se non c'è, lo aggiungo
+  // se non c'è, lo aggiungo
    if ( nClId == GDB_ID_NULL) {
       nClId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
       if ( nClId == GDB_ID_NULL)
@@ -626,7 +632,7 @@ Mortising::Apply( bool bRecalc, bool bPostApply)
 bool
 Mortising::Update( bool bPostApply)
 {
-  // verifico validità gestore DB geometrico e Id del gruppo
+  // verifico validità gestore DB geometrico e Id del gruppo
    if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
       return false ;
 
@@ -636,7 +642,7 @@ Mortising::Update( bool bPostApply)
       return true ;
    }
 
-  // elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo) 
+  // elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo) 
    RemoveClimbRiseHome() ;
 
   // imposto eventuale asse bloccato da lavorazione
@@ -646,7 +652,7 @@ Mortising::Update( bool bPostApply)
    string sHint = ExtractHint( m_Params.m_sUserNotes) ;
    if ( ! m_Params.m_sInitAngs.empty())
       sHint = m_Params.m_sInitAngs ;
-   if ( ! CalculateAxesValues( sHint, true, true)) {
+   if ( ! CalculateAxesValues( sHint, true)) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
       if ( sInfo.empty())
          m_pMchMgr->SetLastError( 2507, "Error in Mortising : axes values not calculable") ;
@@ -655,6 +661,19 @@ Mortising::Update( bool bPostApply)
       return false ;
    }
 
+  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+   CalcAndSetAxesBBox() ;
+
+  // esecuzione eventuali personalizzazioni speciali
+   string sSpecErr ;
+   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
+      if ( ! IsEmptyOrSpaces( sSpecErr))
+         m_pMchMgr->SetLastError( 2514, sSpecErr) ;
+      else
+         m_pMchMgr->SetLastError( 2514, "Error in Mortising : special apply not calculable") ;
+      return false ;
+   }
+
   // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
    if ( ! AdjustStartEndMovements()) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
@@ -665,14 +684,11 @@ Mortising::Update( bool bPostApply)
       return false ;
    }
 
-  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
-   CalcAndSetAxesBBox() ;
-
-  // esecuzione eventuali personalizzazioni
-   string sErr ;
-   if ( bPostApply  &&  ! PostApply( sErr)) {
-      if ( ! IsEmptyOrSpaces( sErr))
-         m_pMchMgr->SetLastError( 2511, sErr) ;
+  // esecuzione eventuali personalizzazioni finali
+   string sPostErr ;
+   if ( bPostApply  &&  ! PostApply( sPostErr)) {
+      if ( ! IsEmptyOrSpaces( sPostErr))
+         m_pMchMgr->SetLastError( 2511, sPostErr) ;
       else
          m_pMchMgr->SetLastError( 2511, "Error in Mortising : post apply not calculable") ;
       return false ;
@@ -811,7 +827,7 @@ Mortising::GetToolData( void) const
 
 //----------------------------------------------------------------------------
 bool
-Mortising::UpdateToolData( bool* pbChanged)
+Mortising::UpdateToolData( void)
 {
   // recupero il gestore DB utensili della macchina corrente
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
@@ -862,9 +878,9 @@ Mortising::UpdateToolData( bool* pbChanged)
                       m_Params.m_sToolName + ")" ;
       m_pMchMgr->SetWarning( 2554, sInfo) ;
    }
-  // se definito parametro di ritorno, lo assegno
-   if ( pbChanged != nullptr)
-      *pbChanged = bChanged ;
+  // se modificato, aggiusto lo stato
+   if ( bChanged)
+      m_nStatus = MCH_ST_TO_VERIFY ;
    return true ;
 }
 
@@ -872,7 +888,7 @@ Mortising::UpdateToolData( bool* pbChanged)
 bool
 Mortising::GetGeometry( SELVECTOR& vIds) const
 {
-  // restituisco l'elenco delle entità
+  // restituisco l'elenco delle entità
    vIds = m_vId ;
    return true ;
 }
@@ -885,7 +901,7 @@ Mortising::VerifyGeometry( SelData Id, int& nSubs, int& nType)
    const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
    if ( pGObj == nullptr)
       return false ;
-  // se ammesse curve ed è tale
+  // se ammesse curve ed è tale
    if ( nType != GEO_SURF  &&  ( pGObj->GetType() & GEO_CURVE) != 0) {
       const ICurve* pCurve = nullptr ;
       // se direttamente la curva
@@ -907,7 +923,7 @@ Mortising::VerifyGeometry( SelData Id, int& nSubs, int& nType)
       }
       return ( pCurve != nullptr) ;
    }
-  // se altrimenti ammesse superfici trimesh ed è tale
+  // se altrimenti ammesse superfici trimesh ed è tale
    else if ( nType != GEO_CURVE  &&  ( pGObj->GetType() & GEO_SURF) != 0) {
       const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
       if ( pSurf == nullptr)
@@ -1022,7 +1038,7 @@ Mortising::GetCurve( SelData Id)
       else
          nToolDir = TOOL_PAR_SLANT ;
       int nFaceUse = ( m_Params.m_nFaceUse & 31) ;
-      AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, V_NULL, m_TParams.m_dThick, 2) ;
+      AdjustCurveFromSurf( pCrvCompo, nToolDir, nFaceUse, V_NULL, {}, m_TParams.m_dThick, 2) ;
      // la restituisco
       return Release( pCrvCompo) ;
    }
@@ -1042,7 +1058,7 @@ Mortising::Chain( int nGrpDestId)
    for ( const auto& Id : m_vId) {
      // prendo curva
       vpCrvs.emplace_back( GetCurve( Id)) ;
-     // ne verifico la validità
+     // ne verifico la validità
       if ( IsNull( vpCrvs.back())) {
          string sInfo = "Warning in Mortising : Skipped entity " + ToString( Id) ;
          m_pMchMgr->SetWarning( 2551, sInfo) ;
@@ -1161,7 +1177,7 @@ Mortising::ProcessPath( int nPathId, int nPvId, int nClId)
   // recupero gruppo per geometria temporanea
    const string GRP_TEMP = "Temp" ;
    int nTempId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, GRP_TEMP) ;
-  // se non c'è, lo aggiungo
+  // se non c'è, lo aggiungo
    if ( nTempId == GDB_ID_NULL) {
       nTempId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
       if ( nTempId == GDB_ID_NULL)
@@ -1225,7 +1241,7 @@ Mortising::ProcessPath( int nPathId, int nPvId, int nClId)
          m_pMchMgr->SetWarning( 2555, "Warning in Mortising : skipped Path too short") ;
          return true ;
       }
-     // se una sola entità circonferenza completa, la divido in due per poterla allungare
+     // se una sola entità circonferenza completa, la divido in due per poterla allungare
       if ( pCompo->GetCurveCount() == 1  &&  pCompo->IsClosed())
          pCompo->AddJoint( 0.5) ;
      // eventuali allungamenti
@@ -1325,7 +1341,7 @@ Mortising::ProcessPath( int nPathId, int nPvId, int nClId)
       return false ;
   // eventuale imposizione massima elevazione da note utente
    double dMaxElev ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "MaxElev", dMaxElev)  &&  dElev > dMaxElev)
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev)  &&  dElev > dMaxElev)
       dElev = dMaxElev ;
 
   // ingombro aggiuntivo da larghezza sega a catena quando inclinata rispetto al movimento
@@ -1336,10 +1352,10 @@ Mortising::ProcessPath( int nPathId, int nPvId, int nClId)
 
   // affondamento speciale da note utente (!!! da trasformare in parametro come gli altri !!!)
    int nPlunge = 0 ;
-   GetValInNotes( m_Params.m_sUserNotes, "Plunge", nPlunge) ;
+   GetValInNotes( m_Params.m_sUserNotes, UN_PLUNGE, nPlunge) ;
 
   // verifico che lo step dell'utensile sia sensato
-   double dOkStep = ( nPlunge == MORTISE_PLUNGE_STEP ? m_Params.m_dStep : 0) ;
+   double dOkStep = ( nPlunge == MORTISE_PLUNGE_STEP  ||  nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ ? m_Params.m_dStep : 0) ;
    const double MIN_ZSTEP = 1.0 ;
    if ( dOkStep >= EPS_SMALL  &&  dOkStep < MIN_ZSTEP) {
       dOkStep = MIN_ZSTEP ;
@@ -1357,7 +1373,7 @@ Mortising::ProcessPath( int nPathId, int nPvId, int nClId)
       return false ;
    }
 
-  // se lo step supera la capacità dell'utensile
+  // se lo step supera la capacità dell'utensile
    if ( dOkStep > m_TParams.m_dMaxMat + EPS_SMALL) {
       dOkStep = m_TParams.m_dMaxMat ;
       string sInfo = "Warning in Mortising : machining step (" + ToString( m_Params.m_dStep, 1) +
@@ -1505,7 +1521,7 @@ Mortising::GenerateMortisingCl( const ICurveComposite* pCompo, const Vector3d& v
    Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;
    Point3d ptEnd ; pCompo->GetEndPoint( ptEnd) ;
 
-  // verifico se affondamento ripetuto è veramente tale
+  // verifico se affondamento ripetuto è veramente tale
    if ( ( nPlunge == MORTISE_PLUNGE_START_END  ||  nPlunge == MORTISE_PLUNGE_START_TO_END)  &&  Dist( ptStart, ptEnd) < 10 * EPS_SMALL)
       nPlunge = MORTISE_PLUNGE_START ;
 
@@ -1529,7 +1545,7 @@ Mortising::GenerateMortisingCl( const ICurveComposite* pCompo, const Vector3d& v
       int kMax = ( int) floor( dLen / m_TParams.m_dDiam) ;
       for ( int k = 0 ; k <= kMax ; ++ k) {
          Point3d ptNewStart = ptStart + vtDir * k * m_TParams.m_dDiam ;
-        // se non è finale 
+        // se non è finale 
          if ( k != kMax  ||  ! AreSamePointEpsilon( ptNewStart, ptEnd, 10 * EPS_SMALL)) {
             if ( ! GenerateOnePlungeCl( ptNewStart, ptEnd, vtTool, dDepth, dElev, dOkStep, MORTISE_PLUNGE_START, k == 0))
                return false ;         
@@ -1561,8 +1577,17 @@ Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, co
 {
   // compensazione elevazione/affondamento
    double dDelta = dElev - dDepth ;
+  // pre-calcolo step per modalità con step
+   int nStep = 1 ;
+   double dStep = dElev ;
+   if ( nPlunge == MORTISE_PLUNGE_STEP  ||  nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ) {
+      if ( dOkStep < EPS_SMALL)
+         dOkStep = dElev ;
+      nStep = max( 1, static_cast<int>( ceil( ( dElev - 10 * EPS_SMALL) / dOkStep))) ;
+      dStep = dElev / nStep ;
+   }
 
-  // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
+  // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
    double dSafeZ = GetSafeZ() + GetDeltaSafeZ( vtTool) ;
    double dStartElev = 0 ;
    Point3d ptLi = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * dDelta ;
@@ -1572,17 +1597,26 @@ Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, co
    if ( ! bUnderStart)
       GetElevation( m_nPhase, ptLi, vtTool, GetRadiusForStartEndElevation(), vtTool, dStartElev) ;
 
+  // sicurezza su punto iniziale
+   double dAppr = dStartElev + dSafeZ ;
+   if ( nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ) {
+      double dStartDownElev ;
+      if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dStartDownElev))
+         dStartDownElev = dDelta ;
+      if ( dStartDownElev < EPS_SMALL)
+         dAppr = -dStep ;
+   }
+
   // 1 -> punto approccio
    int nFirstFlag = ( bFirst ? 1 : 0) ; 
    SetFlag( nFirstFlag) ;
-   Point3d ptP1 = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * ( dDelta + dStartElev + dSafeZ) ;
-   int nStart = AddRapidStartOrMove( ptP1, bFirst) ;
-   if ( nStart == GDB_ID_NULL)
+   Point3d ptP1 = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * ( dDelta + dAppr) ;
+   if ( AddRapidStartOrMove( ptP1, bFirst) == GDB_ID_NULL)
       return false ;
    SetFlag( 0) ;
 
   // 2 -> punto fuori (se diverso dal precedente)
-   if ( m_Params.m_dStartPos < dSafeZ - 10 * EPS_SMALL) {
+   if ( m_Params.m_dStartPos < dAppr - 10 * EPS_SMALL) {
       Point3d ptP2 = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * ( dDelta + m_Params.m_dStartPos) ;
       if ( AddRapidMove( ptP2) == GDB_ID_NULL)
          return false ;
@@ -1610,10 +1644,6 @@ Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, co
    }
    else {
      // determino numero e affondamento degli step
-      if ( dOkStep < EPS_SMALL)
-         dOkStep = dElev ;
-      int nStep = max( 1, static_cast<int>( ceil( ( dElev - 10 * EPS_SMALL) / dOkStep))) ;
-      double dStep = dElev / nStep ;
       const double RETURN_DIST = 10 ;
      // a seconda del tipo
       switch ( m_Params.m_nStepType) {
@@ -1623,7 +1653,7 @@ Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, co
             SetFeed( GetStartFeed()) ;
             SetFlag( 0) ;
             Point3d ptP3 = (( i % 2 == 1) ? ptStart : ptEnd) + ( dDelta - i * dStep) * vtTool ;
-            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
+            if ( AddLinearMove( ptP3) == GDB_ID_NULL  &&  ! ( i == 1  &&  nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ))
                return false ;
            // 4 -> punto termine
             SetFeed( GetFeed()) ;
@@ -1669,7 +1699,7 @@ Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, co
       }
    }
 
-  // determino se la fine dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
+  // determino se la fine dell'uscita è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
    double dEndElev = 0 ;
    Point3d ptLo = ptLast + vtTool * dDelta ;
    bool bUnderEnd = GetAhPointUnderRaw( ptLo, vtTool, 0,
@@ -1677,11 +1707,21 @@ Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, co
   // altrimenti ridetermino elevazione su fine percorso di lavoro
    if ( ! bUnderEnd)
       GetElevation( m_nPhase, ptLo, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev) ;
+
+  // sicurezza su punto finale
+   double dRetr = dEndElev + dSafeZ ;
+   if ( nPlunge == MORTISE_PLUNGE_STEP_NO_SAFEZ) {
+      double dEndDownElev ;
+      if ( ! GetElevation( m_nPhase, ptStart, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndDownElev))
+         dEndDownElev = dDelta ;
+      if ( dEndDownElev < EPS_SMALL)
+         dRetr = dEndElev - dStep ;
+   }
    
   // 6 -> ritorno all'approccio
    SetFeed( GetEndFeed()) ;
    SetFlag( 104) ;            // risalita sopra la fine
-   Point3d ptP6 = ptLast + vtTool * ( dDelta + dEndElev + dSafeZ) ;
+   Point3d ptP6 = ptLast + vtTool * ( dDelta + dRetr) ;
    if ( AddLinearMove( ptP6) == GDB_ID_NULL)
       return false ;
 

Mortising.h

@@ -36,8 +36,14 @@ class Mortising : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_MORTISING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nMortises == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nMortises == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -59,7 +65,7 @@ class Mortising : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 

OperUserNotesConst.h

@@ -0,0 +1,76 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2025-2025
+//----------------------------------------------------------------------------
+// File : OperUserNotesConst.h           Data : 10.11.25        Versione : 2.7k3
+// Contenuto : Costanti per le note utente delle operazioni.      
+//
+//
+//
+// Modifiche : 10.11.25 DS Creazione modulo.
+//
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include <string>
+
+//----------------------------------------------------------------------------
+// Generali
+static const std::string UN_MAXELEV = "MaxElev" ;
+static const std::string UN_TRIMEXT = "TrimExt" ;
+static const std::string UN_OPEN = "Open" ;
+static const std::string UN_LINTOL = "LinTol" ;
+static const std::string UN_DOUBLE = "DOUBLE" ;
+static const std::string UN_MIRRORAX = "MirrorAx" ;
+static const std::string UN_DELTAZ = "DeltaZ" ;
+
+// Solo per Drilling
+static const std::string UN_LASTSTEP = "LastStep" ;
+
+// Solo per FiveAxisMilling
+static const std::string UN_SINGCONEANG = "SingConeAng" ;
+
+// Solo per GenMachining
+static const std::string UN_VPL_COLON = "Vpl:" ;
+
+// Solo per Milling
+static const std::string UN_OUTRAW = "OutRaw" ;
+static const std::string UN_SIDEELEV = "SideElev" ;
+static const std::string UN_VTFACEUSE = "VtFaceUse" ;
+static const std::string UN_EDGESFACEUSE = "EdgesFaceUse" ;
+
+// Solo per Mortising
+static const std::string UN_PLUNGE = "Plunge" ;
+
+// Solo per Pocketing o PocketingNT
+static const std::string UN_OPENOUTRAW = "OpenOutRaw" ;
+static const std::string UN_OPENMINSAFE = "OpenMinSafe" ;
+static const std::string UN_MAXOPTSIZE = "MaxOptSize" ;
+static const std::string UN_PROJEXT = "ExtProj" ;
+static const std::string UN_ADJUSTFEED = "AdjustFeed" ;
+
+// Solo per Sawing
+static const std::string UN_DOWNSE = "DownSE" ;
+static const std::string UN_FSTA = "Fsta" ;
+static const std::string UN_FEND = "Fend" ;
+static const std::string UN_SWE = "SWE" ;
+static const std::string UN_EWE = "EWE" ;
+
+// Solo per SurfFinishing
+static const std::string UN_SKIPMAXDOWN = "SkipMaxDown" ;
+static const std::string UN_SPLITANGLE = "SplitAngle" ;
+static const std::string UN_TYPE = "Type" ;
+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" ;
+
+// Solo per SurfRoughing
+static const std::string UN_PLANEZ = "PlaneZ" ;
+static const std::string UN_ORDER = "Order" ;
+static const std::string UN_SUPP_RAD_OFFS = "SuppRadOffs" ;
+
+// Solo per Waterjetting
+static const std::string UN_START = "START" ;

Operation.h

@@ -1,14 +1,14 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2016-2019
+//  EgalTech 2016-2025
 //----------------------------------------------------------------------------
-// File : Operation.h         Data : 17.06.19          Versione : 2.1f2
+// File : Operation.h         Data : 09.05.25          Versione : 2.7e2
 // Contenuto : Dichiarazione della classe Operation da cui derivano
 //             Disposition e Machining.
 //
 //
 //
 // Modifiche : 29.04.16 DS Creazione modulo.
-//
+//             09.05.25 DS Generalizzazionee funzione IsEmpty con tipo (EMPTY_*).
 //
 //----------------------------------------------------------------------------
 
@@ -30,6 +30,8 @@ class ICurveComposite ;
 //----------------------------------------------------------------------------
 class Operation : public IUserObj
 {
+   friend class Machine ;
+
    public :                           // IUserObj
       bool SetOwner( int nId, IGeomDB* pGDB) override ;
       int  GetOwner( void) const override ;
@@ -48,9 +50,13 @@ class Operation : public IUserObj
 
    public :
       virtual int  GetType( void) const = 0 ;
-      virtual bool IsEmpty( void) const = 0 ;
+      virtual bool IsEmpty( int nEmptyType = 0) const = 0 ;
       virtual bool UpdateStatus( int nModif) = 0 ;
 
+   public :
+      bool   GetInitialAxesValues( bool bSkipClimb, DBLVECTOR& vAxVal) const ;
+      bool   GetFinalAxesValues( bool bSkipRise, DBLVECTOR& vAxVal) const ;
+
    protected :
       virtual const std::string& GetToolName( void) const = 0 ;
       virtual const std::string& GetHeadName( void) const = 0 ;
@@ -115,18 +121,13 @@ class Operation : public IUserObj
       Operation( void) ;
 
    protected :
-      struct Position {
-         int         nSide ;
-         DBLVECTOR   vAxis ;
-         int         nFlag ;
-         int         nFlag2 ;
-         int         nMask ;
-         std::string sInfo ;
-         Position() : nSide( 0), nFlag( 0), nFlag2( 0), nMask( -1) {}
-      } ;
-      typedef std::vector<Position> POSVECTOR ;
-
-   protected :
+      bool   IsAtLeastOnePathOk( void) const ;
+      bool   AreAllPathsOk( void) const ;
+      bool   GetToolpathsStatus( int& nCnt, int& nEmpty) const ;
+      int    GetFirstFullToolpath( bool bMain = true) const ;
+      int    GetNextFullToolpath( int nClPathId) const ;
+      int    GetLastFullToolpath( bool bMain = true) const ;
+      int    GetPrevFullToolpath( int nClPathId) const ;
       bool   UpdateFollowingOperationsStatus( int nModif) ;
       bool   GetElevation( int nPhase, const Point3d& ptP,
                            const Vector3d& vtDir, double& dElev) const ;
@@ -168,7 +169,7 @@ class Operation : public IUserObj
       bool   GetCurrRawsGlobBox( BBox3d& b3Raw) const ;
 
       bool   AdjustCurveFromSurf( ICurveComposite* pCrvCompo, int nToolDir, int nFaceUse, const Vector3d& vtFaceUse,
-                                  double dToolThick, int nGrade = 3) ;
+                                  const INTVECTOR& vnEdgesFaceUse, double dToolThick, int nGrade = 3) ;
       bool   ApproxWithArcsIfUseful( ICurveComposite* pCompo, bool bCareTempProp = false) const ;
       bool   ApproxWithLines( ICurveComposite* pCompo, bool bFeed = true) const ;
       bool   VerifyArcs( ICurveComposite* pCompo, double dMaxAngCen = MAX_ANG_CEN) const ;
@@ -176,11 +177,32 @@ class Operation : public IUserObj
       bool   CalcAndSetBBox( int nClId) ;
       bool   CalcAndSetAxesBBox( void) ;
 
-      bool   CalcMirrorByDouble( int nClId, const std::string& sUserNotes) ;
+      std::string ExtractInfo( const std::string& sNotes, const std::string& sKey) const ;
+      std::string ExtractHint( const std::string& sNotes) const ;
+      bool   SetBlockedRotAxis( const std::string& sBlockedAxis, bool bToolSetOk = false) const ;
+      bool   CalculateAxesValues( const std::string& sHint, bool bSolChExact = false, double dSingConeAng = 0) ;
+      bool   CalculateDoubleAxesValues( const std::string& sHint, bool bSolChExact = false, double dSingConeAng = 0) ;
+      bool   AdjustStartEndMovements( bool bVerifyPreviousLink = true) ;
+      bool   RemoveClimbRiseHome( bool bMain = true) ;
+      double GetDeltaSafeZ( const Vector3d& vtTool) const ;
+      bool   TestCollisionAvoid( const DBLVECTOR& vAxStart, double dStartOffsX, const DBLVECTOR& vAxEnd, int* pnLKAMO = nullptr) const ;
+      bool   GetAggrBottomData( const std::string& sHead, AggrBottom& agbData) const ;
+      bool   IsAggrBottom( const std::string& sHead) const ;
 
-      bool   GetInitialAxesValues( bool bSkipClimb, DBLVECTOR& vAxVal) const ;
+   private :
+      struct Position {
+         int         nSide ;
+         DBLVECTOR   vAxis ;
+         int         nFlag ;
+         int         nFlag2 ;
+         int         nMask ;
+         std::string sInfo ;
+         Position() : nSide( 0), nFlag( 0), nFlag2( 0), nMask( -1) {}
+      } ;
+      typedef std::vector<Position> POSVECTOR ;
+
+   private :
       bool   GetClPathInitialAxesValues( int nClPathId, bool bSkipClimb, DBLVECTOR& vAxVal) const ;
-      bool   GetFinalAxesValues( bool bSkipRise, DBLVECTOR& vAxVal) const ;
       bool   GetClPathFinalAxesValues( int nClPathId, bool bSkipRise, DBLVECTOR& vAxVal) const ;
       bool   GetInitialToolDir( bool bSkipClimb, Vector3d& vtTool) const ;
       bool   GetClPathInitialToolDir( int nClPathId, bool bSkipClimb, Vector3d& vtTool) const ;
@@ -190,38 +212,43 @@ class Operation : public IUserObj
       const CamData* GetClPathInitialCamData( int nClPathId, bool bSkipClimb) const ;
       const CamData* GetFinalCamData( bool bSkipRise) const ;
       const CamData* GetClPathFinalCamData( int nClPathId, bool bSkipRise) const ;
-      std::string ExtractInfo( const std::string& sNotes, const std::string& sKey) const ;
-      std::string ExtractHint( const std::string& sNotes) const ;
-      bool   SetBlockedRotAxis( const std::string& sBlockedAxis) const ;
-      bool   CalculateAxesValues( const std::string& sHint, bool bRotContOnNext = true, bool bSolChExact = false) ;
-      bool   CalculateClPathCenterAxesValues( int nClPathId, int nLinAxes, int nRotAxes, double dRot1W,
-                                              bool bMaxDeltaR2OnFirst, bool bRotContOnNext, double dAngDeltaMinForHome,
-                                              const DBLVECTOR& vAxRotHome, DBLVECTOR& vAxRotPrec) ;
-      bool   CalculateClPathAxesValues( int nClPathId, int nLinAxes, int nRotAxes, double dRot1W,
-                                        bool bMaxDeltaR2OnFirst, bool bRotContOnNext, double dAngDeltaMinForHome,
-                                        const DBLVECTOR& vAxRotHome, DBLVECTOR& vAxRotPrec, int& nOutStrC) ;
-      bool   CalculateRotAxesValues( bool bFirst, const Vector3d& vtTool, const Vector3d& vtAux,
-                                     double dRot1W, bool bMaxDeltaR2OnFirst, bool bRotContOnNext, double dAngDeltaMinForHome,
-                                     const DBLVECTOR& vAxRotHome, const DBLVECTOR& vAxRotPrec, DBLVECTOR& vAxRot) ;
-      bool   VerifyLineMidPoint( const Point3d& ptPrec, const Vector3d& vtDirPrec, const Vector3d& vtAuxPrec, const Vector3d& vtCorrPrec, const DBLVECTOR& vAxPrec,
-                                 const Point3d& ptP, const Vector3d& vtDir, const Vector3d& vtAux, const Vector3d& vtCorr, const DBLVECTOR& vAxVal,
-                                 int nCnt, int nEntId, double dRot1W, int nMoveType, bool& bAdded, bool& bAxError) ;
-      bool   CalculateClPathRobotAxesValues( int nClPathId, int nLinAxes, int nRotAxes, double dRot1W,
-                                             bool bMaxDeltaR2OnFirst, bool bRotContOnNext, double dAngDeltaMinForHome,
-                                             const DBLVECTOR& vAxRotHome, DBLVECTOR& vAxRotPrec) ;
-      bool   AdjustStartEndMovements( bool bVerifyPreviousLink = true) ;
-      bool   ManageProtectedAreas( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, Operation* pPrevOp, Operation* pNextOp, bool& bClimbDone) ;
-      bool   AdjustOneStartEndMovement( int nClPathId, int nPrevClPathId, Operation* pPrevOp, const DBLVECTOR& vAxPrev, bool bMaxZ) ;
-      bool   ToolChangeNeeded( const Operation& Op1, const Operation& Op2) const ;
+      bool   ApplyHintToPrevAxRot( const std::string& sHint, const Machine* pMch, DBLVECTOR& vAxRotPrec) ;
+      bool   CalculateClPathMcentAxesValues( int nClPathId, double dAngDeltaMinForHome, const DBLVECTOR& vAxRotHome,
+                                             DBLVECTOR& vAxRotPrec) ;
+      bool   EraseAddedPoints( int nClPathId) ;
+      bool   MyCalculateClPathMcentAxesValues( int nClPathId, double dAngDeltaMinForHome, const DBLVECTOR& vAxRotHome,
+                                               DBLVECTOR& vAxRotPrec, bool bFirstTry, int& nOutStrC) ;
+      bool   CalculateMcentRotAxesValues( bool bFirst, const Vector3d& vtTool, const Vector3d& vtAux,
+                                          double dAngDeltaMinForHome, const DBLVECTOR& vAxRotHome, const DBLVECTOR& vAxRotPrec,
+                                          DBLVECTOR& vAxRot) ;
+      bool   VerifyMcentLineMidPoint( const Point3d& ptPrec, const Vector3d& vtDirPrec, const Vector3d& vtAuxPrec, const Vector3d& vtCorrPrec, const DBLVECTOR& vAxPrec,
+                                      const Point3d& ptP, const Vector3d& vtDir, const Vector3d& vtAux, const Vector3d& vtCorr, const DBLVECTOR& vAxVal,
+                                      int nCnt, int nEntId, int nMoveType, bool bToolShow, bool& bAdded, bool& bAxError) ;
+      bool   CalculateClPathRobotAxesValues( int nClPathId, double dAngDeltaMinForHome, const DBLVECTOR& vAxRotHome,
+                                             DBLVECTOR& vAxRotPrec) ;
+      bool   CalculateRobotAxesValues( bool bFirst, const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtAux,
+                                       double dAngDeltaMinForHome, const DBLVECTOR& vAxRotHome, const DBLVECTOR& vAxRotPrec,
+                                       DBLVECTOR& vAxRot) ;
+      bool   VerifyRobotLineMidPoint( const Point3d& ptPrec, const Vector3d& vtDirPrec, const Vector3d& vtAuxPrec, const Vector3d& vtCorrPrec, const DBLVECTOR& vAxPrec,
+                                      const Point3d& ptP, const Vector3d& vtDir, const Vector3d& vtAux, const Vector3d& vtCorr, const DBLVECTOR& vAxVal,
+                                      int nCnt, int nEntId, int nMoveType, bool bToolShow, bool& bAdded, bool& bAxError) ;
+      bool   GetAxisMidForTestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, int nAxisOrder, Machine* pMch,
+                                              DBLVECTOR& vAxMid) const ;
+      bool   OneMoveTestCollisionAvoid( const STRVECTOR& vAxName, const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd,
+                                        Machine* pMch, const INTVECTOR& vRawId, const INTVECTOR& vFxtId) const ;
+      bool   AdjustStartEndMovementsStd( bool bVerifyPreviousLink) ;
+      bool   AdjustOneStartEndMovement( int nClPathId, int nPrevClPathId, Operation* pPrevOpe, const DBLVECTOR& vAxPrev, double dPrevOffsX, bool bMaxZ) ;
+      bool   AdjustStartEndMovementsNew( void) ;
+      bool   ManageSpecialLink( Operation* pPrevOpe, int nPrevClPathId, Operation* pNextOpe, int nNextClPathId) ;
+      bool   ToolChangeNeeded( const Operation& Ope1, const Operation& Ope2) const ;
       bool   AddSpecialClimb( const DBLVECTOR& vAxVal, bool bOk = true, int nClPathId = GDB_ID_NULL,
-                              int nFlag = 0, int nFlag2 = 0, int nMask = -1, const std::string& sInfo = "") ;
-      bool   RemoveClimb( int nClPathId = GDB_ID_NULL) ;
+                              int nFlag = 0, int nFlag2 = 0, int nMask = -1, const std::string& sInfo = "", bool bFirst = true) ;
+      bool   RemoveClimb( int nClPathId = GDB_ID_NULL, bool bMain = true) ;
       bool   AddRise( DBLVECTOR& vAxVal, double dDelta = NAN, int nClPathId = GDB_ID_NULL, int nToMinMaxZ = 0) ;
       bool   AddSpecialRise( const DBLVECTOR& vAxVal, bool bOk = true, int nClPathId = GDB_ID_NULL,
                              int nFlag = 0, int nFlag2 = 0, int nMask = -1, const std::string& sInfo = "") ;
-      bool   RemoveRise( int nClPathId = GDB_ID_NULL) ;
+      bool   RemoveRise( int nClPathId = GDB_ID_NULL, bool bMain = true) ;
       bool   AddHome( void) ;
-      bool   RemoveClimbRiseHome( void) ;
       bool   AddRobotClimb( int nEntId, double dDeltaZ = NAN) ;
       bool   CalcRobotAxesAbovePos( const Point3d& ptP, const Vector3d& vtT, const Vector3d& vtA, double dDeltaZ,
                                     DBLVECTOR& vAx, double* pdNewDeltaZ = nullptr) const ;
@@ -235,22 +262,13 @@ class Operation : public IUserObj
       bool   GetRotationAtZmax( void) const ;
       bool   ForcedZmax( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, const BBox3d& b3Raws) const ;
       int    GetUserNotesZmax( void) const ;
-      double GetDeltaSafeZ( const Vector3d& vtTool) const ;
       bool   GetZHomeDown( void) const ;
-      bool   TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd) const ;
       int    SpecialTestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd) const ;
       bool   SpecialMoveZup( DBLVECTOR& vAx, Vector3d& vtTool, int& nFlag, int& nFlag2, bool& bModif) ;
-      bool   SpecialMoveRapid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, int nOutstroke, int nLinkType,
-                               POSVECTOR& vNewPos) ;
-
-      bool   GetAggrBottomData( const std::string& sHead, AggrBottom& agbData) const ;
-      bool   IsAggrBottom( const std::string& sHead) const ;
-
-   private :
-      bool   GetAxisMidForTestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, int nAxisOrder, Machine* pMch,
-                                              DBLVECTOR& vAxMid) const ;
-      bool   OneMoveTestCollisionAvoid( const STRVECTOR& vAxName, const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd,
-                                        Machine* pMch, const INTVECTOR& vRawId, const INTVECTOR& vFxtId) const ;
+      bool   SpecialMoveRapid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, DBLVECTOR& vAxNew, bool& bModif) ;
+      bool   SpecialLink( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, int nLinkType,
+                          const Operation* pPrevOpe, const Operation* pNextOpe) ;
+      bool   SpecialPrevMachiningOffset( const Operation* pPrevOpe, double& dOffsetX) ;
 
    protected :
       int      m_nOwnerId ;       // identificativo dell'oggetto geometrico possessore
@@ -323,11 +341,15 @@ inline Operation* GetOperation( IUserObj* pUserObj)
                { return dynamic_cast< Operation*>( pUserObj) ; }
 
 //----------------------------------------------------------------------------
+// Tipo di controllo per lavorazione vuota
+enum { NEED_GEOM = 0, NEED_ONE_TP_OK = 1, NEED_ALL_TP_OK = 2} ;
 // tipo posizione utensile 
 enum { TOOL_PARAL = 1, TOOL_ORTHO = 2, TOOL_ORTUP = 3, TOOL_PAR_SLANT= 4} ;
 // tipo di utilizzo contorno faccia
-enum { FACE_DOWN = 1, FACE_TOP = 2, FACE_FRONT = 3, FACE_BACK = 4, FACE_LEFT = 5, FACE_RIGHT = 6, FACE_CONT = 7, FACE_VERSOR = 8} ;
+enum { FACE_DOWN = 1, FACE_TOP = 2, FACE_FRONT = 3, FACE_BACK = 4, FACE_LEFT = 5, FACE_RIGHT = 6,
+       FACE_CONT = 7, FACE_VERSOR = 8, FACE_EDGES = 9} ;
 // risultato di SpecialTestCollisionAvoid 
 enum { SCAV_ERROR = -1, SCAV_COLLIDE = 0, SCAV_AVOID = 1, SCAV_TOTEST = 2} ;
 // ordine di movimento assi nei link
-enum { LKAO_INTERP = 0, LKAO_HEAD_BEFORE = -1, LKAO_HEAD_AFTER = +1, LKAO_HEAD_BOTH = 11} ;
+enum { LKAMO_INTERP = 0, LKAMO_HEAD_BEFORE = -1, LKAMO_HEAD_AFTER = +1,
+       LKAMO_HEAD_BEFORE_IF_SAME_ANG = -2, LKAMO_HEAD_AFTER_IF_SAME_ANG = +2} ;

OperationCL.cpp

@@ -323,7 +323,7 @@ Operation::AddLinearMove( const Point3d& ptP, bool bSplit)
       return GDB_ID_NULL ;
    double dLen = Dist( ptS, ptP) ;
    double dStep = GetMaxSplitLen( true, true) ;
-   int nStep = int( dLen / dStep + 0.999) ;
+   int nStep = int( ceil( ( dLen - EPS_ZERO) / dStep)) ;
    int nFirstId = GDB_ID_NULL ;
    for ( int i = 1 ; i <= nStep ; ++ i) {
       int nId = AddLinearMove( Media( ptS, ptP, i * 1.0 / nStep)) ;

OperationConst.h

@@ -18,8 +18,6 @@
 #include "/EgtDev/Include/EMkOperationConst.h"
 #include <string>
 
-#define POCKETING_NT 0
-
 //----------------------------------------------------------------------------
 static const std::string s_OpeClass[] = {"",
                                          "EMkDisposition",
@@ -35,7 +33,8 @@ static const std::string s_OpeClass[] = {"",
                                          "EMkSurfRoughing",
                                          "EMkSurfFinishing",
                                          "EMkWaterJetting",
-                                         "EMkFiveAxisMilling"} ;
+                                         "EMkFiveAxisMilling",
+                                         "EMkProbing"} ;
 
 //----------------------------------------------------------------------------
 // Dal tipo numerico restituisce la classe della operazione
@@ -57,6 +56,7 @@ GetOperationClass( int nOpeType)
    case OPER_SURFFINISHING : return s_OpeClass[12] ;
    case OPER_WATERJETTING : return s_OpeClass[13] ;
    case OPER_FIVEAXISMILLING : return s_OpeClass[14] ;
+   case OPER_PROBING : return s_OpeClass[15] ;
    }
    return s_OpeClass[0] ;
 }
@@ -94,6 +94,8 @@ GetOperationType( const std::string& sOpeClass)
       return OPER_WATERJETTING ;
    else if ( sOpeClass == s_OpeClass[14])
       return OPER_FIVEAXISMILLING ;
+   else if ( sOpeClass == s_OpeClass[15])
+      return OPER_PROBING ;
    else
       return OPER_NULL ;
 }

OutputConst.h

@@ -191,6 +191,7 @@ static const std::string GVAR_SIMUISTAT = ".SIMUISTAT" ; // (num)      stato sim
 static const std::string GVAR_SAFEDIST = ".SAFEDIST" ;   // (num)      distanza di sicurezza per verifica di collisione
 static const std::string GVAR_SIMVMID = ".SIMVMID" ;     // (int)      identificativo grezzo Vmill in collisione
 static const std::string GVAR_SIMCOBIND = ".SIMCOBIND" ; // (int)      indice oggetto in collisione
+static const std::string GVAR_TOOLTRACE = ".TOOLTRACE" ; // (int)      identificativo gruppo di tracciatura utensile
 static const std::string GVAR_MPSIM = ".MPSIM" ;         // (bool)     flag simulazione multiprocesso
 static const std::string GVAR_MPSEST = ".MPSEST" ;       // (string)   path del file di stima speciale per simulazione multiprocesso
 static const std::string GVAR_RECORD = ".RECORD" ;       // (bool)     flag modalità registrazione comandi in simulazione

Pocketing.cpp

@@ -18,6 +18,7 @@
 #include "DllMain.h"
 #include "Pocketing.h"
 #include "OperationConst.h"
+#include "OperUserNotesConst.h"
 #include "MachiningConst.h"
 #include "GeoConst.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
@@ -43,6 +44,10 @@
 
 using namespace std ;
 
+//------------------------------ Constants ------------------------------------
+static int LINK_CURVE_PROP = -3 ;
+static string KEY_OPEN = "OPEN" ;
+
 //------------------------------ Errors --------------------------------------
 // 2401 = "Error in Pocketing : UpdateToolData failed"
 // 2402 = "Error in Pocketing : Open Contour"
@@ -75,23 +80,17 @@ using namespace std ;
 // 2430 = "Error in Pocketing : adjust open edges failed"
 // 2431 = "Error in Pocketing : LeadIn with Mill NoTip in material"
 // 2432 = "Error in Pocketing : Mirror for Double calculation failed"
+// 2433 = "Error in Pocketing : special apply not calculable"
 // 2451 = "Warning in Pocketing : Skipped entity (xx)"
 // 2452 = "Warning in Pocketing : No machinable pocket"
 // 2453 = "Warning in Pocketing : Tool name changed (xx)"
 // 2454 = "Warning in Pocketing : Tool data changed (xx)"
-// 2455 = "Warning in Pocketing : skipped Path too short"
 // 2456 = "Warning in Pocketing : machining step too small (xx)"
 // 2457 = "Warning in Pocketing : machining step (xxx) bigger than MaxMaterial (yyy)"
 // 2458 = "Warning in Pocketing : machining depth (xxx) bigger than MaxMaterial (yyy)"
 
 //----------------------------------------------------------------------------
-static string KEY_OPEN = "OPEN" ;
-static int LINK_CURVE_PROP = -3 ;
-
-//----------------------------------------------------------------------------
-#if POCKETING_NT != 1
-   USEROBJ_REGISTER( GetOperationClass( OPER_POCKETING), Pocketing) ;
-#endif
+//   USEROBJ_REGISTER( GetOperationClass( OPER_POCKETING), Pocketing) ;
 
 //----------------------------------------------------------------------------
 const string&
@@ -506,7 +505,8 @@ Pocketing::SetGeometry( const SELVECTOR& vIds)
   // verifico validità gestore DB geometrico
    if ( m_pGeomDB == nullptr)
       return false ;
-  // reset della geometria corrente
+  // copia temporanea e reset della geometria corrente
+   SELVECTOR vOldId = m_vId ;
    m_vId.clear() ;
   // verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve o tutte facce)
    int nType = GEO_NONE ;
@@ -522,7 +522,8 @@ Pocketing::SetGeometry( const SELVECTOR& vIds)
       m_vId.emplace_back( Id) ;
    }
   // aggiorno lo stato
-   m_nStatus |= MCH_ST_GEO_MODIF ;
+   if ( m_vId != vOldId)
+      m_nStatus |= MCH_ST_GEO_MODIF ;
   // restituisco presenza geometria da lavorare
    return ( ! m_vId.empty()  ||  vIds.empty()) ;
 }
@@ -622,15 +623,17 @@ Pocketing::Apply( bool bRecalc, bool bPostApply)
       return false ;
 
   // aggiorno dati geometrici dell'utensile
-   bool bToolChanged = true ;
-   if ( ! UpdateToolData( &bToolChanged)) {
+   if ( ! UpdateToolData()) {
       m_pMchMgr->SetLastError( 2401, "Error in Pocketing : UpdateToolData failed") ;
       return false ;
    }
 
+  // se modificata geometria, necessario ricalcolo
+   if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
+      bRecalc = true ;
+
   // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ! bToolChanged  &&  
-        ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
+   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
      // confermo i percorsi di lavorazione
       m_nPockets = nCurrPockets ;
       string sLog = string( "Pocketing apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
@@ -717,15 +720,15 @@ Pocketing::Apply( bool bRecalc, bool bPostApply)
   // assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso
    CalcAndSetBBox( nClId) ;
 
-  // eseguo aggiornamento assi macchina e collegamento con operazione precedente
-   if ( ! Update( bPostApply))
-      return false ;
-
   // se lavorazione in doppio, aggiungo geometria della parte simmetrica
    if ( ! CalcMirrorByDouble( nClId, m_Params.m_sUserNotes)) {
       m_pMchMgr->SetLastError( 2432, "Error in Pocketing : Mirror for Double calculation failed") ;
       return false ;
    }
+
+  // eseguo aggiornamento assi macchina e collegamento con operazione precedente
+   if ( ! Update( bPostApply))
+      return false ;
   
   // aggiorno stato della lavorazione
    m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
@@ -770,6 +773,47 @@ Pocketing::Update( bool bPostApply)
       return false ;
    }
 
+  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+   CalcAndSetAxesBBox() ;
+
+  // se lavorazione in doppio, calcolo assi e movimenti di approccio e retrazione relativi
+   if ( GetDoubleType( m_Params.m_sUserNotes) != 0) {
+     // elimino le entità CLIMB, RISE e HOME della lavorazione in doppio
+      RemoveClimbRiseHome( false) ;
+     // recupero i dati della testa in doppio e la imposto
+      string sDblTool ; string sDblHead ; int nDblExit ;
+      bool bOk = GetDoubleToolData( sDblTool, sDblHead, nDblExit)  &&
+                 m_pMchMgr->SetCalcTool( sDblTool, sDblHead, nDblExit) ;
+     // imposto eventuale asse bloccato da lavorazione
+      SetBlockedRotAxis( m_Params.m_sBlockedAxis, true) ;
+     // eseguo il calcolo
+      if ( bOk) {
+         if ( ! CalculateDoubleAxesValues( sHint)) {
+            string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
+            if ( sInfo.empty())
+               m_pMchMgr->SetLastError( 2423, "Error in Pocketing : axes values not calculable for double") ;
+            else
+               m_pMchMgr->SetLastError( 2424, "Error in Pocketing : double outstroke ") ;
+            bOk = false ;
+         }
+      }
+     // ripristino testa principale
+      m_pMchMgr->SetCalcTool( GetToolName(), GetHeadName(), GetExitNbr()) ;
+     // in caso di errore, esco
+      if ( ! bOk)
+         return false ;
+   }
+
+  // esecuzione eventuali personalizzazioni speciali
+   string sSpecErr ;
+   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
+      if ( ! IsEmptyOrSpaces( sSpecErr))
+         m_pMchMgr->SetLastError( 2433, sSpecErr) ;
+      else
+         m_pMchMgr->SetLastError( 2433, "Error in Pocketing : special apply not calculable") ;
+      return false ;
+   }
+
   // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
    if ( ! AdjustStartEndMovements()) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
@@ -780,14 +824,11 @@ Pocketing::Update( bool bPostApply)
       return false ;
    }
 
-  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
-   CalcAndSetAxesBBox() ;
-
-  // esecuzione eventuali personalizzazioni
-   string sErr ;
-   if ( bPostApply  &&  ! PostApply( sErr)) {
-      if ( ! IsEmptyOrSpaces( sErr))
-         m_pMchMgr->SetLastError( 2427, sErr) ;
+  // esecuzione eventuali personalizzazioni finali
+   string sPostErr ;
+   if ( bPostApply  &&  ! PostApply( sPostErr)) {
+      if ( ! IsEmptyOrSpaces( sPostErr))
+         m_pMchMgr->SetLastError( 2427, sPostErr) ;
       else
          m_pMchMgr->SetLastError( 2427, "Error in Pocketing : post apply not calculable") ;
       return false ;
@@ -941,7 +982,7 @@ Pocketing::GetToolData( void) const
 
 //----------------------------------------------------------------------------
 bool
-Pocketing::UpdateToolData( bool* pbChanged)
+Pocketing::UpdateToolData( void)
 {
   // recupero il gestore DB utensili della macchina corrente
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
@@ -992,9 +1033,9 @@ Pocketing::UpdateToolData( bool* pbChanged)
                      m_Params.m_sToolName + ")" ;
       m_pMchMgr->SetWarning( 2454, sInfo) ;
    }
-  // se definito parametro di ritorno, lo assegno
-   if ( pbChanged != nullptr)
-      *pbChanged = bChanged ;
+  // se modificato, aggiusto lo stato
+   if ( bChanged)
+      m_nStatus = MCH_ST_TO_VERIFY ;
    return true ;
 }
 
@@ -1229,7 +1270,7 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
      // la porto in globale
       pCrvCompo->ToGlob( frGlob) ;
      // sistemazioni varie
-      AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, 0) ;
+      AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, {}, 0) ;
      // la restituisco
       lstPC.emplace_back( Release( pCrvCompo)) ;
       return true ;
@@ -1267,7 +1308,7 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
            // la porto in globale
             pCrvCompo->ToGlob( frGlob) ;
            // sistemazioni varie
-            AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, 0) ;
+            AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, V_NULL, {}, 0) ;
            // la restituisco
             lstPC.emplace_back( Release( pCrvCompo)) ;
          }
@@ -1549,7 +1590,7 @@ Pocketing::ProcessPath( int nPathId, int nPvId, int nClId)
 
   // sposto l'inizio a metà del tratto più lungo ( o aperto più lungo)
    if ( bMidOpen) {
-      const double LEN_OUT = 5 ;
+      const double LEN_OUT = 5. + ( m_TParams.m_dDiam / 2.) ;
       double dPar ; int nFlag ;
       bMidOpen = ( DistPointCurve( ptMidOpen + LEN_OUT * vtMidOut, *pCompo).GetParamAtMinDistPoint( 0, dPar, nFlag) && pCompo->ChangeStartPoint( dPar)) ;
    }
@@ -1608,7 +1649,7 @@ Pocketing::ProcessPath( int nPathId, int nPvId, int nClId)
       return false ;
   // eventuale imposizione massima elevazione da note utente
    double dMaxElev ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "MaxElev", dMaxElev)  &&  dElev > dMaxElev)
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_MAXELEV, dMaxElev)  &&  dElev > dMaxElev)
       dElev = dMaxElev ;
 
   // verifico che lo step dell'utensile sia sensato
@@ -1679,11 +1720,11 @@ Pocketing::ProcessPath( int nPathId, int nPvId, int nClId)
 
   // recupero eventuale flag di lato aperto forzato fuori dal grezzo
    int nOpenOutRaw ;
-   m_bOpenOutRaw = ( GetValInNotes( m_Params.m_sUserNotes, "OpenOutRaw", nOpenOutRaw)  &&  nOpenOutRaw != 0) ;
+   m_bOpenOutRaw = ( GetValInNotes( m_Params.m_sUserNotes, UN_OPENOUTRAW, nOpenOutRaw)  &&  nOpenOutRaw != 0) ;
 
   // recupero eventuale minima lunghezza di attacco su lato aperto
    m_dOpenMinSafe = 0 ;
-   GetValInNotes( m_Params.m_sUserNotes, "OpenMinSafe", m_dOpenMinSafe) ;
+   GetValInNotes( m_Params.m_sUserNotes, UN_OPENMINSAFE, m_dOpenMinSafe) ;
 
   // se richiesta anteprima
    if ( nPvId != GDB_ID_NULL) {
@@ -2609,7 +2650,7 @@ Pocketing::OptimizedZigZag( int nPathId, const Vector3d& vtTool, double dDepth,
 
   // recupero gli id dei lati chiusi
    INTVECTOR vnInfoClosed ; 
-   for( int i = 0 ; i < pCrvPocket->GetCurveCount() ; i ++) {
+   for ( int i = 0 ; i < pCrvPocket->GetCurveCount() ; i ++) {
       int nProp ;
       if ( pCrvPocket->GetCurveTempProp( i, nProp) && nProp == 0)
          vnInfoClosed.push_back( i) ;
@@ -3459,7 +3500,7 @@ Pocketing::AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, c
    
       int nMaxInd = pMCrv->GetCurveCount() - 1 ;
       int nMaxRInd = pRCrv->GetCurveCount() - 1 ;
-   
+
      // ciclo sugli step
       Point3d ptP1 ;
       for ( int j = 1 ; j <= nStep ; ++ j) {
@@ -3505,8 +3546,15 @@ Pocketing::AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, c
                   if ( GetLeadInType() == POCKET_LI_ZIGZAG  ||
                        GetLeadInType() == POCKET_LI_HELIX  ||
                        GetLeadInType() == POCKET_LI_GLIDE) {
-                     ptP1 += vtExtr * ( dStElev + LIO_ELEV_TOL) ;
-                     dStElev = -LIO_ELEV_TOL ;
+                    // se lucidatura forzo il valore al parametro di elevazione in ingresso
+                     if ( m_TParams.m_nType == TT_MILL_POLISHING) {
+                        ptP1 += vtExtr * max( m_Params.m_dLiElev, dStElev + LIO_ELEV_TOL) ;
+                        dStElev = 0 ;
+                     }                        
+                     else {
+                        ptP1 += vtExtr * ( dStElev + LIO_ELEV_TOL) ;
+                        dStElev = -LIO_ELEV_TOL ;
+                     }
                   }
                  // approccio al punto iniziale
                   if ( ! AddApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bSplitArcs, bOutStart || bForcedOutStart)) {
@@ -3881,7 +3929,7 @@ Pocketing::CalcSpiral( const ICurveComposite* pCompo, int nReg, bool bSplitArcs,
       Vector3d vtOrtho = OrthoCompo( vtOtherDir, vtDir) ;
       double dPocketSize = vtOrtho.Len() ;
       double dMaxOptSize = m_Params.m_dSideStep ;
-      GetValInNotes( m_Params.m_sUserNotes, "MaxOptSize", dMaxOptSize) ;
+      GetValInNotes( m_Params.m_sUserNotes, UN_MAXOPTSIZE, dMaxOptSize) ;
       if ( ( ( bSomeOpen  &&  dPocketSize < m_TParams.m_dDiam + EPS_SMALL)  ||  abs( dPocketSize - m_TParams.m_dDiam) < EPS_SMALL)  &&
            dPocketSize < dMaxOptSize + 10 * EPS_SMALL) {
          if ( nReg == 0) {
@@ -5145,7 +5193,7 @@ Pocketing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafe
       SetFlag( 0) ;
       bool bStartFeed = ( bOutStart  ||  m_TParams.m_nType == TT_MILL_NOTIP) ;
       SetFeed( bStartFeed ? GetStartFeed() : GetTipFeed()) ;
-      if ( ! AreSamePointApprox( ptP1, ptP)  &&  AddLinearMove( ptP, bSplitArcs) == GDB_ID_NULL)
+      if ( ! AreSamePointApprox( ptP1, ptP)  &&  AddLinearMove( ptP, bSplitArcs, MCH_CL_SAFEIN) == GDB_ID_NULL)
          return false ;
    }
    else {
@@ -5223,7 +5271,7 @@ Pocketing::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ
         // 4 -> movimento di risalita sopra il punto finale
          SetFeed( GetEndFeed()) ;
          Point3d ptP4 = ptP + vtTool * ( dElev + dAppr) ;
-         if ( AddLinearMove( ptP4, bSplitArcs) == GDB_ID_NULL)
+         if ( AddLinearMove( ptP4, bSplitArcs, MCH_CL_SAFEOUT) == GDB_ID_NULL)
             return false ;
       }
       else {
@@ -5231,7 +5279,7 @@ Pocketing::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ
          Point3d ptP4a = ptP + vtTool * ( dElev + dAppr) ;
          if ( dElev + dAppr > EPS_SMALL) {
             SetFeed( GetEndFeed()) ;
-            if ( AddLinearMove( ptP4a, bSplitArcs) == GDB_ID_NULL)
+            if ( AddLinearMove( ptP4a, bSplitArcs, MCH_CL_SAFEOUT) == GDB_ID_NULL)
                return false ;
          }
         // 4b -> movimento di risalita sopra il punto finale
@@ -5466,8 +5514,19 @@ Pocketing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector
          Vector3d vtMove = ptEnd - ptIni ;
          pCrv->Translate( vtMove) ;
          Point3d ptFin ; pCrv->GetEndPoint( ptFin) ;
-         ptFin += vtN * 1.0 ;
-         pCrv->ModifyEnd( ptFin) ;
+        // se lucidatura forzo la stessa quota dell'ingresso
+         if ( m_TParams.m_nType == TT_MILL_POLISHING) {
+            double dExtraElev = max( m_Params.m_dLiElev, 1.0) ;
+            double dNini = ( ptEnd - ORIG) * vtN ;
+            double dNfin = dNini + dExtraElev ;
+            ptFin += vtN * dExtraElev ;
+           // distribuisco l'elevazione extra uniformemente su tutta la curva
+            AdjustCurveSlope( pCrv, dNini, dNfin) ;         
+         }
+         else {            
+            ptFin += vtN * 1.0 ;
+            pCrv->ModifyEnd( ptFin) ;         
+         }
         // emetto (con eventuale spezzatura)
          AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) ;
         // determino elevazione su fine uscita
@@ -5507,10 +5566,7 @@ bool
 Pocketing::GetForcedClosed( void)
 {
    int nOpen ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "Open", nOpen)  &&  nOpen == 0)
-      return true ;
-   else
-      return false ;
+   return ( GetValInNotes( m_Params.m_sUserNotes, UN_OPEN, nOpen)  &&  nOpen == 0) ;
 }
 
 //----------------------------------------------------------------------------

Pocketing.h

@@ -35,8 +35,14 @@ class Pocketing : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_POCKETING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nPockets == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nPockets == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -58,7 +64,7 @@ class Pocketing : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 

PocketingNT.h

@@ -25,11 +25,15 @@
 // struttura informazioni sui singoli percorsi
 struct PathInfoPO {
    bool bOutStart ;                                // flag per entrata da fuori
+   bool bOutEnd ;                                  // flag per uscita da fuori
    bool bSingleCrv ;                               // se percorso formato da una curva singola ( in generale per SubSteps)
    bool bOptTrap ;                                 // flag per casi ottimizzati a trapezio ( per Spiral)
+   bool bOptCirle ;                                // flag per casi ottimizzati a Spirale ( per Spiral)
    bool bIsZigZagOneWayBorder ;                    // curve di bordo dei lati chiusi ( per ZigZag e OneWay)
    PtrOwner<ICurveComposite> pCrvPath ;            // percorso del centro utensile
-   PtrOwner<ICurveComposite> pCrvRet ;             // curva di ritorno per LeadIn/Out a guida
+   PtrOwner<ICurveComposite> pCrvGlideIn ;         // curva per LeadIn a guida
+   PtrOwner<ICurveComposite> pCrvGlideOut ;        // curva per LeadOut a guida
+   PtrOwner<ICurveComposite> pCrvRet ;             // curva di ritorno ( per ora solo caso fori)
 } ;
 // tipo percorso
 typedef std::vector<PathInfoPO> PATHINFOPOVECTOR ;
@@ -60,8 +64,14 @@ class PocketingNT : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_POCKETING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nPockets == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nPockets == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -83,7 +93,7 @@ class PocketingNT : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 
@@ -91,22 +101,38 @@ class PocketingNT : public Machining
       PocketingNT( void) ;
 
    private :
+      bool MyApply( bool bRecalc, bool bPostApply) ;
       bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
-      bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
+      bool AdjustCurvesByStmTopology( const ISurfTriMesh* pSurf, const Frame3d& frGlob, const ISurfTriMesh* pStmTrim, ICURVEPLIST& lstPC) ;
+      bool GetCurves( const SelData& Id, const ISurfTriMesh* pStmRaw, const ISurfTriMesh* pStmTrim, ICURVEPLIST& lstPC) ;
       bool SetCurveAllTempProp( int nCrvId, bool bForcedClose, ICurve* pCurve, bool* pbSomeOpen = nullptr) ;
       bool SetSfrLoopsAllTempProp( int nSfrId, ISurfFlatRegion* pSfr) ;
       bool ResetCurveAllTempProp( ICurve* pCurve) ;
       bool Chain( int nGrpDestId) ;
       ISurfTriMesh* GetRaw( void) ;
-      ISurfTriMesh* GetExtrusionStm( const ISurfFlatRegion* pSfr, const Vector3d& vtTrasl, const Vector3d& vtExtr) ;
+      ISurfTriMesh* GetStmTrim( void) ;
+      ISurfTriMesh* GetExtrusionStm( const ISurfFlatRegion* pSfr, const Vector3d& vtExtr) ;
       ISurfFlatRegion* GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs = 0) ;
+      ISurfFlatRegion* GetSfrRawProjection( const ISurfTriMesh* pStmRaw, const ISurfFlatRegion* pSfr, const Vector3d& vtTool) ;
+      Point3d GetStartPointsByHead( const STEPINFOPOVECTOR& vStepInfo) const ;
+      Point3d GetStartPointsFromSteps( const STEPINFOPOVECTOR& vStepInfo, int nCrvType) const ;
+      bool ChooseRawPart( const ISurfFlatRegion* pSfrChunk, ISurfTriMesh* pStm) const ;
+      bool ManageOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmPart) ;
+      bool GetHomogeneousParts( const ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCrvs) const ;
+      bool ExtendOpenEdges( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm) ;
       bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmExtrusion) ;
-      bool CalcLimitRegion( const ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrRaw, ISurfFlatRegion* pSfrLimit) ;
+      bool CheckMaxDepth( const ISurfFlatRegion* pSfr, double dDepth, const Vector3d& vtTool,
+                          const ISurfTriMesh* pStmRaw, const ISurfTriMesh* pStmExtrusion,
+                          const IntersParPlanesSurfTm& IPPStm, bool& bSkipMaxDepth) ;
       bool ProcessPath( int nPathId, int nPvId, int nClId) ;
-      bool CalcRegionElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double dLen, double& dElev) ;
+      bool CalcRegionElevation( const ISurfFlatRegion* pSfr, const Vector3d& vtTool, double dDepth,
+                                double dRad, double dLen, double& dElev) ;
       bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ;
       bool GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo) ;
+      bool CalcLimitRegion( const ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrRaw, ISurfFlatRegion* pSfrLimit) ;
       bool CalcPaths( STEPINFOPOVECTOR& vStepInfo) ;
+      bool CalcRetCurve( PathInfoPO& PathInfo, const StepInfoPO& StepInfo, const ICurveComposite* pCrvPath,
+                               const Vector3d& vtTool, bool bHolePocketing, bool bInVsOut, ICurveComposite* pCrvGlide) ;
       bool AddPocket( STEPINFOPOVECTOR& vStepInfo, const Vector3d& vtTool, double dElev, double dStep, bool bSplitArcs) ;
       double GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) ;
       bool CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB) ;
@@ -122,25 +148,39 @@ class PocketingNT : public Machining
                            double dElev, double dAppr, bool bSplitArcs) ;
       bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
                        double dElev, double dAppr, bool bSplitArcs) ;
-      bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtTool, const ICurveComposite* pCrvPath, Point3d& ptP1) ;
+      bool CalcFirstElevation( const Point3d& ptStart, const Point3d& ptP1, const Vector3d& vtTool,
+                               const StepInfoPO& currStep, double dSafeZ, double dStep, double& dCurrElev,
+                               double& dEscapeElev, Vector3d& vtEscape) const ;
+      bool CalcLastElevation( const Point3d& ptStart, const Point3d& ptP1, const Vector3d& vtTool,
+                              const StepInfoPO& currStep, double dSafeZ, double dStep, double& dCurrElev,
+                              double& dEscapeElev, Vector3d& vtEscape) const ;
+      bool CalcLeadInStart( Point3d& ptStart, const Vector3d& vtTool, const ICurveComposite* pCrvPath, Point3d& ptP1) ;
       bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
                       const ISurfFlatRegion* pSfr, const ICurveComposite* pRCrv, bool bAtLeft, bool bSplitArcs,
                       bool bNoneForced, bool bSkipControl) ;
-      bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
+      bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, const ISurfFlatRegion* pSfr,
                        const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, Point3d& ptP1) ;
-      double GetRadiusForStartEndElevation( void) ;
+      double GetRadiusForStartEndElevation( void) const ;
       bool GetForcedClosed( void) ;
       bool GetMidOfLongestOpenSide( const ICurveComposite* pCompo, Point3d& ptMid, Vector3d& vtMidOut) ;
       bool AdjustContourWithOpenEdges( ICurveComposite* pCompo) ;
       bool AdjustContourStart( ICurveComposite* pCompo) ;
-      bool CheckSafetyLinearLink( const Point3d& ptCurr, const ISurfFlatRegion* pSfrLimit, const Vector3d& vtTool,
-                                  const Point3d& ptDest, bool& bSafe) ;
+      bool ManageSmoothLink( const PathInfoPO& currPath, const PathInfoPO& nextPath, bool bSamePlane,
+                             bool& bSmoothEnd, bool& bForceLinear) ;
+      bool CheckSafetyLink( const Point3d& ptCurr, const Vector3d& vtCurr,
+                            const Point3d& ptDest, const Vector3d& vtDest,
+                            const ISurfFlatRegion* pSfrLimit, const Vector3d& vtTool,
+                            bool bSmoothEnd, bool& bSafeLimit, ICurveComposite* pCrvSafeLink) ;
       bool VerifyLeadInHelix( const ISurfFlatRegion* pSfr, const Point3d& ptStart, const Point3d& ptCen, double dHelixRad) ;
       bool VerifyLeadInZigZag( const ISurfFlatRegion* pSfr, const Point3d& ptStart, const Point3d& ptPa, const Point3d& ptPb) ;
+      bool VerifyLeadInOutGlide( const ISurfFlatRegion* pSfr, ICurveComposite* pCrvGlide) ;
       bool CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist, Vector3d& vtNorm) ;
      // debug
-      void _debug_draw_sfr( const ISurfFlatRegion* pSfr, bool bUniform) ;
-      void _debug_draw_loop( const ICurveComposite* pCrvCompo, bool bUniform) ;
+      void DebugDrawSfr( const ISurfFlatRegion* pSfr, bool bUniform, int nlayer = GDB_ID_ROOT) ;
+      void DebugDrawLoop( const ICurveComposite* pCrvCompo, int nLayer, bool bUniform) ;
+      void DebugDrawBox( const BBox3d& BBox, const Frame3d& FrBox, int nlayer) ;
+      void DebugDrawOpenEdgesInRaw( const ICRVCOMPOPOVECTOR& vpCrvsm, int nlayer) ;
+      void DebugDrawFeed( const ICurve* pCrv, double dFeed, int nlayer) ;
 
    private :
       double GetSpeed( void) const
@@ -176,23 +216,24 @@ class PocketingNT : public Machining
            return m_Params.m_nLeadOutType ; }
 
    private :
-      SELVECTOR     m_vId ;             // identificativi entità geometriche da lavorare
-      PocketingData m_Params ;          // parametri lavorazione
-      ToolData      m_TParams ;         // parametri utensile
-      double        m_dTHoldBase ;      // posizione base del porta-utensile
-      double        m_dTHoldLen ;       // lunghezza del porta-utensile
-      double        m_dTHoldDiam ;      // diametro del porta-utensile
-      double        m_dMaxHelixRad ;    // raggio massimo attacco ad elica nel caso di cerchi
-      int           m_nStatus ;         // stato di aggiornamento della lavorazione
-      int           m_nPockets ;        // numero di percorsi di svuotatura generati
-      bool          m_bTiltingTab ;     // flag utilizzo tavola basculante
-      Vector3d      m_vtTiltingAx ;     // versore direzione eventuale asse basculante
-      bool          m_bAboveHead ;      // flag utilizzo testa da sopra
-      bool          m_bAggrBottom ;     // flag di utilizzo dell'aggregato da sotto
-      Vector3d      m_vtAggrBottom ;    // vettore direzione ausiliaria aggregato da sotto
-      AggrBottom    m_AggrBottom ;      // dati eventuale aggregato da sotto
-      bool          m_bOpenOutRaw ;     // flag forzatura lati aperti sempre fuori dal grezzo
-      double        m_dOpenMinSafe ;    // minima distanza di sicurezza di attacco su lato aperto
-
-      bool          _m_Debug = false ;  // _debug
+      SELVECTOR     m_vId ;                  // identificativi entità geometriche da lavorare
+      PocketingData m_Params ;               // parametri lavorazione
+      ToolData      m_TParams ;              // parametri utensile
+      double        m_dTHoldBase ;           // posizione base del porta-utensile
+      double        m_dTHoldLen ;            // lunghezza del porta-utensile
+      double        m_dTHoldDiam ;           // diametro del porta-utensile
+      double        m_dMaxHelixRad ;         // raggio massimo attacco ad elica nel caso di cerchi
+      int           m_nStatus ;              // stato di aggiornamento della lavorazione
+      int           m_nPockets ;             // numero di percorsi di svuotatura generati
+      bool          m_bTiltingTab ;          // flag utilizzo tavola basculante
+      Vector3d      m_vtTiltingAx ;          // versore direzione eventuale asse basculante
+      bool          m_bAboveHead ;           // flag utilizzo testa da sopra
+      bool          m_bAggrBottom ;          // flag di utilizzo dell'aggregato da sotto
+      Vector3d      m_vtAggrBottom ;         // vettore direzione ausiliaria aggregato da sotto
+      AggrBottom    m_AggrBottom ;           // dati eventuale aggregato da sotto
+      bool          m_bOpenOutRaw ;          // flag forzatura lati aperti sempre fuori dal grezzo
+      double        m_dOpenMinSafe ;         // minima distanza di sicurezza di attacco su lato aperto
+      double        m_dOpenInRawExtension ;  // estensione dei tratti aperti dentro al grezzo
+      bool          m_bAllClose ;            // flag per forzare i lati come tutti chiusi
+      bool          m_bRunning ;             // flag di calcoli in corso
 } ;

Probing.cpp

@@ -0,0 +1,955 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2025-2025
+//----------------------------------------------------------------------------
+// File : Probing.cpp        Data : 10.06.25          Versione : 2.7f2
+// Contenuto : Implementazione gestione tastatura.
+//
+//
+//
+// Modifiche : 10.06.25 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "MachMgr.h"
+#include "DllMain.h"
+#include "Probing.h"
+#include "OperationConst.h"
+#include "OperUserNotesConst.h"
+#include "/EgtDev/Include/EGkCurveLine.h"
+#include "/EgtDev/Include/EGkCurveArc.h"
+#include "/EgtDev/Include/EGkCurveComposite.h"
+#include "/EgtDev/Include/EGkArcSpecial.h"
+#include "/EgtDev/Include/EGkSfrCreate.h"
+#include "/EgtDev/Include/EGkSurfTriMesh.h"
+#include "/EgtDev/Include/EGkUserObjFactory.h"
+#include "/EgtDev/Include/EGnStringKeyVal.h"
+#include "/EgtDev/Include/EgtPointerOwner.h"
+#include "/EgtDev/Include/EgtIniFile.h"
+
+using namespace std ;
+
+//------------------------------ Errors --------------------------------------
+// 3401 = "Error in Probing : UpdateToolData failed"
+// 3402 = "Error in Probing : missing Script (xxx)"
+// 3403 = "Error in Probing : Error in xxx (nnn)"
+// 3404 = "Error in Probing : axes values not calculable"
+// 3405 = "Error in Probing : outstroke xx"
+// 3406 = "Error in Probing : link movements not calculable"
+// 3407 = "Error in Probing : link outstroke xx"
+// 3408 = "Error in Probing : post apply not calculable"
+// 3409 = "Error in Probing : Tool loading failed"
+// 3410 = "Error in Probing : special apply not calculable"
+// 3451 = "Warning in Probing : Skipped entity (xx)"
+// 3452 = "Warning in Probing : No machinable path"
+// 3453 = "Warning in Probing : Tool name changed (xx)"
+// 3454 = "Warning in Probing : Tool data changed (xx)"
+
+//------------------------------ Constants -----------------------------------
+static const string EMC_VAR = "EMC" ;              // tabella variabili locali per calcolo
+static const string EVAR_MACHID = ".MACHID" ;      // IN (int) identificativo della lavorazione
+static const string EVAR_GEOM = ".GEOM" ;          // IN (table) tabella delle entità da lavorare
+static const string EVAR_DEPTH = ".DEPTH" ;        // IN (string) affondamento (espressione numerica)
+static const string EVAR_TINVERT = ".TOOLINVERT" ; // IN (bool) flag di inversione direzione utensile
+static const string EVAR_INVERT = ".INVERT" ;      // IN (bool) flag di inversione direzione lavorazione
+static const string EVAR_STARTPOS = ".STARTPOS" ;  // IN (num) quota di inizio lavorazione (sempre >= 0) 
+static const string EVAR_SYSNOTES = ".SYSNOTES" ;  // IN (string) note interne
+static const string EVAR_USERNOTES = ".USERNOTES" ;// IN (string) note dell'utente
+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_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_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
+static const string EVAR_TIPFEED = ".TIPFEED" ;    // IN (num) feed di punta dell'utensile
+static const string EVAR_ISROBOT = ".ISROBOT" ;    // IN (bool) flag per indicare che la cinematica è di tipo robot
+static const string EVAR_ERROR = ".ERR" ;          // OUT (int) codice di errore ( 0 = ok)
+static const string EVAR_MILLS = ".MILLS" ;        // OUT (int) numero di percorsi di lavoro
+static const string ON_PREVIEW = "OnPreview_" ;
+static const string ON_APPLY = "OnApply_" ;
+
+//----------------------------------------------------------------------------
+USEROBJ_REGISTER( GetOperationClass( OPER_PROBING), Probing) ;
+
+//----------------------------------------------------------------------------
+const string&
+Probing::GetClassName( void) const
+{
+   return USEROBJ_GETNAME( Probing) ;
+}
+
+//----------------------------------------------------------------------------
+Probing*
+Probing::Clone( void) const
+{
+  // alloco oggetto
+   Probing* pGenM = new(nothrow) Probing ;
+  // eseguo copia dei dati
+   if ( pGenM != nullptr) {
+      try {
+         pGenM->m_vId = m_vId ;
+         pGenM->m_pMchMgr = m_pMchMgr ;
+         pGenM->m_nPhase = m_nPhase ;
+         pGenM->m_Params = m_Params ;
+         pGenM->m_TParams = m_TParams ;
+         pGenM->m_nStatus = m_nStatus ;
+         pGenM->m_nMills = m_nMills ;
+      }
+      catch( ...) {
+         delete pGenM ;
+         return nullptr ;
+      }
+   }
+  // ritorno l'oggetto
+   return pGenM ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::Dump( string& sOut, bool bMM, const char* szNewLine) const
+{
+   sOut += GetClassName() + "[mm]" + szNewLine ;
+   sOut += KEY_PHASE + EQUAL + ToString( m_nPhase) + szNewLine ;
+   sOut += KEY_IDS + EQUAL + ToString( m_vId) + szNewLine ;
+   for ( int i = 0 ; i < m_Params.GetSize() ; ++ i)
+      sOut += m_Params.ToString( i) + szNewLine ;
+   for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i)
+      sOut += m_TParams.ToString( i) + szNewLine ;
+   sOut += KEY_NUM + EQUAL + ToString( m_nMills) + szNewLine ;
+   sOut += KEY_STAT + EQUAL + ToString( m_nStatus) + szNewLine ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::Save( int nBaseId, STRVECTOR& vString) const
+{
+   try {
+      int nSize = 1 + m_Params.GetSize() + m_TParams.GetSize() + 3 ;
+      vString.insert( vString.begin(), nSize, "") ;
+      int k = - 1 ;
+      if ( ! SetVal( KEY_IDS, m_vId, vString[++k]))
+         return false ;
+      for ( int i = 0 ; i < m_Params.GetSize() ; ++ i)
+         vString[++k] = m_Params.ToString( i) ;
+      for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i)
+         vString[++k] = m_TParams.ToString( i) ;
+      if ( ! SetVal( KEY_PHASE, m_nPhase, vString[++k]))
+         return false ;
+      if ( ! SetVal( KEY_NUM, m_nMills, vString[++k]))
+         return false ;
+      if ( ! SetVal( KEY_STAT, m_nStatus, vString[++k]))
+         return false ;
+   }
+   catch( ...) {
+      return false ;
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::Load( const STRVECTOR& vString, int nBaseGdbId)
+{
+   int nSize = int( vString.size()) ;
+  // lista identificativi geometrie da lavorare
+   int k = - 1 ;
+   if ( k >= nSize - 1  ||  ! GetVal( vString[++k], KEY_IDS, m_vId))
+      return false ;
+   for ( auto& Sel : m_vId)
+      Sel.nId += nBaseGdbId ;
+  // parametri lavorazione
+   for ( int i = 0 ; i < m_Params.GetSize() ; ++ i) {
+      int nKey ;
+      if ( k >= nSize - 1  ||  ! m_Params.FromString( vString[++k], nKey)  ||  nKey != i) {
+         if ( m_Params.IsOptional( i))
+            -- k ;
+         else
+            return false ;
+      }
+   }
+  // parametri utensile
+   for ( int i = 0 ; i < m_TParams.GetSize() ; ++ i) {
+      int nKey ;
+      if ( k >= nSize - 1  ||  ! m_TParams.FromString( vString[++k], nKey)  ||  nKey != i)
+         return false ;
+   }
+  // parametri di stato
+   while ( k < nSize - 1) {
+     // separo chiave da valore
+      string sKey, sVal ;
+      SplitFirst( vString[++k], "=", sKey, sVal) ;
+     // leggo
+      if ( sKey == KEY_PHASE) {
+         if ( ! FromString( sVal, m_nPhase))
+            return false ;
+      }
+      else if ( sKey == KEY_NUM) {
+         if ( ! FromString( sVal, m_nMills))
+            return false ;
+      }
+      else if ( sKey == KEY_STAT) {
+         if ( ! FromString( sVal, m_nStatus))
+            return false ;
+      }
+   }
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+//----------------------------------------------------------------------------
+Probing::Probing( void)
+{
+   m_Params.m_sName = "*" ;
+   m_Params.m_sToolName = "*" ;
+   m_TParams.m_sName = "*" ;
+   m_TParams.m_sHead = "*" ;
+   m_nStatus = MCH_ST_TO_VERIFY ;
+   m_nMills = 0 ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::Prepare( const string& sGenMchName)
+{
+  // verifico il gestore lavorazioni
+   if ( m_pMchMgr == nullptr)
+      return false ;
+  // recupero il gestore DB utensili della macchina corrente
+   ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
+   if ( pTMgr == nullptr)
+      return false ;
+  // recupero il gestore DB lavorazioni della macchina corrente
+   MachiningsMgr* pMMgr = m_pMchMgr->GetCurrMachiningsMgr() ;
+   if ( pMMgr == nullptr)
+      return false ;
+  // ricerca della lavorazione di libreria con il nome indicato
+   const ProbingData* pDdata = GetProbingData( pMMgr->GetMachining( sGenMchName)) ;
+   if ( pDdata == nullptr)
+      return false ;
+   m_Params = *pDdata ;
+  // ricerca dell'utensile usato dalla lavorazione
+   const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
+   if ( pTdata == nullptr)
+      return false ;
+   m_TParams = *pTdata ;
+   m_Params.m_sToolName = m_TParams.m_sName ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::SetParam( int nType, bool bVal)
+{
+   switch ( nType) {
+   case MPA_INVERT :
+      if ( bVal != m_Params.m_bInvert)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_bInvert = bVal ;
+      return true ;
+   case MPA_TOOLINVERT :
+      if ( bVal != m_Params.m_bToolInvert)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_bToolInvert = bVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::SetParam( int nType, int nVal)
+{
+   switch ( nType) {
+   case MPA_SCC :
+      if ( ! m_Params.VerifySolCh( nVal))
+         return false ;
+      if ( nVal != m_Params.m_nSolCh)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_nSolCh = nVal ;
+      return true ;
+   case MPA_SUBTYPE :
+      if ( nVal != m_Params.m_nSubType)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_nSubType = nVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::SetParam( int nType, double dVal)
+{
+   switch ( nType) {
+   case MPA_FEED :
+      if ( abs( m_TParams.m_dFeed - dVal) < EPS_MACH_LEN_PAR)
+         dVal = 0 ;
+      if ( abs( dVal - m_Params.m_dFeed) > EPS_MACH_LEN_PAR)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_dFeed = dVal ;
+      return true ;
+   case MPA_STARTFEED :
+      if ( abs( m_TParams.m_dStartFeed - dVal) < EPS_MACH_LEN_PAR)
+         dVal = 0 ;
+      if ( abs( dVal - m_Params.m_dStartFeed) > EPS_MACH_LEN_PAR)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_dStartFeed = dVal ;
+      return true ;
+   case MPA_ENDFEED :
+      if ( abs( m_TParams.m_dEndFeed - dVal) < EPS_MACH_LEN_PAR)
+         dVal = 0 ;
+      if ( abs( dVal - m_Params.m_dEndFeed) > EPS_MACH_LEN_PAR)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_dEndFeed = dVal ;
+      return true ;
+   case MPA_TIPFEED :
+      if ( abs( m_TParams.m_dTipFeed - dVal) < EPS_MACH_LEN_PAR)
+         dVal = 0 ;
+      if ( abs( dVal - m_Params.m_dTipFeed) > EPS_MACH_LEN_PAR)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_dTipFeed = dVal ;
+      return true ;
+   case MPA_DEPTH: {
+      string sVal = ToString( dVal) ;
+      if ( sVal != m_Params.m_sDepth)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_sDepth = sVal ;
+      } return true ;
+   case MPA_STARTPOS :
+      if ( abs( dVal - m_Params.m_dStartPos) > EPS_MACH_LEN_PAR)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_dStartPos = dVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::SetParam( int nType, const string& sVal)
+{
+   switch ( nType) {
+   case MPA_TOOL : {
+      const ToolData* pTdata ;
+      if ( ! m_Params.VerifyTool( m_pMchMgr->GetCurrToolsMgr(), sVal, pTdata))
+         return false ;
+      if ( ! SameTool( m_TParams, *pTdata))
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_sToolName = sVal ;
+      m_Params.m_ToolUuid = pTdata->m_Uuid ;
+      m_TParams = *pTdata ;
+      } return true ;
+   case MPA_DEPTH_STR :
+      if ( sVal != m_Params.m_sDepth)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_sDepth = sVal ;
+      return true ;
+   case MPA_SYSNOTES :
+      if ( sVal != m_Params.m_sSysNotes)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_sSysNotes = sVal ;
+      return true ;
+   case MPA_USERNOTES :
+      if ( sVal != m_Params.m_sUserNotes)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_sUserNotes = sVal ;
+      return true ;
+   case MPA_INITANGS :
+      if ( sVal != m_Params.m_sInitAngs)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_sInitAngs = sVal ;
+      return true ;
+   case MPA_BLOCKEDAXIS :
+      if ( sVal != m_Params.m_sBlockedAxis)
+         m_nStatus |= MCH_ST_PARAM_MODIF ;
+      m_Params.m_sBlockedAxis = sVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::SetGeometry( const SELVECTOR& vIds)
+{
+  // verifico validità gestore DB geometrico
+   if ( m_pGeomDB == nullptr)
+      return false ;
+  // copia temporanea e reset della geometria corrente
+   SELVECTOR vOldId = m_vId ;
+   m_vId.clear() ;
+  // verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve o tutte facce)
+   int nType = GEO_NONE ;
+   for ( const auto& Id : vIds) {
+     // test sull'entità
+      int nSubs ;
+      if ( ! VerifyGeometry( Id, nSubs, nType)) {
+         string sInfo = "Warning in Probing : Skipped entity " + ToString( Id) ;
+         m_pMchMgr->SetWarning( 3451, sInfo) ;
+         continue ;
+      }
+     // posso aggiungere alla lista
+      m_vId.emplace_back( Id) ;
+   }
+  // aggiorno lo stato
+   if ( m_vId != vOldId)
+      m_nStatus |= MCH_ST_GEO_MODIF ;
+  // restituisco presenza geometria da lavorare
+   return ( ! m_vId.empty()  ||  vIds.empty()) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::Preview( bool bRecalc)
+{
+  // reset numero percorsi di lavoro generati
+   m_nMills = 0 ;
+
+  // verifico validità gestore DB geometrico e Id del gruppo
+   if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
+      return false ;
+
+  // aggiorno dati geometrici dell'utensile
+   if ( ! UpdateToolData()) {
+      m_pMchMgr->SetLastError( 3401, "Error in Probing : UpdateToolData failed") ;
+      return false ;
+   }
+
+  // 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( 3409, "Error in Probing : Tool loading failed") ;
+      return false ;
+   }
+
+  // recupero gruppo per geometria di Preview
+   int nPvId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_PV) ;
+  // se non c'è, lo aggiungo
+   if ( nPvId == GDB_ID_NULL) {
+      nPvId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
+      if ( nPvId == GDB_ID_NULL)
+         return false ;
+      m_pGeomDB->SetName( nPvId, MCH_PV) ;
+   }
+  // altrimenti lo svuoto
+   else
+      m_pGeomDB->EmptyGroup( nPvId) ;
+
+  // recupero la macchina corrente
+   Machine* pMch = m_pMchMgr->GetCurrMachine() ;
+   if ( pMch == nullptr)
+      return false ;
+
+  // nome della funzione lua da Ini della macchina
+   string sMachIni = pMch->GetMachineDir() + "\\" + pMch->GetMachineName() + ".ini" ;
+   string sKey = PROBING_SCRIPT_KEY + ToString( m_Params.m_nSubType) ;
+   string sName = GetPrivateProfileStringUtf8( PROBING_SEC.c_str(), sKey.c_str(), "", sMachIni.c_str()) ;
+   string sPreview = ON_PREVIEW + sName ;
+
+  // verifico esistenza funzione
+   if ( ! pMch->LuaExistsFunction( sPreview)) {
+      string sErr = "Error in Probing : missing Script " + sPreview ;
+      m_pMchMgr->SetLastError( 3402, sErr) ;
+      return false ;
+   }
+
+  // imposto stato
+   bool bOk = true ;
+   int nErr = 99 ;
+  // imposto valori parametri
+   bOk = bOk && pMch->LuaCreateGlobTable( EMC_VAR) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_MACHID, m_nOwnerId) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_GEOM, m_vId) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_DEPTH, m_Params.m_sDepth) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TINVERT, m_Params.m_bToolInvert) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_INVERT, m_Params.m_bInvert) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTPOS, m_Params.m_dStartPos) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_SYSNOTES, m_Params.m_sSysNotes) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_USERNOTES, m_Params.m_sUserNotes) ;  
+   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_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_FEED, GetFeed()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTFEED, GetStartFeed()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ENDFEED, GetEndFeed()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TIPFEED, GetTipFeed()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ISROBOT, m_pMchMgr->GetCurrIsRobot()) ;
+  // eseguo
+   bOk = bOk && pMch->LuaCallFunction( sPreview, false) ;
+  // recupero valori parametri obbligatori
+   bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_ERROR, nErr) ;
+   bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_MILLS, m_nMills) ;
+  // reset
+   bOk = bOk && pMch->LuaResetGlobVar( EMC_VAR) ;
+  // segnalo errori
+   if ( ! bOk  ||  nErr != 0) {
+      m_nMills = 0 ;
+      string sErr = "Error in Probing : Error in " + sPreview + " (" + ToString( nErr) + ")" ;
+      m_pMchMgr->SetLastError( 3403, sErr) ;
+      return false ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::Apply( bool bRecalc, bool bPostApply)
+{
+  // reset numero percorsi di lavoro generati
+   int nCurrMills = m_nMills ;
+   m_nMills = 0 ;
+
+  // verifico validità gestore DB geometrico e Id del gruppo
+   if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
+      return false ;
+
+  // aggiorno dati geometrici dell'utensile
+   if ( ! UpdateToolData()) {
+      m_pMchMgr->SetLastError( 3401, "Error in Probing : UpdateToolData failed") ;
+      return false ;
+   }
+
+  // se modificata geometria, necessario ricalcolo
+   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_nMills = nCurrMills ;
+      string sLog = string( "Probing 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( 3409, "Error in Probing : Tool loading 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
+   if ( nClId == GDB_ID_NULL) {
+      nClId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
+      if ( nClId == GDB_ID_NULL)
+         return false ;
+      m_pGeomDB->SetName( nClId, MCH_CL) ;
+   }
+  // altrimenti lo svuoto
+   else
+      m_pGeomDB->EmptyGroup( nClId) ;
+
+  // recupero la macchina corrente
+   Machine* pMch = m_pMchMgr->GetCurrMachine() ;
+   if ( pMch == nullptr)
+      return false ;
+
+  // nome della funzione lua da Ini della macchina
+   string sMachIni = pMch->GetMachineDir() + "\\" + pMch->GetMachineName() + ".ini" ;
+   string sKey = PROBING_SCRIPT_KEY + ToString( m_Params.m_nSubType) ;
+   string sName = GetPrivateProfileStringUtf8( PROBING_SEC.c_str(), sKey.c_str(), "", sMachIni.c_str()) ;
+   string sApply = ON_APPLY + sName ;
+
+  // verifico esistenza funzione
+   if ( ! pMch->LuaExistsFunction( sApply)) {
+      string sErr = "Error in Probing : missing Script " + sApply ;
+      m_pMchMgr->SetLastError( 3402, sErr) ;
+      return false ;
+   }
+
+  // imposto stato
+   bool bOk = true ;
+   int nErr = 99 ;
+  // imposto valori parametri
+   bOk = bOk && pMch->LuaCreateGlobTable( EMC_VAR) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_MACHID, m_nOwnerId) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_GEOM, m_vId) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_DEPTH, m_Params.m_sDepth) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TINVERT, m_Params.m_bToolInvert) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_INVERT, m_Params.m_bInvert) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTPOS, m_Params.m_dStartPos) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_SYSNOTES, m_Params.m_sSysNotes) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_USERNOTES, m_Params.m_sUserNotes) ;  
+   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_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_FEED, GetFeed()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTFEED, GetStartFeed()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ENDFEED, GetEndFeed()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TIPFEED, GetTipFeed()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ISROBOT, m_pMchMgr->GetCurrIsRobot()) ;
+  // eseguo
+   bOk = bOk && pMch->LuaCallFunction( sApply, false) ;
+  // recupero valori parametri obbligatori
+   bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_ERROR, nErr) ;
+   bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_MILLS, m_nMills) ;
+  // reset
+   bOk = bOk && pMch->LuaResetGlobVar( EMC_VAR) ;
+  // segnalo errori
+   if ( ! bOk  ||  nErr != 0) {
+      m_nMills = 0 ;
+      string sErr = "Error in Probing : Error in " + sApply + " (" + ToString( nErr) + ")" ;
+      m_pMchMgr->SetLastError( 3403, sErr) ;
+      return false ;
+   }
+
+  // assegno ingombri dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+   CalcAndSetBBox( nClId) ;
+
+  // eseguo aggiornamento assi macchina e collegamento con operazione precedente
+   if ( ! Update( bPostApply))
+      return false ;
+  
+  // aggiorno stato della lavorazione
+   m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
+  // dichiaro successiva da aggiornare
+   UpdateFollowingOperationsStatus( MCH_ST_OTH_MODIF) ;
+
+   LOG_DBG_INFO( GetEMkLogger(), "Probing apply done") ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::Update( bool bPostApply)
+{
+  // verifico validità gestore DB geometrico e Id del gruppo
+   if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
+      return false ;
+
+  // se lavorazione vuota, esco
+   if ( m_nMills == 0) {
+      m_pMchMgr->SetWarning( 3452, "Warning in Probing : No machinable path") ;
+      return true ;
+   }
+
+  // elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo) 
+   RemoveClimbRiseHome() ;
+
+  // imposto eventuale asse bloccato da lavorazione
+   SetBlockedRotAxis( m_Params.m_sBlockedAxis) ;
+
+  // calcolo gli assi macchina
+   string sHint = ExtractHint( m_Params.m_sUserNotes) ;
+   if ( ! m_Params.m_sInitAngs.empty())
+      sHint = m_Params.m_sInitAngs ;
+   if ( ! CalculateAxesValues( sHint)) {
+      string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
+      if ( sInfo.empty())
+         m_pMchMgr->SetLastError( 3404, "Error in Probing : axes values not calculable") ;
+      else
+         m_pMchMgr->SetLastError( 3405, "Error in Probing : outstroke ") ;
+      return false ;
+   }
+
+  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+   CalcAndSetAxesBBox() ;
+
+  // esecuzione eventuali personalizzazioni speciali
+   string sSpecErr ;
+   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
+      if ( ! IsEmptyOrSpaces( sSpecErr))
+         m_pMchMgr->SetLastError( 3410, sSpecErr) ;
+      else
+         m_pMchMgr->SetLastError( 3410, "Error in Probing : special apply not calculable") ;
+      return false ;
+   }
+
+  // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
+   if ( ! AdjustStartEndMovements()) {
+      string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
+      if ( sInfo.empty())
+         m_pMchMgr->SetLastError( 3406, "Error in Probing : link movements not calculable") ;
+      else
+         m_pMchMgr->SetLastError( 3407, "Error in Probing : link outstroke ") ;
+      return false ;
+   }
+
+  // esecuzione eventuali personalizzazioni finali
+   string sPostErr ;
+   if ( bPostApply  &&  ! PostApply( sPostErr)) {
+      if ( ! IsEmptyOrSpaces( sPostErr))
+         m_pMchMgr->SetLastError( 3408, sPostErr) ;
+      else
+         m_pMchMgr->SetLastError( 3408, "Error in Probing : post apply not calculable") ;
+      return false ;
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::GetParam( int nType, bool& bVal) const
+{
+   switch ( nType) {
+   case MPA_INVERT :
+      bVal = m_Params.m_bInvert ;
+      return true ;
+   case MPA_TOOLINVERT :
+      bVal = m_Params.m_bToolInvert ;
+      return true ;
+   }
+   bVal = false ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::GetParam( int nType, int& nVal) const
+{
+   switch ( nType) {
+   case MPA_TYPE :
+      nVal = MT_PROBING ;
+      return true ;
+   case MPA_SCC :
+      nVal = m_Params.m_nSolCh ;
+      return true ;
+   case MPA_SUBTYPE :
+      nVal = m_Params.m_nSubType ;
+      return true ;
+   }
+   nVal = 0 ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::GetParam( int nType, double& dVal) const
+{
+   switch ( nType) {
+   case MPA_SPEED :
+      dVal = 0 ;
+      return true ;
+   case MPA_FEED :
+      dVal = GetFeed() ;
+      return true ;
+   case MPA_STARTFEED :
+      dVal = GetStartFeed() ;
+      return true ;
+   case MPA_ENDFEED :
+      dVal = GetEndFeed() ;
+      return true ;
+   case MPA_TIPFEED :
+      dVal = GetTipFeed() ;
+      return true ;
+   case MPA_STARTPOS :
+      dVal = m_Params.m_dStartPos ;
+      return true ;
+   }
+   dVal = 0 ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::GetParam( int nType, string& sVal) const
+{
+   switch ( nType) {
+   case MPA_NAME :
+      sVal = m_Params.m_sName ;
+      return true ;
+   case MPA_TOOL :
+      sVal = m_Params.m_sToolName ;
+      return true ;
+   case MPA_DEPTH_STR :
+      sVal = m_Params.m_sDepth ;
+      return true ;
+   case MPA_TUUID :
+      sVal = ToString( m_Params.m_ToolUuid) ;
+      return true ;
+   case MPA_UUID :
+      sVal = ToString( m_Params.m_Uuid) ;
+      return true ;
+   case MPA_SYSNOTES :
+      sVal = m_Params.m_sSysNotes ;
+      return true ;
+   case MPA_USERNOTES :
+      sVal = m_Params.m_sUserNotes ;
+      return true ;
+   case MPA_INITANGS :
+      sVal = m_Params.m_sInitAngs ;
+      return true ;
+   case MPA_BLOCKEDAXIS :
+      sVal = m_Params.m_sBlockedAxis ;
+      return true ;
+   }
+   sVal = "" ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+const ToolData&
+Probing::GetToolData( void) const
+{
+   return m_TParams ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::UpdateToolData( void)
+{
+  // recupero il gestore DB utensili della macchina corrente
+   ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
+   if ( pTMgr == nullptr)
+      return false ;
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
+   const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
+  // salvo posizione TC, testa e uscita originali
+   string sOrigTcPos = m_TParams.m_sTcPos ;
+   string sOrigHead = m_TParams.m_sHead ;
+   int nOrigExit = m_TParams.m_nExit ;
+  // verifico se sono diversi (ad esclusione di nome, posizione TC, testa e uscita)
+   bool bChanged = ( ! SameTool( m_TParams, *pTdata, false)) ;
+  // aggiorno comunque i parametri
+   m_TParams = *pTdata ;
+  // se definito attrezzaggio, aggiorno i parametri che ne possono derivare
+   string sTcPos ; string sHead ; int nExit ;
+   if ( m_pMchMgr->GetCurrSetupMgr().GetToolData( m_TParams.m_sName, sTcPos, sHead, nExit)) {
+      if ( sOrigTcPos != sTcPos  ||
+           sOrigHead  != sHead  ||
+           nOrigExit != nExit)
+         bChanged = true ;
+      m_TParams.m_sTcPos = sTcPos ;
+      m_TParams.m_sHead = sHead ;
+      m_TParams.m_nExit = nExit ;
+   }
+   else {
+      if ( sOrigTcPos != pTdata->m_sTcPos  ||
+           sOrigHead  != pTdata->m_sHead  ||
+           nOrigExit  != pTdata->m_nExit)
+         bChanged = true ;
+   }
+  // eventuali segnalazioni
+   if ( ! EqualNoCase( m_Params.m_sToolName, m_TParams.m_sName)) {
+      string sInfo = "Warning in Probing : tool name changed (" +
+                     m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ;
+      m_pMchMgr->SetWarning( 3453, sInfo) ;
+      m_Params.m_sToolName = m_TParams.m_sName ;
+   }
+   if ( bChanged) {
+      string sInfo = "Warning in Probing : tool data changed (" +
+                     m_Params.m_sToolName + ")" ;
+      m_pMchMgr->SetWarning( 3454, sInfo) ;
+   }
+  // se modificato, aggiusto lo stato
+   if ( bChanged)
+      m_nStatus = MCH_ST_TO_VERIFY ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::GetGeometry( SELVECTOR& vIds) const
+{
+  // restituisco l'elenco delle entità
+   vIds = m_vId ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+Probing::VerifyGeometry( SelData Id, int& nSubs, int& nType)
+{
+  // ammessi : tutte curve o tutte facce di trimesh
+   const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( Id.nId) ;
+   if ( pGObj == nullptr)
+      return false ;
+  // se ammesse curve ed è tale
+   if ( nType != GEO_SURF  &&  ( pGObj->GetType() & GEO_CURVE) != 0) {
+      const ICurve* pCurve = nullptr ;
+      // se direttamente la curva
+      if ( Id.nSub == SEL_SUB_ALL) {
+         pCurve = ::GetCurve( pGObj) ;
+         if ( pCurve != nullptr) {
+            if ( pCurve->GetType() == CRV_COMPO)
+               nSubs = ::GetCurveComposite( pCurve)->GetCurveCount() ;
+            else
+               nSubs = 0 ;
+         }
+      }
+      // altrimenti sottocurva di composita
+      else {
+         const ICurveComposite* pCompo = GetCurveComposite( pGObj) ;
+         if ( pCompo != nullptr)
+            pCurve = pCompo->GetCurve( Id.nSub) ;
+         nSubs = 0 ;
+      }
+      return ( pCurve != nullptr) ;
+   }
+  // se altrimenti ammesse superfici trimesh ed è tale
+   else if ( nType != GEO_CURVE  &&  ( pGObj->GetType() & GEO_SURF) != 0) {
+      const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
+      if ( pSurf == nullptr)
+         return false ;
+      // se direttamente la superficie
+      if ( Id.nSub == SEL_SUB_ALL) {
+         nSubs = pSurf->GetFacetCount() ;
+         return true ;
+      }
+      // altrimenti faccia di superficie trimesh
+      else {
+        // se faccia non esistente
+         if ( Id.nSub > pSurf->GetFacetCount())
+            return false ;
+        // tutto bene
+         nSubs = 0 ;
+         return true ;
+      }
+   }
+  // altrimenti errore
+   else
+      return false ;
+}
+
+//----------------------------------------------------------------------------
+double
+Probing::GetApproxLinTol( void) const
+{
+   double dLinTol ;
+   if ( GetValInNotes( m_Params.m_sUserNotes, UN_LINTOL, dLinTol))
+      return dLinTol ;
+   else
+      return Operation::GetApproxLinTol() ;
+}

Probing.h

@@ -0,0 +1,94 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2025-2025
+//----------------------------------------------------------------------------
+// File : Probing.h           Data : 10.06.25          Versione : 2.7f2
+// Contenuto : Dichiarazione della classe Probing.
+//
+//
+//
+// Modifiche : 10.06.25 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "Machining.h"
+#include "ProbingData.h"
+#include "ToolData.h"
+
+class ICurve ;
+class ICurveComposite ;
+
+//----------------------------------------------------------------------------
+class Probing : public Machining
+{
+   public :                           // IUserObj
+      Probing* Clone( void) const override ;
+      const std::string& GetClassName( void) const override ;
+      bool Dump( std::string& sOut, bool bMM = true, const char* szNewLine = "\n") const override ;
+      bool ToSave( void) const override
+              { return true ; }
+      bool Save( int nBaseId, STRVECTOR& vString) const override ;
+      bool Load( const STRVECTOR& vString, int nBaseGdbId) override ;
+
+   public :                           // Operation
+      int  GetType( void) const override
+              { return OPER_PROBING ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nMills == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
+      bool UpdateStatus( int nModif) override
+              { m_nStatus |= nModif ; return true ; }
+
+   protected :                        // Operation
+      int  GetSolCh( void) const override
+              { return m_Params.m_nSolCh ; }
+
+   public :                           // Machining
+      bool Prepare( const std::string& sMillName) override ;
+      bool SetParam( int nType, bool bVal) override ;
+      bool SetParam( int nType, int nVal) override ;
+      bool SetParam( int nType, double dVal) override ;
+      bool SetParam( int nType, const std::string& sVal) override ;
+      bool SetGeometry( const SELVECTOR& vIds) override ;
+      bool Preview( bool bRecalc) override ;
+      bool Apply( bool bRecalc, bool bPostApply) override ;
+      bool Update( bool bPostApply) override ;
+      bool GetParam( int nType, bool& bVal) const override ;
+      bool GetParam( int nType, int& nVal) const override ;
+      bool GetParam( int nType, double& dVal) const override ;
+      bool GetParam( int nType, std::string& sVal) const override ;
+      bool UpdateToolData( void) override ;
+      const ToolData& GetToolData( void) const override ;
+      bool GetGeometry( SELVECTOR& vIds) const override ;
+
+   public :
+      Probing( void) ;
+
+   private :
+      bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
+      double GetApproxLinTol( void) const override ;
+
+   private :
+      double GetFeed() const
+         { return ( IsNullLenValue( m_Params.m_dFeed) ? m_TParams.m_dFeed : m_Params.m_dFeed) ; }
+      double GetStartFeed() const
+         { return ( IsNullLenValue( m_Params.m_dStartFeed) ? m_TParams.m_dStartFeed : m_Params.m_dStartFeed) ; }
+      double GetEndFeed() const
+         { return ( IsNullLenValue( m_Params.m_dEndFeed) ? m_TParams.m_dEndFeed : m_Params.m_dEndFeed) ; }
+      double GetTipFeed() const
+         { return ( IsNullLenValue( m_Params.m_dTipFeed) ? m_TParams.m_dTipFeed : m_Params.m_dTipFeed) ; }
+
+   private :
+      SELVECTOR     m_vId ;             // identificativi entità geometriche da lavorare
+      ProbingData   m_Params ;          // parametri lavorazione
+      ToolData      m_TParams ;         // parametri utensile
+      int           m_nStatus ;         // stato di aggiornamento della lavorazione
+      int           m_nMills ;          // numero di percorsi di lavoro generati
+} ;

ProbingData.cpp

@@ -0,0 +1,515 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2025-2025
+//----------------------------------------------------------------------------
+// File : ProbingData.cpp        Data : 09.06.25        Versione : 2.7f2
+// Contenuto : Implementazione struttura dati tastatura.
+//
+//
+//
+// Modifiche : 09.06.25 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+//--------------------------- Include ----------------------------------------
+#include "stdafx.h"
+#include "ProbingData.h"
+#include "MachiningDataFactory.h"
+#include "MachiningConst.h"
+#include "/EgtDev/Include/EmkToolConst.h"
+#include "/EgtDev/Include/EmkSimuGenConst.h"
+#include "/EgtDev/Include/EGnStringUtils.h"
+#include <array>
+#include <cassert>
+
+using namespace std ;
+
+//----------------------------------------------------------------------------
+enum nProbingKey {
+   KEY_AB = 0,
+   KEY_AI,
+   KEY_DH,
+   KEY_F,
+   KEY_FE,
+   KEY_FS,
+   KEY_FT,
+   KEY_INV,
+   KEY_NAME,
+   KEY_NNS,
+   KEY_NNU,
+   KEY_PS,
+   KEY_SCC,
+   KEY_SUBTYPE,
+   KEY_TI,
+   KEY_TNAME,
+   KEY_TUUID,
+   KEY_UUID,
+   KEY_ZZZ} ;        // rappresenta il numero di elementi
+
+static const array<string,KEY_ZZZ> sProbingKey = {
+   "AB",
+   "AI",
+   "DH",
+   "F",
+   "FE",
+   "FS",
+   "FT",
+   "INV",
+   "NAME",
+   "NNS",
+   "NNU",
+   "PS",
+   "SCC",
+   "SUB",
+   "TI",
+   "TN",
+   "TU",
+   "UUID"} ;
+
+//----------------------------------------------------------------------------
+MCHDATA_REGISTER( MT_PROBING, "PROBING", ProbingData) ;
+
+//----------------------------------------------------------------------------
+ProbingData*
+ProbingData::Clone( void) const
+{
+  // alloco oggetto
+   ProbingData* pDdata = new(nothrow) ProbingData ;
+  // copio i dati
+   if ( pDdata != nullptr) {
+      if ( ! pDdata->CopyFrom( this)) {
+         delete pDdata ;
+         return nullptr ;
+      }
+   }
+   return pDdata ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::CopyFrom( const MachiningData* pMdata)
+{
+  // è inutile copiare se sorgente coincide con destinazione
+   if ( pMdata == this)
+      return true ;
+  // la sorgente deve essere dello stesso tipo
+   const ProbingData* pGdata = GetProbingData( pMdata) ;
+   if ( pGdata == nullptr)
+      return false ;
+  // eseguo copia
+   m_Uuid = pGdata->m_Uuid ;
+   m_sName = pGdata->m_sName ;
+   m_ToolUuid = pGdata->m_ToolUuid ;
+   m_sToolName = pGdata->m_sToolName ;
+   m_sBlockedAxis = pGdata->m_sBlockedAxis ;
+   m_sInitAngs = pGdata->m_sInitAngs ;
+   m_nSolCh = pGdata->m_nSolCh ;
+   m_dFeed = pGdata->m_dFeed ;
+   m_dStartFeed = pGdata->m_dStartFeed ;
+   m_dEndFeed = pGdata->m_dEndFeed ;
+   m_dTipFeed = pGdata->m_dTipFeed ;
+   m_bToolInvert = pGdata->m_bToolInvert ;
+   m_bInvert = pGdata->m_bInvert ;
+   m_sDepth = pGdata->m_sDepth ;
+   m_dStartPos = pGdata->m_dStartPos ;
+   m_nSubType = pGdata->m_nSubType ;
+   m_sSysNotes = pGdata->m_sSysNotes ;
+   m_sUserNotes = pGdata->m_sUserNotes ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::SameAs(const MachiningData* pMdata) const
+{
+  // se coincide con altro -> uguali
+   if ( pMdata == this)
+      return true ;
+  // se sono di tipo diverso -> diversi
+   const ProbingData* pGdata = GetProbingData( pMdata) ;
+   if ( pGdata == nullptr)
+      return false ;
+  // confronto termine a termine
+   return ( m_Uuid == pGdata->m_Uuid  &&
+            m_sName == pGdata->m_sName  &&
+            m_ToolUuid == pGdata->m_ToolUuid  &&
+            m_sToolName == pGdata->m_sToolName  &&
+            m_sBlockedAxis == pGdata->m_sBlockedAxis  &&
+            m_sInitAngs == pGdata->m_sInitAngs  &&
+            m_nSolCh == pGdata->m_nSolCh  &&
+            abs( m_dFeed - pGdata->m_dFeed) < EPS_MACH_LEN_PAR  &&
+            abs( m_dStartFeed - pGdata->m_dStartFeed) < EPS_MACH_LEN_PAR  &&
+            abs( m_dEndFeed - pGdata->m_dEndFeed) < EPS_MACH_LEN_PAR  &&
+            abs( m_dTipFeed - pGdata->m_dTipFeed) < EPS_MACH_LEN_PAR  &&
+            m_bToolInvert == pGdata->m_bToolInvert  &&
+            m_bInvert == pGdata->m_bInvert  &&
+            m_sDepth == pGdata->m_sDepth  &&
+            abs( m_dStartPos - pGdata->m_dStartPos) < EPS_MACH_LEN_PAR  &&
+            m_nSubType == pGdata->m_nSubType  &&
+            m_sSysNotes == pGdata->m_sSysNotes  &&
+            m_sUserNotes == pGdata->m_sUserNotes) ;
+}
+
+//----------------------------------------------------------------------------
+int
+ProbingData::GetSize( void) const
+{
+  // in debug verifico validità ultimo campo
+   assert( sProbingKey[KEY_UUID] == "UUID") ;
+   return KEY_ZZZ ;
+}
+//----------------------------------------------------------------------------
+string
+ProbingData::GetTitle( void) const
+{
+   return MCHDATA_GETNAME( ProbingData) ;
+}
+
+//----------------------------------------------------------------------------
+static int
+FindProbingKey( const string& sKey)
+{
+   auto TheRange = equal_range( sProbingKey.cbegin(), sProbingKey.cend(), sKey) ;
+   if ( TheRange.first == TheRange.second)
+      return - 1 ;
+   return int( TheRange.first - sProbingKey.cbegin()) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::FromString( const string& sString, int& nKey)
+{
+  // separo chiave da valore
+   string sKey, sVal ;
+   SplitFirst( sString, "=", sKey, sVal) ;
+  // riconosco la chiave
+   nKey = FindProbingKey( ToUpper( sKey)) ;
+   bool bOk = ( nKey >= 0) ;
+   switch ( nKey) {
+   case KEY_AB :
+      m_sBlockedAxis = sVal ;
+      break ;
+   case KEY_AI :
+      m_sInitAngs = sVal ;
+      break ;
+   case KEY_DH :
+      m_sDepth = sVal ;
+      if ( m_sDepth.empty())
+         m_sDepth = "0" ;
+      break ;
+   case KEY_F :
+      bOk = ::FromString( sVal, m_dFeed) ;
+      break ;
+   case KEY_FE :
+      bOk = ::FromString( sVal, m_dEndFeed) ;
+      break ;
+   case KEY_FS :
+      bOk = ::FromString( sVal, m_dStartFeed) ;
+      break ;
+   case KEY_FT :
+      bOk = ::FromString( sVal, m_dTipFeed) ;
+      break ;
+   case KEY_INV :
+      bOk = ::FromString( sVal, m_bInvert) ;
+      break ;
+   case KEY_NAME :
+      m_sName = sVal ;
+      bOk = ! m_sName.empty() ;
+      break ;
+   case KEY_NNS :
+      m_sSysNotes = sVal ;
+      break ;
+   case KEY_NNU :
+      m_sUserNotes = sVal ;
+      break ;
+   case KEY_PS :
+      bOk = ::FromString( sVal, m_dStartPos) ;
+      break ;
+   case KEY_SCC :
+      bOk = ::FromString( sVal, m_nSolCh) ;
+      break ;
+   case KEY_SUBTYPE :
+      bOk = ::FromString( sVal, m_nSubType) ;
+      break ;
+   case KEY_TNAME :
+      m_sToolName = sVal ;
+      break ;
+   case KEY_TI :
+      bOk = ::FromString( sVal, m_bToolInvert) ;
+      break ;
+   case KEY_TUUID :
+      bOk = ::FromString( sVal, m_ToolUuid) ;
+      break ;
+   case KEY_UUID :
+      bOk = ::FromString( sVal, m_Uuid) ;
+      break ;
+   default :
+      bOk = false ;
+      break ;
+   }
+   return bOk ;
+}
+
+//----------------------------------------------------------------------------
+string
+ProbingData::ToString( int nKey) const
+{
+   switch ( nKey) {
+   case KEY_AB : return ( sProbingKey[KEY_AB] + "=" +  m_sBlockedAxis) ;
+   case KEY_AI : return ( sProbingKey[KEY_AI] + "=" +  m_sInitAngs) ;
+   case KEY_DH : return ( sProbingKey[KEY_DH] + "=" + m_sDepth) ;
+   case KEY_F : return ( sProbingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ;
+   case KEY_FE : return ( sProbingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ;
+   case KEY_FS : return ( sProbingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ;
+   case KEY_FT : return ( sProbingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ;
+   case KEY_INV : return ( sProbingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
+   case KEY_NAME : return ( sProbingKey[KEY_NAME] + "=" + m_sName) ;
+   case KEY_NNS : return ( sProbingKey[KEY_NNS] + "=" + m_sSysNotes) ;
+   case KEY_NNU : return ( sProbingKey[KEY_NNU] + "=" + m_sUserNotes) ;
+   case KEY_PS : return ( sProbingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ;
+   case KEY_SCC : return ( sProbingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ;
+   case KEY_SUBTYPE : return ( sProbingKey[KEY_SUBTYPE] + "=" + ::ToString( m_nSubType)) ;
+   case KEY_TI : return ( sProbingKey[KEY_TI] + "=" + ::ToString( m_bToolInvert)) ;
+   case KEY_TNAME : return ( sProbingKey[KEY_TNAME] + "=" + m_sToolName) ;
+   case KEY_TUUID : return ( sProbingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
+   case KEY_UUID : return ( sProbingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
+   default : return "" ;
+   }
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::IsOptional( int nKey) const
+{
+   return ( nKey == KEY_AB  ||  nKey == KEY_AI  ||  nKey == KEY_TI) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::VerifySolCh( int nVal) const
+{
+   return IsValidOperationScc( nVal) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::VerifyTool( const ToolsMgr* pToolsMgr, const string& sVal, const ToolData*& pTdata) const
+{
+   if ( pToolsMgr == nullptr)
+      return false ;
+   pTdata =  pToolsMgr->GetTool( sVal) ;
+   if ( pTdata == nullptr)
+      return false ;
+   if ( ( pTdata->m_nType & TF_PROBE) == 0)
+      return false ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const
+{
+   if ( pToolsMgr == nullptr)
+      return false ;
+   pTdata = pToolsMgr->GetTool( m_ToolUuid) ;
+   return ( pTdata != nullptr) ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::SetParam( int nType, bool bVal)
+{
+   switch ( nType) {
+   case MPA_INVERT :
+      m_bInvert = bVal ;
+      return true ;
+   case MPA_TOOLINVERT :
+      m_bToolInvert = bVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::SetParam( int nType, int nVal)
+{
+   switch ( nType) {
+   case MPA_SCC :
+      if ( ! VerifySolCh( nVal))
+         return false ;
+      m_nSolCh = nVal ;
+      return true ;
+   case MPA_SUBTYPE :
+      m_nSubType = nVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::SetParam( int nType, double dVal)
+{
+   switch ( nType) {
+   case MPA_FEED :
+      m_dFeed = dVal ;
+      return true ;
+   case MPA_STARTFEED :
+      m_dStartFeed = dVal ;
+      return true ;
+   case MPA_ENDFEED :
+      m_dEndFeed = dVal ;
+      return true ;
+   case MPA_TIPFEED :
+      m_dTipFeed = dVal ;
+      return true ;
+   case MPA_DEPTH :
+      m_sDepth = ::ToString( dVal) ;
+      return true ;
+   case MPA_STARTPOS :
+      m_dStartPos = dVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::SetParam( int nType, const string& sVal)
+{
+   switch ( nType) {
+   case MPA_NAME :
+      m_sName = sVal ;
+      return true ;
+   case MPA_TOOL :
+      m_sToolName = sVal ;
+      return true ;
+   case MPA_DEPTH_STR :
+      m_sDepth = sVal ;
+      return true ;
+   case MPA_TUUID :
+      return ::FromString( sVal, m_ToolUuid) ;
+   case MPA_UUID :
+      return ::FromString( sVal, m_Uuid) ;
+   case MPA_SYSNOTES :
+      m_sSysNotes = sVal ;
+      return true ;
+   case MPA_USERNOTES :
+      m_sUserNotes = sVal ;
+      return true ;
+   case MPA_INITANGS :
+      m_sInitAngs = sVal ;
+      return true ;
+   case MPA_BLOCKEDAXIS :
+      m_sBlockedAxis = sVal ;
+      return true ;
+   }
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::ResetTool( void)
+{
+   m_sToolName.clear() ;
+   m_ToolUuid.Clear() ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::GetParam( int nType, bool& bVal) const
+{
+   switch ( nType) {
+   case MPA_INVERT :
+      bVal = m_bInvert ;
+      return true ;
+   case MPA_TOOLINVERT :
+      bVal = m_bToolInvert ;
+      return true ;
+   }
+   bVal = false ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::GetParam( int nType, int& nVal) const
+{
+   switch ( nType) {
+   case MPA_TYPE :
+      nVal = MT_PROBING ;
+      return true ;
+   case MPA_SCC :
+      nVal = m_nSolCh ;
+      return true ;
+   case MPA_SUBTYPE :
+      nVal = m_nSubType ;
+      return true ;
+   }
+   nVal = 0 ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::GetParam( int nType, double& dVal) const
+{
+   switch ( nType) {
+   case MPA_FEED :
+      dVal = m_dFeed ;
+      return true ;
+   case MPA_STARTFEED :
+      dVal = m_dStartFeed ;
+      return true ;
+   case MPA_ENDFEED :
+      dVal = m_dEndFeed ;
+      return true ;
+   case MPA_TIPFEED :
+      dVal = m_dTipFeed ;
+      return true ;
+   case MPA_STARTPOS :
+      dVal = m_dStartPos ;
+      return true ;
+   }
+   dVal = 0 ;
+   return false ;
+}
+
+//----------------------------------------------------------------------------
+bool
+ProbingData::GetParam( int nType, string& sVal) const
+{
+   switch ( nType) {
+   case MPA_NAME :
+      sVal = m_sName ;
+      return true ;
+   case MPA_TOOL :
+      sVal = m_sToolName ;
+      return true ;
+   case MPA_DEPTH_STR :
+      sVal = m_sDepth ;
+      return true ;
+   case MPA_TUUID :
+      sVal = ::ToString( m_ToolUuid) ;
+      return true ;
+   case MPA_UUID :
+      sVal = ::ToString( m_Uuid) ;
+      return true ;
+   case MPA_SYSNOTES :
+      sVal = m_sSysNotes ;
+      return true ;
+   case MPA_USERNOTES :
+      sVal = m_sUserNotes ;
+      return true ;
+   case MPA_INITANGS :
+      sVal = m_sInitAngs ;
+      return true ;
+   case MPA_BLOCKEDAXIS :
+      sVal = m_sBlockedAxis ;
+      return true ;
+   }
+   sVal = "" ;
+   return false ;
+}

ProbingData.h

@@ -0,0 +1,73 @@
+//----------------------------------------------------------------------------
+//  EgalTech 2025-2025
+//----------------------------------------------------------------------------
+// File : ProbingData.h      Data : 09.06.25          Versione : 2.7f2
+// Contenuto : Dichiarazione della struct ProbingData e costanti associate.
+//
+//
+//
+// Modifiche : 09.06.25 DS Creazione modulo.
+//
+//
+//----------------------------------------------------------------------------
+
+#pragma once
+
+#include "MachiningData.h"
+
+//----------------------------------------------------------------------------
+struct ProbingData : public MachiningData
+{
+   EgtUUID     m_ToolUuid ;        // identificativo universale dell'utensile
+   std::string m_sToolName ;       // nome dell'utensile
+   std::string m_sInitAngs ;       // angoli iniziali suggeriti (Nome1=val1,Nome2=val2)
+   std::string m_sBlockedAxis ;    // eventuale asse rotante bloccato (Nome=val)
+   int         m_nSolCh ;          // criterio scelta soluzione (quando possibili molteplici)
+   double      m_dFeed ;           // velocità di lavorazione normale  ( se 0 da utensile)
+   double      m_dStartFeed ;      // velocità di lavorazione iniziale  ( se 0 da utensile)
+   double      m_dEndFeed ;        // velocità di lavorazione finale  ( se 0 da utensile)
+   double      m_dTipFeed ;        // velocità di lavorazione di sfondamento  ( se 0 da utensile)
+   bool        m_bToolInvert ;     // flag per inversione direzione utensile da geometria
+   bool        m_bInvert ;         // flag di inversione direzione lavorazione
+   std::string m_sDepth ;          // affondamento (espressione numerica)
+   double      m_dStartPos ;       // quota di inizio lavorazione (sempre >= 0)
+   int         m_nSubType ;        // da [Probing] di Ini di macchina
+   std::string m_sSysNotes ;       // note interne
+   std::string m_sUserNotes ;      // note dell'utente
+
+   ProbingData( void)
+      : m_ToolUuid(), m_nSolCh( 0), m_dFeed( 0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0),
+        m_bToolInvert( false), m_bInvert( false), m_dStartPos( 0), m_nSubType( 0) {}
+   ProbingData* Clone( void) const override ;
+   bool CopyFrom( const MachiningData* pMdata) override ;
+   bool SameAs(const MachiningData* pMdata) const override  ;
+   int  GetType( void) const override
+           { return MT_PROBING ; }
+   int  GetSize( void) const override ;
+   std::string GetTitle( void) const override ;
+   bool FromString( const std::string& sString, int& nKey) override ;
+   std::string ToString( int nKey) const override ;
+   bool IsOptional( int nKey) const override ;
+   bool SetParam( int nType, bool bVal) override ;
+   bool SetParam( int nType, int nVal) override ;
+   bool SetParam( int nType, double dVal) override ;
+   bool SetParam( int nType, const std::string& sVal) override ;
+   bool ResetTool( void) override ;
+   bool GetParam( int nType, bool& bVal) const override ;
+   bool GetParam( int nType, int& nVal) const override ;
+   bool GetParam( int nType, double& dVal) const override ;
+   bool GetParam( int nType, std::string& sVal) const override ;
+   bool GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const override ;
+   bool VerifyTool( const ToolsMgr* pToolsMgr, const std::string& sVal, const ToolData*& pTdata) const override ;
+   bool VerifySolCh( int nVal) const ;
+} ;
+
+//----------------------------------------------------------------------------
+inline const ProbingData* GetProbingData( const MachiningData* pMdata)
+               { if ( pMdata == nullptr  ||  pMdata->GetType() != MT_PROBING)
+                    return nullptr ;
+                 return ( static_cast<const ProbingData*>( pMdata)) ; }
+inline ProbingData* GetProbingData( MachiningData* pMdata)
+               { if ( pMdata == nullptr  ||  pMdata->GetType() != MT_PROBING)
+                    return nullptr ;
+                 return ( static_cast<ProbingData*>( pMdata)) ; }

Processor.cpp

@@ -29,11 +29,8 @@
 using namespace std ;
 
 //------------------------------ Errors --------------------------------------
-// 1001 = "Error with setup : xxx"
-// 1002 = "Error opening Cnc file"
-
-//----------------------------------------------------------------------------
-static const string ERR_EXT = ".err" ;
+// 1002 = "Error with setup : xxx"
+// 1003 = "Error opening Cnc file"
 
 //----------------------------------------------------------------------------
 Processor::Processor( void)
@@ -318,7 +315,7 @@ Processor::ProcessMachining( int nOpId, int nOpInd)
       return false ;
 
   // Verifico non sia vuota
-   if ( m_pMchMgr->IsMachiningEmpty())
+   if ( m_pMchMgr->IsMachiningEmpty( NEED_ONE_TP_OK))
       return true ;
 
   // Recupero l'utensile della lavorazione corrente

SawFinishing.cpp

@@ -4,7 +4,7 @@
 // File : SawFinishing.cpp       Data : 23.04.19          Versione : 2.1d3
 // Contenuto : Implementazione gestione finitura superficie con lama.
 //
-// Note : Questa lavorazione è sempre espressa nel riferimento globale.
+// Note : Questa lavorazione è sempre espressa nel riferimento globale.
 //
 // Modifiche : 05.04.16 DS Creazione modulo.
 //             23.04.19 DS Aggiunte cornici curve.
@@ -51,6 +51,7 @@ using namespace std ;
 // 2713 = "Error in SawFinishing : link movements not calculable"
 // 2714 = "Error in SawFinishing : link outstroke xx"
 // 2715 = "Error in SawFinishing : post apply not calculable"
+// 2716 = "Error in SawFinishing : special apply not calculable"
 // 2751 = "Warning in SawFinishing : Skipped entity (xx)"
 // 2752 = "Warning in SawFinishing : No machinable path"
 // 2753 = "Warning in SawFinishing : Tool name changed (xx)"
@@ -446,14 +447,15 @@ SawFinishing::SetParam( int nType, const string& sVal)
 bool
 SawFinishing::SetGeometry( const SELVECTOR& vIds)
 {
-  // verifico validità gestore DB geometrico
+  // verifico validità gestore DB geometrico
    if ( m_pGeomDB == nullptr)
       return false ;
-  // reset della geometria corrente
+  // copia temporanea e reset della geometria corrente
+   SELVECTOR vOldId = m_vId ;
    m_vId.clear() ;
-  // verifico che gli identificativi rappresentino delle entità ammissibili
+  // verifico che gli identificativi rappresentino delle entità ammissibili
    for ( const auto& Id : vIds) {
-     // test sull'entità
+     // test sull'entità
       int nSubs ;
       if ( ! VerifyGeometry( Id, nSubs)) {
          string sInfo = "Warning in SawFinishing : Skipped entity " + ToString( Id) ;
@@ -464,7 +466,8 @@ SawFinishing::SetGeometry( const SELVECTOR& vIds)
       m_vId.emplace_back( Id) ;
    }
   // aggiorno lo stato
-   m_nStatus |= MCH_ST_GEO_MODIF ;
+   if ( m_vId != vOldId)
+      m_nStatus |= MCH_ST_GEO_MODIF ;
   // restituisco presenza geometria da lavorare
    return ( ! m_vId.empty()) ;
 }
@@ -485,20 +488,22 @@ SawFinishing::Apply( bool bRecalc, bool bPostApply)
    int nCurrCuts = m_nCuts ;
    m_nCuts = 0 ;
 
-  // verifico validità gestore DB geometrico e Id del gruppo
+  // verifico validità gestore DB geometrico e Id del gruppo
    if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
       return false ;
 
   // aggiorno dati geometrici dell'utensile
-   bool bToolChanged = true ;
-   if ( ! UpdateToolData( &bToolChanged)) {
+   if ( ! UpdateToolData()) {
       m_pMchMgr->SetLastError( 2701, "Error in SawFinishing : UpdateToolData failed") ;
       return false ;
    }
 
+  // se modificata geometria, necessario ricalcolo
+   if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
+      bRecalc = true ;
+
   // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ! bToolChanged  &&  
-        ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
+   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
      // confermo i percorsi di lavorazione
       m_nCuts = nCurrCuts ;
       string sLog = string( "SawFinishing apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
@@ -515,7 +520,7 @@ SawFinishing::Apply( bool bRecalc, bool bPostApply)
 
   // recupero gruppo per geometria ausiliaria
    int nAuxId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_AUX) ;
-  // se non c'è, lo aggiungo
+  // se non c'è, lo aggiungo
    if ( nAuxId == GDB_ID_NULL) {
       nAuxId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
       if ( nAuxId == GDB_ID_NULL)
@@ -537,7 +542,7 @@ SawFinishing::Apply( bool bRecalc, bool bPostApply)
 
   // recupero gruppo per geometria di lavorazione (Cutter Location)
    int nClId = m_pGeomDB->GetFirstNameInGroup( m_nOwnerId, MCH_CL) ;
-  // se non c'è, lo aggiungo
+  // se non c'è, lo aggiungo
    if ( nClId == GDB_ID_NULL) {
       nClId = m_pGeomDB->AddGroup( GDB_ID_NULL, m_nOwnerId, Frame3d()) ;
       if ( nClId == GDB_ID_NULL)
@@ -584,7 +589,7 @@ SawFinishing::Apply( bool bRecalc, bool bPostApply)
   // eseguo aggiornamento assi macchina e collegamento con operazione precedente
    if ( ! Update( bPostApply))
       return false ;
-  
+
   // aggiorno stato della lavorazione
    m_nStatus = ( bPostApply ? MCH_ST_OK : MCH_ST_NO_POSTAPPL) ;
   // dichiaro successiva da aggiornare
@@ -599,7 +604,7 @@ SawFinishing::Apply( bool bRecalc, bool bPostApply)
 bool
 SawFinishing::Update( bool bPostApply)
 {
-  // verifico validità gestore DB geometrico e Id del gruppo
+  // verifico validità gestore DB geometrico e Id del gruppo
    if ( m_pGeomDB == nullptr  ||  ! m_pGeomDB->ExistsObj( m_nOwnerId))
       return false ;
 
@@ -609,7 +614,7 @@ SawFinishing::Update( bool bPostApply)
       return true ;
    }
 
-  // elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo) 
+  // elimino le entità CLIMB, RISE e HOME della lavorazione, potrebbero falsare i calcoli degli assi (in ogni casi vengono riaggiunte dopo) 
    RemoveClimbRiseHome() ;
 
   // imposto eventuale asse bloccato da lavorazione
@@ -628,6 +633,19 @@ SawFinishing::Update( bool bPostApply)
       return false ;
    }
 
+  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+   CalcAndSetAxesBBox() ;
+
+  // esecuzione eventuali personalizzazioni speciali
+   string sSpecErr ;
+   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
+      if ( ! IsEmptyOrSpaces( sSpecErr))
+         m_pMchMgr->SetLastError( 2716, sSpecErr) ;
+      else
+         m_pMchMgr->SetLastError( 2716, "Error in SawFinishing : special apply not calculable") ;
+      return false ;
+   }
+
   // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
    if ( ! AdjustStartEndMovements()) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
@@ -638,14 +656,11 @@ SawFinishing::Update( bool bPostApply)
       return false ;
    }
 
-  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
-   CalcAndSetAxesBBox() ;
-
-  // esecuzione eventuali personalizzazioni
-   string sErr ;
-   if ( bPostApply  &&  ! PostApply( sErr)) {
-      if ( ! IsEmptyOrSpaces( sErr))
-         m_pMchMgr->SetLastError( 2715, sErr) ;
+  // esecuzione eventuali personalizzazioni finali
+   string sPostErr ;
+   if ( bPostApply  &&  ! PostApply( sPostErr)) {
+      if ( ! IsEmptyOrSpaces( sPostErr))
+         m_pMchMgr->SetLastError( 2715, sPostErr) ;
       else
          m_pMchMgr->SetLastError( 2715, "Error in SawFinishing : post apply not calculable") ;
       return false ;
@@ -790,7 +805,7 @@ SawFinishing::GetToolData( void) const
 
 //----------------------------------------------------------------------------
 bool
-SawFinishing::UpdateToolData( bool* pbChanged)
+SawFinishing::UpdateToolData( void)
 {
   // recupero il gestore DB utensili della macchina corrente
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
@@ -841,9 +856,9 @@ SawFinishing::UpdateToolData( bool* pbChanged)
                      m_Params.m_sToolName + ")" ;
       m_pMchMgr->SetWarning( 2754, sInfo) ;
    }
-  // se definito parametro di ritorno, lo assegno
-   if ( pbChanged != nullptr)
-      *pbChanged = bChanged ;
+  // se modificato, aggiusto lo stato
+   if ( bChanged)
+      m_nStatus = MCH_ST_TO_VERIFY ;
    return true ;
 }
 
@@ -851,7 +866,7 @@ SawFinishing::UpdateToolData( bool* pbChanged)
 bool
 SawFinishing::GetGeometry( SELVECTOR& vIds) const
 {
-  // restituisco l'elenco delle entità
+  // restituisco l'elenco delle entità
    vIds = m_vId ;
    return true ;
 }
@@ -946,7 +961,7 @@ SawFinishing::GetCurve( SelData Id)
 bool
 SawFinishing::AdjustGeometry( int nAuxId)
 {
-  // sgrossatura di cornici diritte : due o più curve (sezioni e guida rettilinea)
+  // sgrossatura di cornici diritte : due o più curve (sezioni e guida rettilinea)
   // sgrossatura di cornici curve : due curve (sezione e guida curva)
    size_t nCrvCount = m_vId.size() ;
    if ( nCrvCount >= 2) {
@@ -970,7 +985,7 @@ SawFinishing::AdjustGeometry( int nAuxId)
                return false ;
          }
       }
-     // l'ultima curva è la guida
+     // l'ultima curva è la guida
       PtrOwner<ICurve> pGuide( GetCurve( m_vId[nCrvCount-1])) ;
       if ( IsNull( pGuide))
          return false ;
@@ -1184,7 +1199,7 @@ SawFinishing::CalculateStraightAlongToolPath( int nAuxId, int nClId)
          }
       }
    }
-  // se c'è qualcosa in sospeso
+  // se c'è qualcosa in sospeso
    if ( nStatus != CCL_VERT) {
       bSkipMax = false ;
       bool bInvert = ( nStatus == CCL_RISE) ;
@@ -1377,7 +1392,7 @@ SawFinishing::CalculateCurvedAlongToolPath( int nAuxId, int nClId)
   // recupero il suo riferimento
    Frame3d frGdL ;
    m_pGeomDB->GetGlobFrame( nGuideId, frGdL) ;
-  // porto la curva in globale (dovrebbe già avere riferimento globale)
+  // porto la curva in globale (dovrebbe già avere riferimento globale)
    pGuide->ToGlob( frGdL) ;
   // recupero il box globale della linea guida
    BBox3d b3Guide ;
@@ -1492,7 +1507,7 @@ SawFinishing::CalculateCurvedAlongToolPath( int nAuxId, int nClId)
          }
       }
    }
-  // se c'è qualcosa in sospeso
+  // se c'è qualcosa in sospeso
    if ( nStatus != CCL_VERT) {
       bSkipMax = false ;
       bool bInvert = ( nStatus == CCL_RISE) ;
@@ -1536,7 +1551,7 @@ SawFinishing::CalculateCurvedAcrossToolPath( int nAuxId, int nClId)
   // recupero il suo riferimento
    Frame3d frGdL ;
    m_pGeomDB->GetGlobFrame( nGuideId, frGdL) ;
-  // porto la curva in globale (dovrebbe già avere riferimento globale)
+  // porto la curva in globale (dovrebbe già avere riferimento globale)
    pGuide->ToGlob( frGdL) ;
   // recupero il box globale della linea guida
    BBox3d b3Guide ;
@@ -1639,7 +1654,7 @@ SawFinishing::CalculateCurvedAcrossToolPath( int nAuxId, int nClId)
       vtCorr.Rotate( Z_AX, dAngRotDeg - 90) ;
      // flag di inizio
       bool bFirst = ( dLen < EPS_SMALL) ;
-     // se non è inizio
+     // se non è inizio
       bool bCorner = false ;
       Vector3d vtPrev ;
       if ( ! bFirst) {
@@ -1780,7 +1795,7 @@ SawFinishing::CalculateSection( int nSectGrpId, ICurve*& pSect)
 bool
 SawFinishing::TrimSection( ICurve* pCrv)
 {
-  // se parametri di accorciamento iniziale e finale sono nulli, non faccio alcunché
+  // se parametri di accorciamento iniziale e finale sono nulli, non faccio alcunché
    if ( m_Params.m_dStartAddLen > - EPS_SMALL  &&  m_Params.m_dEndAddLen > -EPS_SMALL)
       return true ;
 
@@ -1833,7 +1848,7 @@ SawFinishing::CalculateGuideLine( int nGuideId, const BBox3d& b3Sect,
   // recupero il suo riferimento
    Frame3d frGdL ;
    m_pGeomDB->GetGlobFrame( nGuideId, frGdL) ;
-  // porto la curva in globale (dovrebbe già avere riferimento globale)
+  // porto la curva in globale (dovrebbe già avere riferimento globale)
    pGuide->ToGlob( frGdL) ;
   // recupero gli estremi della linea guida
    pGuide->GetStartPoint( ptGdStart) ;
@@ -2216,14 +2231,14 @@ SawFinishing::CalcAlongZigZagCut( const Point3d& ptStart, const Point3d& ptEnd,
             if ( AddLinearMove( ptNewStart) == GDB_ID_NULL)
                return false ;
          }
-        // se il precedente è più fuori
+        // se il precedente è più fuori
          else if ( dDiff > 0) {
            // allungo nuova passata
             SetFeed( ( bVert ? GetVertFeed() : GetFeed())) ;
             if ( AddLinearMove( ptNewStart - dDiff * vtNewDir) == GDB_ID_NULL)
                return false ;
          }
-        // se il corrente è più fuori
+        // se il corrente è più fuori
          else {
            // allungo passata precedente
             if ( AddLinearMove( ptLast + dDiff * vtNewDir) == GDB_ID_NULL)
@@ -2592,7 +2607,7 @@ SawFinishing::CalcCurvedAlongZigZagCut( const ICurve* pCut, const Vector3d& vtTo
       GetCurrPos( ptCurr) ;
      // differenza tra corrente e nuovo lungo direzione ortogonale
       double dOrtStartDiff = ( ptNewStart - ptCurr) * vtOrtStart ;
-     // se punto corrente più fuori, aggiungo punto fuori allo stesso modo sul nuovo
+     // se punto corrente più fuori, aggiungo punto fuori allo stesso modo sul nuovo
       if ( dOrtStartDiff < - 10 * EPS_SMALL) {
          Point3d ptOut = ptNewStart + ( - dOrtStartDiff * vtOrtStart) ;
          SetFlag( 0) ;
@@ -2600,7 +2615,7 @@ SawFinishing::CalcCurvedAlongZigZagCut( const ICurve* pCut, const Vector3d& vtTo
          if ( ! SameAsCurrPos( ptOut)  &&  AddLinearMove( ptOut) == GDB_ID_NULL)
             return false ;
       }
-     // se altrimenti più dentro, aggiungo punto fuori allo stesso modo sul corrente
+     // se altrimenti più dentro, aggiungo punto fuori allo stesso modo sul corrente
       else if ( dOrtStartDiff > 10 * EPS_SMALL) {
          Point3d ptOut = ptCurr + ( dOrtStartDiff * vtOrtStart) ;
          SetFlag( 0) ;
@@ -2635,14 +2650,14 @@ SawFinishing::CalcCurvedAlongZigZagCut( const ICurve* pCut, const Vector3d& vtTo
             if ( AddLinearMove( ptNewStart) == GDB_ID_NULL)
                return false ;
          }
-        // se il precedente è più fuori
+        // se il precedente è più fuori
          else if ( dDiff > 0) {
            // allungo nuova passata
             SetFeed( ( bVert ? GetVertFeed() : GetFeed())) ;
             if ( AddLinearMove( ptNewStart - dDiff * vtDirStart) == GDB_ID_NULL)
                return false ;
          }
-        // se il corrente è più fuori
+        // se il corrente è più fuori
          else {
            // allungo passata precedente
             if ( AddLinearMove( ptLast + dDiff * vtDirStart) == GDB_ID_NULL)
@@ -2654,7 +2669,7 @@ SawFinishing::CalcCurvedAlongZigZagCut( const ICurve* pCut, const Vector3d& vtTo
          }
       }
    }
-   // se non ci sono già, vado all'inizio dell'arco
+   // se non ci sono già, vado all'inizio dell'arco
    if ( ! SameAsCurrPos( ptStart)  &&  AddLinearMove( ptStart) == GDB_ID_NULL)
       return false ;
   // 3 -> movimento di lato al punto finale
@@ -2816,7 +2831,7 @@ SawFinishing::AddCornerApproach( const Point3d& ptP, const Vector3d& vtCorr, con
 {
   // impongo minima distanza di approccio
    dAppr = max( dAppr, 1.0) ;
-  // recupero posizione precedente (correzione precedente è passata perchè già impostata la nuova)
+  // recupero posizione precedente (correzione precedente è passata perchè già impostata la nuova)
    Point3d ptPrev ;
    if ( ! GetCurrPos( ptPrev))
       return false ;
@@ -2927,7 +2942,7 @@ SawFinishing::GetHeightOnSection( const ICurve* pSect, double dX, double dYmin,
       dY = aInfo.IciA[0].ptI.y ;
       return true ;
    }
-  // se non c'è intersezione assegno il minimo
+  // se non c'è intersezione assegno il minimo
    dY = dYmin ;
    return true ;
 }

SawFinishing.h

@@ -38,8 +38,14 @@ class SawFinishing : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_SAWFINISHING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nCuts == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nCuts == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -62,7 +68,7 @@ class SawFinishing : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 

SawRoughing.h

@@ -38,8 +38,14 @@ class SawRoughing : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_SAWROUGHING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nCuts == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nCuts == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -62,7 +68,7 @@ class SawRoughing : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 
@@ -73,19 +79,24 @@ class SawRoughing : public Machining
       bool VerifyGeometry( SelData Id, int& nSubs) ;
       ICurve* GetCurve( SelData Id) ;
       bool AdjustGeometry( int nAuxId) ;
-      bool CalculateToolPath( int nAuxId, int nClId) ;
+      bool CalculateToolPath( int nAuxId, int nPvId, int nClId) ;
       bool CalculateCurvedToolPath( int nAuxId, int nClId) ;
+      bool GeneratePreView( int nPathId, const ICurve* pSect, const Frame3d& frSect, double dGuideLen,
+                            const Vector3d& vtGdDir, const BBox3d& b3Raw) ;
       bool CalculateSection( int nSectGrpId, ICurve*& pSect) ;
       bool TrimSection( ICurve* pCrv) ;
-      bool CalculateGuideLine( int nGuideId, const BBox3d& b3Sect,
-                               Point3d& ptGdStart, Point3d& ptGdEnd, Vector3d& vtGdDir) ;
+      bool CalculateGuideLine( int nGuideId, const BBox3d& b3Sect, Point3d& ptGdStart, Point3d& ptGdEnd, Vector3d& vtGdDir) ;
+      bool AdaptGuideLineToRaw( Point3d& ptGdStart, Point3d& ptGdEnd, const Vector3d& vtGdDir, const BBox3d& b3Raw) const ;
       bool CalculateOneWayCut( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtDir,
-                               const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, bool bFirst, bool bLast) ;
+                               const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, bool bFirst, bool bLast, const BBox3d& b3Raw) ;
       bool CalculateZigZagCut( const Point3d& ptStart, const Point3d& ptEnd, const Vector3d& vtDir,
                                const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, bool bFirst, bool bLast,
-                               int& nCount) ;
+                               int& nCount, const BBox3d& b3Raw) ;
+      bool CalculateZConstCut( const ICurve* pCrv, double dXmin, double dXmax, bool bIncludeMax, bool bIncludeMin, 
+                               const Point3d& ptGdStart, const Point3d& ptGdEnd, const Vector3d& vtGdDir, const Frame3d& frSect, 
+                               const BBox3d& b3Raw, double dDepth, bool bFirstInterval, bool bLastInterval, int& nCount) ;
       bool CalculateCurvedZigZagCut( const ICurve* pCut, const Vector3d& vtTool, double dElev, bool bFirst, bool bLast,
-                                     int& nCount) ;
+                                     int& nCount) ;     
       bool AddApproach( const Point3d& ptP, const Vector3d& vtCorr, bool bFirst,
                         double dSafeZ, double dElev, double dAppr) ;
       bool AddRetract( const Point3d& ptP, const Vector3d& vtCorr, double dSafeZ, double dElev, double dAppr) ;
@@ -112,7 +123,7 @@ class SawRoughing : public Machining
          { return ( IsUnknownValue( m_Params.m_dOffsR) ? m_TParams.m_dOffsR : m_Params.m_dOffsR) ; }
 
    private :
-      SELVECTOR        m_vId ;             // identificativi entità geometriche da lavorare
+      SELVECTOR        m_vId ;             // identificativi entità geometriche da lavorare
       bool             m_bStraight ;       // flag per cornici diritte/curve
       SawRoughingData  m_Params ;          // parametri lavorazione
       ToolData         m_TParams ;         // parametri utensile

Sawing.cpp

@@ -18,6 +18,7 @@
 #include "Sawing.h"
 #include "GeoConst.h"
 #include "OperationConst.h"
+#include "OperUserNotesConst.h"
 #include "/EgtDev/Include/EXeCmdLogOff.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
@@ -56,6 +57,7 @@ using namespace std ;
 // 2217 = "Error in Sawing : link movements not calculable"
 // 2218 = "Error in Sawing : link outstroke xxx"
 // 2219 = "Error in Sawing : post apply not calculable"
+// 2220 = "Error in Sawing : special apply not calculable"
 // 2251 = "Warning in Sawing : Skipped entity xxx"
 // 2252 = "Warning in Sawing : No machinable path"
 // 2253 = "Warning in Sawing : Tool name changed (xx)"
@@ -538,7 +540,8 @@ Sawing::SetGeometry( const SELVECTOR& vIds)
   // verifico validità gestore DB geometrico
    if ( m_pGeomDB == nullptr)
       return false ;
-  // reset della geometria corrente
+  // copia temporanea e reset della geometria corrente
+   SELVECTOR vOldId = m_vId ;
    m_vId.clear() ;
   // verifico che gli identificativi rappresentino delle entità ammissibili
    int nType = GEO_NONE ;
@@ -554,7 +557,8 @@ Sawing::SetGeometry( const SELVECTOR& vIds)
       m_vId.emplace_back( Id) ;
    }
   // aggiorno lo stato
-   m_nStatus |= MCH_ST_GEO_MODIF ;
+   if ( m_vId != vOldId)
+      m_nStatus |= MCH_ST_GEO_MODIF ;
   // restituisco presenza geometria da lavorare
    return ( ! m_vId.empty()  ||  vIds.empty()) ;
 }
@@ -641,15 +645,17 @@ Sawing::Apply( bool bRecalc, bool bPostApply)
       return false ;
 
   // aggiorno dati geometrici dell'utensile
-   bool bToolChanged = true ;
-   if ( ! UpdateToolData( &bToolChanged)) {
+   if ( ! UpdateToolData()) {
       m_pMchMgr->SetLastError( 2201, "Error in Sawing : UpdateToolData failed") ;
       return false ;
    }
 
+  // se modificata geometria, necessario ricalcolo
+   if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
+      bRecalc = true ;
+
   // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ! bToolChanged  &&  
-        ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
+   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
      // confermo i percorsi di lavorazione
       m_nCuts = nCurrCuts ;
       string sLog = string( "Sawing apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
@@ -694,7 +700,7 @@ Sawing::Apply( bool bRecalc, bool bPostApply)
 
   // verifiche per attacchi/uscite senza approcci e retrazioni
    int nDownSE = 0 ;
-   GetValInNotes( m_Params.m_sUserNotes, "DownSE", nDownSE) ;
+   GetValInNotes( m_Params.m_sUserNotes, UN_DOWNSE, nDownSE) ;
    m_bDownSE = ( nDownSE != 0  &&  m_Params.m_nStepType == SAW_ST_TOANDFROM) ;
 
   // recupero gruppo per geometria di lavorazione (Cutter Location)
@@ -777,6 +783,16 @@ Sawing::Update( bool bPostApply)
   // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
    CalcAndSetAxesBBox() ;
 
+  // esecuzione eventuali personalizzazioni speciali
+   string sSpecErr ;
+   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
+      if ( ! IsEmptyOrSpaces( sSpecErr))
+         m_pMchMgr->SetLastError( 2220, sSpecErr) ;
+      else
+         m_pMchMgr->SetLastError( 2220, "Error in Sawing : special apply not calculable") ;
+      return false ;
+   }
+
   // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
    if ( ! AdjustStartEndMovements()) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
@@ -787,11 +803,11 @@ Sawing::Update( bool bPostApply)
       return false ;
    }
 
-  // esecuzione eventuali personalizzazioni
-   string sErr ;
-   if ( bPostApply  &&  ! PostApply( sErr)) {
-      if ( ! IsEmptyOrSpaces( sErr))
-         m_pMchMgr->SetLastError( 2219, sErr) ;
+  // esecuzione eventuali personalizzazioni finali
+   string sPostErr ;
+   if ( bPostApply  &&  ! PostApply( sPostErr)) {
+      if ( ! IsEmptyOrSpaces( sPostErr))
+         m_pMchMgr->SetLastError( 2219, sPostErr) ;
       else
          m_pMchMgr->SetLastError( 2219, "Error in Sawing : post apply not calculable") ;
       return false ;
@@ -1028,7 +1044,7 @@ Sawing::GetToolData( void) const
 
 //----------------------------------------------------------------------------
 bool
-Sawing::UpdateToolData( bool* pbChanged)
+Sawing::UpdateToolData( void)
 {
   // recupero il gestore DB utensili della macchina corrente
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
@@ -1075,9 +1091,9 @@ Sawing::UpdateToolData( bool* pbChanged)
                     m_Params.m_sToolName + ")" ;
       m_pMchMgr->SetWarning( 2254, sInfo) ;
    }
-  // se definito parametro di ritorno, lo assegno
-   if ( pbChanged != nullptr)
-      *pbChanged = bChanged ;
+  // se modificato, aggiusto lo stato
+   if ( bChanged)
+      m_nStatus = MCH_ST_TO_VERIFY ;
    return true ;
 }
 
@@ -1255,7 +1271,7 @@ Sawing::GetCurve( SelData Id)
       pCrvCompo->ToGlob( frGlob) ;
       vtN.ToGlob( frGlob) ;
      // sistemazioni varie
-      AdjustCurveFromSurf( pCrvCompo, TOOL_ORTUP, FACE_DOWN, V_NULL, 0, 1) ;
+      AdjustCurveFromSurf( pCrvCompo, TOOL_ORTUP, FACE_DOWN, V_NULL, {}, 0, 1) ;
      // aggiusto lato lavoro e inverti, angolo di fianco e lato mandrino
       if ( m_Params.m_nWorkSide == SAW_WS_CENTER)
          m_Params.m_nWorkSide = SAW_WS_RIGHT ;
@@ -1304,7 +1320,7 @@ Sawing::GetCurve( SelData Id)
       pCrvCompo->ToGlob( frGlob) ;
       vtN.ToGlob( frGlob) ;
      // sistemazioni varie
-      AdjustCurveFromSurf( pCrvCompo, TOOL_ORTUP, FACE_DOWN, V_NULL, 0, 1) ;
+      AdjustCurveFromSurf( pCrvCompo, TOOL_ORTUP, FACE_DOWN, V_NULL, {}, 0, 1) ;
      // aggiusto lato lavoro e inverti, angolo di fianco e lato mandrino
       if ( m_Params.m_nWorkSide == SAW_WS_CENTER)
          m_Params.m_nWorkSide = SAW_WS_RIGHT ;
@@ -1587,6 +1603,15 @@ Sawing::ProcessPath( int nPathId, int nPvId, int nClId)
    double dThick ;
    pCompo->GetThickness( dThick) ;
 
+  // aggiusto eventuali normali inverse di archi rispetto ad estrusione
+   const ICurve* pCrv = pCompo->GetFirstCurve() ;
+   while ( pCrv != nullptr) {
+      const ICurveArc* pArc = GetCurveArc( pCrv) ;
+      if ( pArc != nullptr  &&  pArc->GetNormVersor() * vtExtr < 0)
+         const_cast<ICurveArc*>(pArc)->InvertN() ;
+      pCrv = pCompo->GetNextCurve() ;
+   }
+
   // recupero distanza da fondo dei grezzi interessati dal percorso
    double dRbDist, dAllRbDist ;
    double dToler = 2 * m_TParams.m_dThick + tan( abs( m_Params.m_dSideAngle) * DEGTORAD) * m_TParams.m_dMaxMat ;
@@ -1864,8 +1889,8 @@ Sawing::ProcessLine( const ICurve* pCrvP, const ICurveLine* pLineC, const ICurve
   // Eventuale variazioni di velocità all'inizio e alla fine del percorso
    FseVar FvVar ;
    if ( pCrvP == nullptr) {
-      string sFsta = ExtractInfo( m_Params.m_sUserNotes, "Fsta=") ;
-      if ( ! sFsta.empty()) {
+      string sFsta ;
+      if ( GetValInNotes( m_Params.m_sUserNotes, UN_FSTA, sFsta)) {   
          string sLen, sPu ;
          SplitFirst( sFsta, ",", sLen, sPu) ;
          if ( FromString( sLen, FvVar.dLenStart))
@@ -1875,8 +1900,8 @@ Sawing::ProcessLine( const ICurve* pCrvP, const ICurveLine* pLineC, const ICurve
       }
    }
    if ( pCrvN == nullptr) {
-      string sFend = ExtractInfo( m_Params.m_sUserNotes, "Fend=") ;
-      if ( ! sFend.empty()) {
+      string sFend ;
+      if ( GetValInNotes( m_Params.m_sUserNotes, UN_FEND, sFend)) {   
          string sLen, sPu ;
          SplitFirst( sFend, ",", sLen, sPu) ;
          if ( FromString( sLen, FvVar.dLenEnd))
@@ -1889,10 +1914,10 @@ Sawing::ProcessLine( const ICurve* pCrvP, const ICurveLine* pLineC, const ICurve
   // recupero eventuali estensioni dei baffi (whiskers)
    double dStartWhiskExt = 0 ;
    if ( m_Params.m_nLeadInType == SAW_LI_CENT)
-      GetValInNotes( m_Params.m_sUserNotes, "SWE", dStartWhiskExt) ;
+      GetValInNotes( m_Params.m_sUserNotes, UN_SWE, dStartWhiskExt) ;
    double dEndWhiskExt = 0 ;
    if ( m_Params.m_nLeadOutType == SAW_LO_CENT)
-      GetValInNotes( m_Params.m_sUserNotes, "EWE", dEndWhiskExt) ;
+      GetValInNotes( m_Params.m_sUserNotes, UN_EWE, dEndWhiskExt) ;
 
   // Se richiesto Preview
    if ( nPvId != GDB_ID_NULL) {
@@ -2141,6 +2166,15 @@ Sawing::GenerateLineCl( const ICurveLine* pLine, const Vector3d& vtTool, const V
    double dActLstep = GetStepLast() ;
   // direzione della linea
    Vector3d vtDir ; pLine->GetStartDir( vtDir) ;
+  // parametri per partenza/arrivo a feed ridotta
+   double dCutLen ; pLine->GetLength( dCutLen) ;
+   double dStartFraz = FvVar.dLenStart / dCutLen ;
+   double dEndFraz = FvVar.dLenEnd / dCutLen ;
+   if ( dStartFraz + dEndFraz > 1) {
+      dStartFraz /= ( dStartFraz + dEndFraz) ;
+      dEndFraz = 1 - dStartFraz ;
+   }
+   double dMidFraz = 1 - dEndFraz ;
 
   // Se una sola passata
    if ( m_Params.m_nStepType != SAW_ST_TOANDFROM  &&
@@ -2189,16 +2223,6 @@ Sawing::GenerateLineCl( const ICurveLine* pLine, const Vector3d& vtTool, const V
       }
      // 3 -> movimento di lato al punto finale
       if ( FvVar.dLenStart > EPS_SMALL  ||  FvVar.dLenEnd > EPS_SMALL) {
-        // lunghezza del taglio
-         double dCutLen ; pLine->GetLength( dCutLen) ;
-         double dStartFraz = FvVar.dLenStart / dCutLen ;
-         double dEndFraz = FvVar.dLenEnd / dCutLen ;
-         double dMidFraz = 1 - dEndFraz ;
-         if ( dStartFraz + dEndFraz > 1) {
-            dStartFraz /= ( dStartFraz + dEndFraz) ;
-            dEndFraz = 1 - dStartFraz ;
-            dMidFraz = dStartFraz ;
-         }
         // punto finale
          Point3d ptP3 = pLine->GetEnd() ;
         // 3a -> eventuale movimento di lato a feed ridotta di inizio percorso
@@ -2274,9 +2298,38 @@ Sawing::GenerateLineCl( const ICurveLine* pLine, const Vector3d& vtTool, const V
          if ( AddLinearMove( ptP2) == GDB_ID_NULL)
             return false ;
         // movimento di lato
-         SetFeed( ( ! bSideAng ? ( i == 0 ? GetBackFeed() : GetFeed()) : GetSideAngFeed())) ;
-         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
-            return false ;
+         double dCurrFeed = ( ! bSideAng ? ( i == 0 ? GetBackFeed() : GetFeed()) : GetSideAngFeed()) ;
+         if ( FvVar.dLenStart > EPS_SMALL  ||  FvVar.dLenEnd > EPS_SMALL) {
+           // scambio opportunamente le frazioni (dispari vanno, pari tornano)
+            double dCurrStartFraz = dStartFraz ;
+            double dCurrEndFraz = dEndFraz ;
+            if ( IsEven( i))
+               swap( dCurrStartFraz, dCurrEndFraz) ;
+            double dCurrMidFraz = 1 - dCurrEndFraz ;
+           // 3a -> eventuale movimento di lato a feed ridotta di inizio percorso
+            if ( dCurrStartFraz * dCutLen > EPS_SMALL) {
+               SetFeed( FvVar.dPuStart * dCurrFeed) ;
+               if ( AddLinearMove( Media( ptP2, ptP3, dCurrStartFraz)) == GDB_ID_NULL)
+                  return false ;
+            }
+           // 3b -> eventuale movimento di lato a feed normale
+            if ( ( dCurrMidFraz - dCurrStartFraz) * dCutLen > EPS_SMALL) {
+               SetFeed( dCurrFeed) ;
+               if ( AddLinearMove( Media( ptP2, ptP3, dCurrMidFraz)) == GDB_ID_NULL)
+                  return false ;
+            }
+           // 3c -> eventuale movimento di lato a feed ridotta di fine percorso
+            if ( dCurrEndFraz * dCutLen > EPS_SMALL) {
+               SetFeed( FvVar.dPuEnd * dCurrFeed) ;
+               if ( AddLinearMove( ptP3) == GDB_ID_NULL)
+                  return false ;
+            }
+         }
+         else {
+            SetFeed( dCurrFeed) ;
+            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
+               return false ;
+         }
       }     
      // 4 -> retrazione
       if ( ! AddRetract( pLine->GetStart(), vtCorr, dSafeZ, dElev, dAppr))
@@ -2310,10 +2363,33 @@ Sawing::GenerateLineCl( const ICurveLine* pLine, const Vector3d& vtTool, const V
          if ( AddLinearMove( ptP2) == GDB_ID_NULL)
             return false ;
         // movimento di lato al punto finale
-         SetFeed( ( ! bSideAng ? GetFeed() : GetSideAngFeed())) ;
+         double dCurrFeed = ( ! bSideAng ? GetFeed() : GetSideAngFeed()) ;
          Point3d ptP3 = pLine->GetEnd() + vtCorr * dDelta ;
-         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
-            return false ;
+         if ( FvVar.dLenStart > EPS_SMALL  ||  FvVar.dLenEnd > EPS_SMALL) {
+           // 3a -> eventuale movimento di lato a feed ridotta di inizio percorso
+            if ( dStartFraz * dCutLen > EPS_SMALL) {
+               SetFeed( FvVar.dPuStart * dCurrFeed) ;
+               if ( AddLinearMove( Media( ptP2, ptP3, dStartFraz)) == GDB_ID_NULL)
+                  return false ;
+            }
+           // 3b -> eventuale movimento di lato a feed normale
+            if ( ( dMidFraz - dStartFraz) * dCutLen > EPS_SMALL) {
+               SetFeed( dCurrFeed) ;
+               if ( AddLinearMove( Media( ptP2, ptP3, dMidFraz)) == GDB_ID_NULL)
+                  return false ;
+            }
+           // 3c -> eventuale movimento di lato a feed ridotta di fine percorso
+            if ( dEndFraz * dCutLen > EPS_SMALL) {
+               SetFeed( FvVar.dPuEnd * dCurrFeed) ;
+               if ( AddLinearMove( ptP3) == GDB_ID_NULL)
+                  return false ;
+            }
+         }
+         else {
+            SetFeed( dCurrFeed) ;
+            if ( AddLinearMove( ptP3) == GDB_ID_NULL)
+               return false ;
+         }
         // se non è ultimo passo
          if ( i != 0) {
            // movimento di risalita sopra il punto finale

Sawing.h

@@ -39,8 +39,14 @@ class Sawing : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_SAWING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nCuts == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nCuts == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -63,7 +69,7 @@ class Sawing : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 

Simulator.h

@@ -53,11 +53,15 @@ class __declspec( novtable) ISimulator
       virtual bool GetMoveInfo( int& nGmove, double& dFeed) const = 0 ;
       virtual bool AddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType,
                                     const Vector3d& vtMove, double dPar1, double dPar2, double dPar3) = 0 ;
+      virtual bool RemoveCollisionObj( int nFrameId) = 0 ;
+      virtual bool GetCollisionObj( int nPos, int& nInd, bool& bToolOn, int& nFrameId, int& nType,
+                                    Vector3d& vtMove, double& dPar1, double& dPar2, double& dPar3) = 0 ;
       virtual bool ExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType) = 0 ;
       virtual bool OnCollision( int nCdInd, int nObjInd, int& nErr) = 0 ;
       virtual bool SetToolForVmill( const std::string& sTool, const std::string& sHead, int nExit, int nFlag,
                                     double dPar1, double dPar2, const INTVECTOR& vVmill, bool bFirst) = 0 ;
       virtual bool EnableToolsForVmill( bool bEnable) = 0 ;
+      virtual bool EnableToolTipTrace( bool bEnable) = 0 ;
       virtual int  MoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt) = 0 ; 
       virtual bool SaveCmd( int nType, int nPar, const std::string& sPar, const std::string& sPar2) = 0 ;
 } ;

SimulatorMP.cpp

@@ -48,9 +48,10 @@ using namespace std ;
 
 //----------------------------------------------------------------------------
 static const double MIN_STEP = 1.0 ;
-static const double MAX_STEP = 500.0 ;
 static const double MID_STEP = 50.0 ;
+static const double MAX_STEP = 500.0 ;
 static const double COLL_STEP = 10. ;
+static const double MAX_COLL_STEP = 100. ;
 static const double SQ_COEFF_ROT_MOVE = 100. ;
 static const double COEFF_LIM = 0.999 ;
 static const double SAFEDIST_STD = 5.0 ;
@@ -792,12 +793,10 @@ SimulatorMP::FindAndManageOperationStart( bool bStart, bool bFirst, int& nChange
   // recupero la nuova operazione
    if ( nChangeTool == 0) {
       if ( bStart) {
-         //m_nOpId = m_pMchMgr->GetFirstActiveOperation() ;
          m_nOpInd = 0 ;
          m_nOpId = ( m_nOpInd < int( m_vOperId.size()) ? m_vOperId[m_nOpInd] : GDB_ID_NULL) ;
       }
       else {
-         // m_nOpId = m_pMchMgr->GetNextActiveOperation( m_nOpId) ;
          ++ m_nOpInd ;
          m_nOpId = ( m_nOpInd < int( m_vOperId.size()) ? m_vOperId[m_nOpInd] : GDB_ID_NULL) ;
       }
@@ -1113,11 +1112,17 @@ SimulatorMP::ManageSingleMove( int& nStatus, double& dMove)
       break ;
    case CamData::AS_OUTSTROKE : {
       DBLVECTOR OutAxes = pCamData->GetAxesVal() ;
-      for ( size_t i = OutAxes.size() ; i < 5 ; ++ i)
-         OutAxes.emplace_back( 0) ;
-      DBLVECTOR vAng( OutAxes.begin() + 3, OutAxes.end()) ;
-      int nStat ;
-      m_pMachine->VerifyOutstroke( OutAxes[0], OutAxes[1], OutAxes[2], vAng, true, nStat) ;
+      if ( ! m_pMchMgr->GetCurrIsRobot()) {
+         for ( size_t i = OutAxes.size() ; i < 5 ; ++ i)
+            OutAxes.emplace_back( 0) ;
+         DBLVECTOR vAng( OutAxes.begin() + 3, OutAxes.end()) ;
+         int nStat ;
+         m_pMachine->VerifyOutstroke( OutAxes[0], OutAxes[1], OutAxes[2], vAng, true, nStat) ;
+      }
+      else {
+         int nStat ;
+         m_pMachine->VerifyOutstroke( 0, 0, 0, OutAxes, true, nStat) ;
+      }
       nStatus = MCH_SIM_OUTSTROKE ;
       return false ; }
    case CamData::AS_DIR_ERR :
@@ -1128,6 +1133,16 @@ SimulatorMP::ManageSingleMove( int& nStatus, double& dMove)
       return false ;
    }
    DBLVECTOR AxesEnd = pCamData->GetAxesVal() ;
+  // Controllo che il numero di valori corrisponda con quello degli assi
+   int nEndsCnt = int( AxesEnd.size()) ;
+   int nAxesCnt = int( m_AxesName.size()) ;
+   if ( nEndsCnt != nAxesCnt) {
+      nStatus = MCH_SIM_ERR ;
+      m_pMchMgr->SetLastError( 1003, "Error : mismatch between the number of values and of axes") ;
+      string sOut = "Error : " + ToString( nEndsCnt) + " values vs " + ToString( nAxesCnt) + " axes" ;
+      LOG_ERROR( GetEMkLogger(), sOut.c_str())
+      return false ;
+   }
   // Tipo di movimento
    int nMoveType = pCamData->GetMoveType() ;
   // Se inizio di nuova entità, mascheratura movimento
@@ -1576,6 +1591,8 @@ SimulatorMP::ExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType)
          continue ;
      // recupero il riferimento
       Frame3d frCd ; m_pGeomDB->GetGlobFrame( m_CdId[i], frCd) ;
+     // recupero il nome
+      string sCdName ; m_pGeomDB->GetName( m_CdId[i], sCdName) ;
      // ciclo sugli oggetti con cui verificare
       for ( int j = 0 ; j < int( m_CollObj.size()) ; ++ j) {
         // se modo hidden è da saltare
@@ -1590,6 +1607,10 @@ SimulatorMP::ExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType)
         // se utensile attivo su grezzo in lavoro e non è rapido, salto
          if ( bIsTool  &&  bIsRaw  &&  nMoveType != 0)
             continue ;
+        // se contiene info con nome da saltare, verifico se è il caso
+         string sCollSkip ;
+         if ( m_pGeomDB->GetInfo( m_CollObj[j].nFrameId, "CollSkip", sCollSkip)  &&  sCollSkip == sCdName)
+            continue ;
         // esecuzione controlli di collisione
          bool bOk = true ;
         // oggetti che richiedono frame associato (Box, Cylinder, Sphere, Cone)
@@ -1663,8 +1684,8 @@ FindCollisionMarkId( const IGeomDB* pGeomDB, int nCollId)
    int nCollParId = pGeomDB->GetParentId( nCollId) ;
    string sCollParName = "COLLISION" ;
    pGeomDB->GetName( nCollParId, sCollParName) ;
-  // COLLISION per parti generiche di macchina, BASE e MOBILE per fixtures
-   if ( sCollParName != "COLLISION"  &&  sCollParName != "BASE"  &&  sCollParName != "MOBILE")
+  // COLLISION* per parti generiche di macchina, BASE e MOBILE per fixtures
+   if ( sCollParName.rfind( "COLLISION", 0) != 0  &&  sCollParName != "BASE"  &&  sCollParName != "MOBILE")
       return nCollParId ;
    else {
       int nCollGprId = pGeomDB->GetParentId( nCollParId) ;
@@ -2316,6 +2337,34 @@ SimulatorMP::AddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType, c
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+SimulatorMP::RemoveCollisionObj( int nFrameId)
+{
+   erase_if( m_CollObj, [nFrameId]( CollObj Item) { return ( Item.nFrameId == nFrameId) ; }) ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SimulatorMP::GetCollisionObj( int nPos, int& nInd, bool& bToolOn, int& nFrameId, int& nType,
+                              Vector3d& vtMove, double& dPar1, double& dPar2, double& dPar3)
+{
+  // posizione nel vettore non valida
+   if ( nPos < 0  ||  nPos >= ssize( m_CollObj))
+      return false ;
+  // assegno i dati
+   nInd = m_CollObj[nPos].nInd ;
+   bToolOn = m_CollObj[nPos].bToolOn ;
+   nFrameId = m_CollObj[nPos].nFrameId ;
+   nType = m_CollObj[nPos].nType ;
+   vtMove = m_CollObj[nPos].vtMove ;
+   dPar1 = m_CollObj[nPos].dPar1 ;
+   dPar2 = m_CollObj[nPos].dPar2 ;
+   dPar3 = m_CollObj[nPos].dPar3 ;
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 SimulatorMP::SetToolForVmill( const string& sTool, const string& sHead, int nExit, int nFlag, double dPar1, double dPar2,
@@ -2526,6 +2575,7 @@ SimulatorMP::ExecCmdData( int& nStatus)
       static const int STEP_RAPID = -2 ;
       static const int STEP_RAPROT = -3 ;
       static const int STEP_COLLROT = -4 ;
+      double dMaxStep = ( NeedCollisionCheck() ? MAX_COLL_STEP : MAX_STEP) ;
       int nStep = 1 ;
       for ( int i = 0 ; i < nAxCount ; ++ i) {
          double dMove = abs( CmdCurr.vAxNaEpSt[i].dEndPos - vPrev[i]) ;
@@ -2540,7 +2590,7 @@ SimulatorMP::ExecCmdData( int& nStatus)
             else                 // STEP_COLLROT
                dStep = min( 0.4 * m_dStep, 10.) ;
          }
-         dStep = max( dStep, 1.) ;
+         dStep = Clamp( dStep, MIN_STEP, dMaxStep) ;
          int nAxStep = int( dMove / dStep) + 1 ;
          nStep = max( nStep, nAxStep) ;
       }

SimulatorMP.h

@@ -40,11 +40,16 @@ class SimulatorMP : public ISimulator
       bool GetMoveInfo( int& nGmove, double& dFeed) const override ;
       bool AddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType,
                             const Vector3d& vtMove, double dPar1, double dPar2, double dPar3) override ;
+      bool RemoveCollisionObj( int nFrameId) override ;
+      bool GetCollisionObj( int nPos, int& nInd, bool& bToolOn, int& nFrameId, int& nType,
+                            Vector3d& vtMove, double& dPar1, double& dPar2, double& dPar3) override ;
       bool ExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType) override ;
       bool OnCollision( int nCdInd, int nObjInd, int& nErr) override ;
       bool SetToolForVmill( const std::string& sTool, const std::string& sHead, int nExit, int nFlag,
                             double dPar1, double dPar2, const INTVECTOR& vVmill, bool bFirst) override ;
       bool EnableToolsForVmill( bool bEnable) override ;
+      bool EnableToolTipTrace( bool bEnable) override
+               { return false ; }
       int  MoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt) override ;
       bool SaveCmd( int nType, int nPar, const std::string& sPar, const std::string& sPar2) override ;
 

SimulatorSP.cpp

@@ -29,15 +29,18 @@
 #include "/EgtDev/Include/EGkCDeClosedSurfTmClosedSurfTm.h"
 #include "/EgtDev/Include/EGkVolZmap.h"
 #include "/EgtDev/Include/EGkGeoVector3d.h"
+#include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkStringUtils3d.h"
 #include "/EgtDev/Include/EGkSurfLocal.h"
 #include "/EgtDev/Include/EXeCmdLogOff.h"
+#include "/EgtDev/Include/EXeSetModifiedOff.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EMkToolConst.h"
 #include "/EgtDev/Include/EMkOperationConst.h"
 #include "/EgtDev/Include/EGnGetKeyData.h"
 #include "/EgtDev/Include/EgtPerfCounter.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
+#include "/EgtDev/Include/EgtIniFile.h"
 #include "/EgtDev/Include/EgtKeyCodes.h"
 #include "/EgtDev/Include/SELkKeyProc.h"
 
@@ -48,9 +51,10 @@ using namespace std ;
 
 //----------------------------------------------------------------------------
 static const double MIN_STEP = 1.0 ;
-static const double MAX_STEP = 500.0 ;
 static const double MID_STEP = 50.0 ;
+static const double MAX_STEP = 500.0 ;
 static const double COLL_STEP = 10. ;
+static const double MAX_COLL_STEP = 100. ;
 static const double SQ_COEFF_ROT_MOVE = 100. ;
 static const double COEFF_LIM = 0.999 ;
 static const double SAFEDIST_STD = 5.0 ;
@@ -88,9 +92,12 @@ SimulatorSP::SimulatorSP( void)
    m_nAuxEInd = 0 ;
    m_nExit = 0 ;
    m_dTDiam = 0 ;
+   m_dTLen = 0 ;
    m_bCutOnTip = false ;
    m_bEnableVm = false ;
    m_dSafeDist = SAFEDIST_STD ;
+   m_bEnableTrace = false ;
+   m_nCurrTrace = GDB_ID_NULL ;
    m_nAxesMask = 0 ;
    m_bEnabAxes = true ;
    m_bShowAxes = true ;
@@ -200,6 +207,9 @@ SimulatorSP::Start( bool bFirst)
      // Verifico attrezzaggio
       if ( ! VerifySetup())
          bOk = false ;
+     // Recupero il materiale associato alla macchina
+      string sMachIni = m_pMachine->GetMachineDir() + "\\" + m_pMachine->GetMachineName() + ".ini" ;
+      m_sMachineMaterial = GetPrivateProfileStringUtf8( GENERAL_SEC.c_str(), MATERIAL_KEY.c_str(), "", sMachIni.c_str()) ;
    }
 
   // Reset utensile, interpolazione e assi correnti
@@ -207,7 +217,9 @@ SimulatorSP::Start( bool bFirst)
    m_sHead.clear() ;
    m_nExit = 0 ;
    m_dTDiam = 0 ;
+   m_dTLen = 0 ;
    m_bCutOnTip = false ;
+   m_nCurrTrace = GDB_ID_NULL ;
    ResetInterpolation() ;
    ResetAxes() ;
    ResetAuxAxes() ;
@@ -573,6 +585,7 @@ SimulatorSP::UpdateTool( bool bFirst, int& nErr)
       m_sHead = sHead ;
       m_nExit = nExit ;
       m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, m_dTDiam) ;
+      m_pMchMgr->TdbGetCurrToolParam( TPA_LEN, m_dTLen) ;
       double dTipFeed = 0 ;
       m_pMchMgr->TdbGetCurrToolParam( TPA_TIPFEED, dTipFeed) ;
       m_bCutOnTip = ( dTipFeed > EPS_MACH_LEN_PAR) ;
@@ -616,6 +629,7 @@ SimulatorSP::UpdateTool( bool bFirst, int& nErr)
       m_sHead = sHead ;
       m_nExit = nExit ;
       m_pMchMgr->TdbGetCurrToolParam( TPA_DIAM, m_dTDiam) ;
+      m_pMchMgr->TdbGetCurrToolParam( TPA_LEN, m_dTLen) ;
       double dTipFeed = 0 ;
       m_pMchMgr->TdbGetCurrToolParam( TPA_TIPFEED, dTipFeed) ;
       m_bCutOnTip = ( dTipFeed > EPS_MACH_LEN_PAR) ;
@@ -725,11 +739,11 @@ SimulatorSP::FindAndManageOperationStart( bool bStart, bool bFirst, int& nStatus
       bFirst = false ;
   // recupero la nuova operazione
    if ( bStart) {
-      m_nOpId = m_pMchMgr->GetFirstActiveOperation() ;
+      m_nOpId = m_pMchMgr->GetFirstActiveOperation( true) ;
       m_nOpInd = 0 ;
    }
    else
-      m_nOpId = m_pMchMgr->GetNextActiveOperation( m_nOpId) ;
+      m_nOpId = m_pMchMgr->GetNextActiveOperation( m_nOpId, true) ;
   // ciclo sulle successive operazioni
    while ( m_nOpId != GDB_ID_NULL) {
      // se lavorazione valida
@@ -888,6 +902,8 @@ SimulatorSP::FindAndManagePathStart( int& nStatus)
          m_dCoeff = 0 ;
       }
    }
+  // reset eventuale curva di TipTrace
+   m_nCurrTrace = GDB_ID_NULL ;
   // se trovato nuovo CLpath con entità, gestisco inizio percorso di lavoro
    if ( m_nEntId != GDB_ID_NULL) {
       ++ m_nCLPathInd ;
@@ -955,6 +971,8 @@ SimulatorSP::ManagePathEnd( int& nStatus)
   // gestione stato
    if ( ! bOk)
       nStatus = CalcStatusOnError( 0) ;
+  // reset eventuale curva di TipTrace
+   m_nCurrTrace = GDB_ID_NULL ;
    return bOk ;
 }
 
@@ -1041,11 +1059,17 @@ SimulatorSP::ManageSingleMove( int& nStatus, double& dMove)
       break ;
    case CamData::AS_OUTSTROKE : {
       DBLVECTOR OutAxes = pCamData->GetAxesVal() ;
-      for ( size_t i = OutAxes.size() ; i < 5 ; ++ i)
-         OutAxes.emplace_back( 0) ;
-      DBLVECTOR vAng( OutAxes.begin() + 3, OutAxes.end()) ;
-      int nStat ;
-      m_pMachine->VerifyOutstroke( OutAxes[0], OutAxes[1], OutAxes[2], vAng, true, nStat) ;
+      if ( ! m_pMchMgr->GetCurrIsRobot()) {
+         for ( int i = int( OutAxes.size()) ; i <= 5 ; ++ i)
+            OutAxes.emplace_back( 0) ;
+         DBLVECTOR vAng( OutAxes.begin() + 3, OutAxes.end()) ;
+         int nStat ;
+         m_pMachine->VerifyOutstroke( OutAxes[0], OutAxes[1], OutAxes[2], vAng, true, nStat) ;
+      }
+      else {
+         int nStat ;
+         m_pMachine->VerifyOutstroke( 0, 0, 0, OutAxes, true, nStat) ;
+      }
       nStatus = MCH_SIM_OUTSTROKE ;
       return false ; }
    case CamData::AS_DIR_ERR :
@@ -1056,6 +1080,16 @@ SimulatorSP::ManageSingleMove( int& nStatus, double& dMove)
       return false ;
    }
    DBLVECTOR AxesEnd = pCamData->GetAxesVal() ;
+  // Controllo che il numero di valori corrisponda con quello degli assi
+   int nEndsCnt = int( AxesEnd.size()) ;
+   int nAxesCnt = int( m_AxesName.size()) ;
+   if ( nEndsCnt != nAxesCnt) {
+      nStatus = MCH_SIM_ERR ;
+      m_pMchMgr->SetLastError( 1003, "Error : mismatch between the number of values and of axes") ;
+      string sOut = "Error : " + ToString( nEndsCnt) + " values vs " + ToString( nAxesCnt) + " axes" ;
+      LOG_ERROR( GetEMkLogger(), sOut.c_str())
+      return false ;
+   }
   // Tipo di movimento
    int nMoveType = pCamData->GetMoveType() ;
   // Se inizio di nuova entità, mascheratura movimento
@@ -1098,6 +1132,10 @@ SimulatorSP::ManageSingleMove( int& nStatus, double& dMove)
    for ( int i = 0 ; i < int( m_VmId.size()) ; ++ i)
       bOkI = m_pGeomDB->GetGlobFrame( m_VmId[i], vFrVzmI[i]) && bOkI ;
 
+  // Eventuale primo tracciamento punto tip utensile
+   if ( m_nCurrTrace == GDB_ID_NULL)
+      TraceToolTipMove( nMoveType) ;
+
   // Dati per eventuale verifica di collisione
    int nCdInd, nObjInd ;
    bool bCollCheck = true ;
@@ -1194,6 +1232,8 @@ SimulatorSP::ManageSingleMove( int& nStatus, double& dMove)
             }
            // eseguo eventuale collision check
             bCollCheck = bCollCheck && ExecCollisionCheck( nCdInd, nObjInd, nMoveType) ;
+           // eventuale tracciamento punto tip utensile
+            TraceToolTipMove( nMoveType) ;
          }
       }
      // Eseguo movimento su arco
@@ -1278,6 +1318,8 @@ SimulatorSP::ManageSingleMove( int& nStatus, double& dMove)
             }
            // eseguo eventuale collision check
             bCollCheck = bCollCheck && ExecCollisionCheck( nCdInd, nObjInd, nMoveType) ;
+           // eventuale tracciamento punto tip utensile
+            TraceToolTipMove( nMoveType) ;
          }
       }
    }
@@ -1338,6 +1380,8 @@ SimulatorSP::ManageSingleMove( int& nStatus, double& dMove)
          }
         // eseguo eventuale collision check
          bCollCheck = bCollCheck && ExecCollisionCheck( nCdInd, nObjInd, nMoveType) ;
+        // eventuale tracciamento punto tip utensile
+         TraceToolTipMove( nMoveType) ;
       }
    }
 
@@ -1498,6 +1542,8 @@ SimulatorSP::ExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType)
          continue ;
      // recupero il riferimento
       Frame3d frCd ; m_pGeomDB->GetGlobFrame( m_CdId[i], frCd) ;
+     // recupero il nome
+      string sCdName ; m_pGeomDB->GetName( m_CdId[i], sCdName) ;
      // ciclo sugli oggetti con cui verificare
       for ( int j = 0 ; j < int( m_CollObj.size()) ; ++ j) {
         // se modo hidden è da saltare
@@ -1512,6 +1558,10 @@ SimulatorSP::ExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType)
         // se utensile attivo su grezzo in lavoro e non è rapido, salto
          if ( bIsTool  &&  bIsRaw  &&  nMoveType != 0)
             continue ;
+        // se contiene info con nome da saltare, verifico se è il caso
+         string sCollSkip ;
+         if ( m_pGeomDB->GetInfo( m_CollObj[j].nFrameId, "CollSkip", sCollSkip)  &&  sCollSkip == sCdName)
+            continue ;
         // esecuzione controlli di collisione
          bool bOk = true ;
         // oggetti che richiedono frame associato (Box, Cylinder, Sphere, Cone)
@@ -1585,8 +1635,8 @@ FindCollisionMarkId( const IGeomDB* pGeomDB, int nCollId)
    int nCollParId = pGeomDB->GetParentId( nCollId) ;
    string sCollParName = "COLLISION" ;
    pGeomDB->GetName( nCollParId, sCollParName) ;
-  // COLLISION per parti generiche di macchina, BASE e MOBILE per fixtures
-   if ( sCollParName != "COLLISION"  &&  sCollParName != "BASE"  &&  sCollParName != "MOBILE")
+  // COLLISION* per parti generiche di macchina, BASE e MOBILE per fixtures
+   if ( sCollParName.rfind( "COLLISION", 0) != 0  &&  sCollParName != "BASE"  &&  sCollParName != "MOBILE")
       return nCollParId ;
    else {
       int nCollGprId = pGeomDB->GetParentId( nCollParId) ;
@@ -1626,6 +1676,73 @@ SimulatorSP::ResetCollisionMark( void)
    return true ;
 }
 
+//----------------------------------------------------------------------------
+bool
+SimulatorSP::EnableToolTipTrace( bool bEnable)
+{
+   if ( bEnable != m_bEnableTrace) {
+      if ( bEnable) {
+         ;
+      }
+      else {
+         int nTraceCrvId = m_nCurrTrace ;
+         while ( nTraceCrvId != GDB_ID_NULL) {
+            m_pGeomDB->SetStatus( nTraceCrvId, GDB_ST_OFF) ;
+            nTraceCrvId = m_pGeomDB->GetPrev( nTraceCrvId) ;
+         }
+         m_nCurrTrace = GDB_ID_NULL ;
+      }
+   }
+   m_bEnableTrace = bEnable ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SimulatorSP::TraceToolTipMove( int nMoveType)
+{
+  // verifico che la tracciatura sia abilitata
+   if ( ! m_bEnableTrace)
+      return true ;
+  // recupero il gruppo per le curve di traccia
+   int nTraceGrpId ;
+   if ( ! m_pMachine->LuaGetGlobVar( GLOB_VAR + GVAR_TOOLTRACE, nTraceGrpId))
+      return false ;
+  // recupero posizione utensile corrente
+   int nExitId = m_pMachine->GetExitId( m_sHead, m_nExit) ;
+   Frame3d frExit ;
+   if ( ! m_pGeomDB->GetGroupGlobFrame( nExitId, frExit))
+      return false ;
+   Point3d ptTip = frExit.Orig() - ( m_sMachineMaterial != "Additive" ? m_dTLen : 0) * frExit.VersZ() ;
+  // disabilito gestione segnalazione modifiche progetto
+   SetModifiedOff modOff ;
+  // eseguo tracciatura
+   static string TRACE_MOVE = "Move" ;
+   static int TRACE_MAX_LINE = 1000 ;
+   if ( m_nCurrTrace == GDB_ID_NULL) {
+      m_nCurrTrace = ExeCreateGeoPoint( nTraceGrpId, ptTip, GDB_ID_ROOT) ;
+      m_pGeomDB->SetInfo( m_nCurrTrace, TRACE_MOVE, nMoveType) ;
+      m_pGeomDB->SetStipple( m_nCurrTrace, ( nMoveType == 0 ? 3 : 0), 0x8C8C) ;
+   }
+   else {
+      const ICurveComposite* pCC = GetCurveComposite( m_pGeomDB->GetGeoObj( m_nCurrTrace)) ;
+      int nCount = ( pCC != nullptr ? pCC->GetCurveCount() : 0) ;
+      int nTraMove ;
+      m_pGeomDB->GetInfo( m_nCurrTrace, TRACE_MOVE, nTraMove) ;
+      if ( ( nMoveType == 0) == ( nTraMove == 0)  &&  nCount < TRACE_MAX_LINE)
+         ExeAddCurveCompoLine( m_nCurrTrace, ptTip, true, GDB_ID_ROOT) ;
+      else {
+         Point3d ptPrev ; ExeEndPoint( m_nCurrTrace, GDB_ID_ROOT, ptPrev) ;
+         m_nCurrTrace = ExeCreateGeoPoint( nTraceGrpId, ptPrev, GDB_ID_ROOT) ;
+         ExeAddCurveCompoLine( m_nCurrTrace, ptTip, true, GDB_ID_ROOT) ;
+         m_pGeomDB->SetInfo( m_nCurrTrace, TRACE_MOVE, nMoveType) ;
+         m_pGeomDB->SetStipple( m_nCurrTrace, ( nMoveType == 0 ? 3 : 0), 0x8C8C) ;
+      }
+   }
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 SimulatorSP::OnInit( void)
@@ -2227,7 +2344,8 @@ SimulatorSP::OnResetMachine( void)
 
 //----------------------------------------------------------------------------
 bool
-SimulatorSP::AddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType, const Vector3d& vtMove, double dPar1, double dPar2, double dPar3)
+SimulatorSP::AddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType,
+                              const Vector3d& vtMove, double dPar1, double dPar2, double dPar3)
 {
   // verifiche sui parametri
    if ( nInd <= 0  ||  nFrameId <= GDB_ID_NULL)
@@ -2258,6 +2376,35 @@ SimulatorSP::AddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType, c
    }
   // aggiungo al vettore
    m_CollObj.emplace_back( nInd, bToolOn, nFrameId, nType, vtMove, dPar1, dPar2, dPar3) ;
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SimulatorSP::RemoveCollisionObj( int nFrameId)
+{
+   erase_if( m_CollObj, [nFrameId]( CollObj Item) { return ( Item.nFrameId == nFrameId) ; }) ;
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SimulatorSP::GetCollisionObj( int nPos, int& nInd, bool& bToolOn, int& nFrameId, int& nType,
+                              Vector3d& vtMove, double& dPar1, double& dPar2, double& dPar3)
+{
+  // posizione nel vettore non valida
+   if ( nPos < 0  ||  nPos >= ssize( m_CollObj))
+      return false ;
+  // assegno i dati
+   nInd = m_CollObj[nPos].nInd ;
+   bToolOn = m_CollObj[nPos].bToolOn ;
+   nFrameId = m_CollObj[nPos].nFrameId ;
+   nType = m_CollObj[nPos].nType ;
+   vtMove = m_CollObj[nPos].vtMove ;
+   dPar1 = m_CollObj[nPos].dPar1 ;
+   dPar2 = m_CollObj[nPos].dPar2 ;
+   dPar3 = m_CollObj[nPos].dPar3 ;
    return true ;
 }
 
@@ -2415,6 +2562,7 @@ SimulatorSP::MoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt)
    static const int STEP_RAPID = -2 ;
    static const int STEP_RAPROT = -3 ;
    static const int STEP_COLLROT = -4 ;
+   double dMaxStep = ( NeedCollisionCheck() ? MAX_COLL_STEP : MAX_STEP) ;
    bool bViewAllFrames = true ;
    int nStep = 1 ;
    for ( int i = 0 ; i < nAxCount ; ++ i) {
@@ -2430,11 +2578,11 @@ SimulatorSP::MoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt)
             bViewAllFrames = ( bIsRobot ? true : false) ;
          }
          else {               // STEP_COLLROT
-            dStep = min( 0.4 * m_dStep, 10.) ;
+            dStep = min( 0.4 * m_dStep, COLL_STEP) ;
             bViewAllFrames = ( bIsRobot ? true : false) ;
          }
       }
-      dStep = max( dStep, 1.) ;
+      dStep = Clamp( dStep, MIN_STEP, dMaxStep) ;
       int nAxStep = int( dMove / dStep) + 1 ;
       nStep = max( nStep, nAxStep) ;
    }
@@ -2467,11 +2615,14 @@ SimulatorSP::MoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt)
          }
       }
      // Aggiorno visualizzazione
-      if ( bViewAllFrames  ||  ( i % 4) == 0  ||  i == nStep)
+      if ( bViewAllFrames  ||  ( i % 8) == 0  ||  i == nStep)
          ExeDraw() ;
      // Verifico collisioni
       int nCdInd, nObjInd ;
       bool bCollCheck = ExecCollisionCheck( nCdInd, nObjInd, nMoveType) ;
+     // eventuale tracciamento punto tip utensile
+      TraceToolTipMove( nMoveType) ;
+     // Se riscontrata collisione
       if ( ! bCollCheck) {
         // Richiamo funzione di convalida collisione
          int nPrevErr ;
@@ -2500,7 +2651,7 @@ SimulatorSP::MoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt)
      // Gestione aggiornamenti...
       if ( ExeGetEnableUI()) {
         // Aggiornamento interfaccia
-         ExeProcessEvents( 0, 4) ;
+         ExeProcessEvents( 0, 0) ;
          while ( m_nUiStatus == MCH_UISIM_PAUSE) {
             ExeProcessEvents( 0, 4) ;
          }

SimulatorSP.h

@@ -40,11 +40,15 @@ class SimulatorSP : public ISimulator
       bool GetMoveInfo( int& nGmove, double& dFeed) const override ;
       bool AddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType,
                             const Vector3d& vtMove, double dPar1, double dPar2, double dPar3) override ;
+      bool RemoveCollisionObj( int nFrameId) override ;
+      bool GetCollisionObj( int nPos, int& nInd, bool& bToolOn, int& nFrameId, int& nType,
+                            Vector3d& vtMove, double& dPar1, double& dPar2, double& dPar3) override ;
       bool ExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType) override ;
       bool OnCollision( int nCdInd, int nObjInd, int& nErr) override ;
       bool SetToolForVmill( const std::string& sTool, const std::string& sHead, int nExit, int nFlag,
                             double dPar1, double dPar2, const INTVECTOR& vVmill, bool bFirst) override ;
       bool EnableToolsForVmill( bool bEnable) override ;
+      bool EnableToolTipTrace( bool bEnable) override ;
       int  MoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt) override ; 
       bool SaveCmd( int nType, int nPar, const std::string& sPar, const std::string& sPar2) override
                { return false ; } 
@@ -81,6 +85,7 @@ class SimulatorSP : public ISimulator
                { return ( m_nUiStatus == MCH_UISIM_STOP) ; }
       bool SetCollisionMark( int nCdInd, int nObjInd) ;
       bool ResetCollisionMark( void) ;
+      bool TraceToolTipMove( int nMoveType) ;
       bool OnInit( void) ;
       bool OnExit( void) ;
       bool OnProgramStart( bool bFirst) ;
@@ -142,6 +147,7 @@ class SimulatorSP : public ISimulator
       MachMgr*      m_pMchMgr ;              // puntatore al gestore di tutte le lavorazioni
       IGeomDB*      m_pGeomDB ;              // puntatore al DB geometrico
       Machine*      m_pMachine ;             // puntatore alla macchina
+      std::string   m_sMachineMaterial ;     // nome del materiale associato alla macchina
       PerformanceCounter* m_pPerfCnt ;       // timer per calcolo FPS
       int           m_nStatus ;              // stato interno del simulatore (creato, inizializzato, pronto al movimento)
       double        m_dStep ;                // lunghezza di riferimento per la velocità di simulazione
@@ -161,6 +167,7 @@ class SimulatorSP : public ISimulator
       std::string   m_sHead ;                // nome della testa corrente
       int           m_nExit ;                // indice dell'uscita corrente
       double        m_dTDiam ;               // diametro dell'utensile corrente
+      double        m_dTLen ;                // lunghezza dell'utensile corrente
       bool          m_bCutOnTip ;            // flag capacità di lavorare di testa dell'utensile corrente
       bool          m_bEnableVm ;            // flag abilitazione Virtual Milling
       INTVECTOR     m_VmId ;                 // vettore identificativi Zmap per Virtual Milling
@@ -169,6 +176,8 @@ class SimulatorSP : public ISimulator
       COBVECTOR     m_CollObj ;              // vettore oggetti da testare per collisione con grezzo
       double        m_dSafeDist ;            // distanza di sicurezza per verifica collisioni
       INTVECTOR     m_nCollMarkId ;          // elenco oggetti marcati per visualizzare meglio la collisione rilevata
+      bool          m_bEnableTrace ;         // flag abilitazione tool tip trace
+      int           m_nCurrTrace ;           // Id della curva composita corrente di trace
       int           m_nAxesMask ;            // maschera a bit di abilitazione movimento assi (solo se rapido) 
       bool          m_bEnabAxes ;            // flag abilitazione movimento assi attivi
       bool          m_bShowAxes ;            // flag visualizzazione assi attivi

SurfFinishing.h

@@ -18,6 +18,7 @@
 #include "SurfFinishingData.h"
 #include "ToolData.h"
 #include "MachiningConst.h"
+#include "GeoConst.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
@@ -33,7 +34,6 @@ class StmFromTriangleSoup ;
 struct PATH {
    PtrOwner<ICurveComposite> pCrvPath ;
    int nType ;
-   double dSideAng ;
 } ;
 // vettore associato
 typedef std::vector<PATH> VECTORPATHS ;
@@ -43,6 +43,7 @@ struct CollisionSfr {
    PNTUVVECT CollisionInfo ;
    bool bInSpiral ;
    bool bInZConst ;
+   bool bOnBorder ;
 } ;
 // vettore associato
 typedef std::vector<CollisionSfr> VECTORCOLLISIONSFR ;
@@ -62,8 +63,14 @@ class SurfFinishing : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_SAWFINISHING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nPaths == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nPaths == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -86,7 +93,7 @@ class SurfFinishing : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 
@@ -98,29 +105,63 @@ class SurfFinishing : public Machining
       bool VerifyGeometry( SelData Id, int& nSubs) ;
       bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
       bool Chain( int nGrpDestId) ;
-      bool ProcessSfr( int nPathId, int nPvId, int nClId) ;
+      bool GetSurfacesByIds( SURFLOCALVECTOR& vSrfLoc, SURFLOCALVECTOR& vSrfSuppLoc, Frame3d& frSurf) ;
+      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,
+                             double dDepth, ISurfFlatRegion* pSfrCnt) ;
       bool ProcessCrvCompo( int nPathId, int nPvId, int nClId) ;
-      bool SimplifyCurve( ICurveComposite* pCompo) const ;
+      bool ProcessSfr( int nPathId, int nPvId, int nClId) ;
+      bool SimplifyCurve( ICurveComposite* pCompo,
+                          double dMergeLinTol = 200. * EPS_SMALL, double dMergeAndTolDeg = 200. * EPS_ANG_SMALL,
+                          double dSmallDefLinTol = 150. * EPS_SMALL, double dSmallDefAngTolDeg = 2. * ANG_TOL_STD_DEG,
+                          double dArcApproxLinTol = 50. * EPS_SMALL, double dArcApproxAngTolDeg = ANG_TOL_STD_DEG) const ;
       bool CalcZConstProjectedLink( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frPocket,
                                     const Frame3d& frSurf, const Vector3d& vtTool, double dDepth,
                                     const Point3d ptStart_forced, const Point3d ptEnd_forced,
-                                    ICurveComposite* pCrv) ;
+                                    ICurveComposite* pCrv) const ;
      // lavorazioni per superfici
-      bool AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
+      bool AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
                       const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
-      bool AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
+      bool AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
                       const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
-      bool AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
+      bool AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrCnt,
                       const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut) ;
-      bool AddZConst( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfr,
-                      const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
-      bool AddOptimal( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfr,
-                      const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
+      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) ;
+      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) ;
+     // 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) ;
+     // collisione con i percorsi di lavorazione
+      bool CorrectPathByCollision( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const Vector3d& vtTool,
+                                   double dDepth, ICRVCOMPOPOVECTOR& vpCrvs) ;
+
+      bool WorkPencilCurves( const ICRVCOMPOPOVECTOR& vCrvCompo, const ISurfFlatRegion* pSfrCnt, int nPencilType, double dOffs, int nOffs,
+                             double dDepth, double dElev, double dLinTol, const Vector3d& vtTool, const SURFLOCALVECTOR& vSrfLoc,
+                             const Frame3d& frSurf, ICAvToolSurfTm* pCAvTlStm, bool bSplitArcs) ;
+      bool OrderAndConnectPencilCurves( ICRVCOMPOPOVECTOR& vCrvCompo, double dLinkTol) const ;
+      bool GetOffsetCurvesFromPencilProjection( const ICRVCOMPOPOVECTOR& vCrvCompo, const ISurfFlatRegion* pSfrClass,
+                                                double dOffs, int nPencilType, ICRVCOMPOPOVECTOR& vCrvCompoRes) const ;
+      bool ProjectExposedPencilCurvesOnPlane( ICAvToolSurfTm* pCAvTlStm, const ICRVCOMPOPOVECTOR& vCrvCompo,
+                                              const Plane3d& plProj, const Vector3d& vtAxL, const Vector3d& vtMoveL,
+                                              double dOffs, double dDepth, ICRVCOMPOPOVECTOR& vCrvCompoProj) const ;
+      bool ChainPencilCurves( ICRVCOMPOPOVECTOR& vCrvCompo, double dLinTol, bool bAllowInvert = true) const ;
+      bool GetSurfTriMeshFromOffset( const SURFLOCALVECTOR& vSrfLoc, double dOffs, double dLinTol, ISurfTriMesh* pStmOffs) const ;
+      bool GetCurvesFromSurfTriMeshesOffset( const ISurfTriMesh * pStmOffs, double dBiTanAng, double dLinTol, 
+                                             int nOffs, const ISurfFlatRegion* pSfrCnt, ICRVCOMPOPOVECTOR& vCrvCompo ) ;
       bool ChooseFinishingForOptimal( const ISurfFlatRegion* pSfr, int nChunk, bool& bSpiral, double& dSideAng) ;
-      bool OrderOptimalPathsByZLoc( const ISurfFlatRegion* pSfr, VECTORPATHS& vCrvPaths) ;
+      bool OrderOptimalPathsByZLoc( const ISurfFlatRegion* pSfrCntZConst, const ISurfFlatRegion* pSfrCntZigZag, VECTORPATHS& vCrvPaths) const ;
       bool GetSfrBySilhouette( ICAvParSilhouettesSurfTm* pCavParSilh, double dDepth, double dSilTolSamp,
                                double dSilTolLin, double dSilTolAng, ISurfFlatRegion* pSfrSil) ;
       bool ApproxSilhouetteClosedPLForOptimal( PolyLine& PL, double dSampleTol, double dMaxLinTol, double dAngTol, double dLinFeaTol, ICurveComposite* pCompoPL) ;
@@ -128,19 +169,23 @@ class SurfFinishing : public Machining
                                              const Vector3d& vtTool, double dDepth, double dClippingAngle, double dTolerAngle,
                                              ISURFTMPOVECTOR& vpStm1, ISURFTMPOVECTOR& vpStm2, double& dMaxFrontTriaRad) const ;
       bool GetZConstQuotesInsideSfrParallelToTool( const SURFLOCALVECTOR&, const Frame3d& frSurf, const ISurfFlatRegion* pSfr,
-                                                   const Vector3d& vtTool, std::set<double>& setZAmbiguos) ;
-      ICAvParSilhouettesSurfTm* GetParSilhouettesForZConst( const ISURFTMPOVECTOR& vStm, const ISurfFlatRegion* pSfr) const ;
+                                                   const Vector3d& vtTool, std::set<double>& setZAmbiguos) const ;
       ISurfFlatRegion* GetSfrSilhouette( const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frLvl0, double dDepth) const ;
       ISurfFlatRegion* GetSfrProjectedStmLoops( const ISURFTMPOVECTOR& vStm, const ISurfFlatRegion* pSfrContour,
                                                 const DBLVECTOR& vdLinFeaTol, const DBLVECTOR& vdAngTol, const DBLVECTOR& vdMaxLinTol) const ;
       ISurfTriMesh* SplitStmTriaUnderClippingAngle( const SurfLocal SrfLoc, const Vector3d& vtTest, double dClippingAngle,
                                                     double dFrontTriaTolerAng,  double& dMaxFrontTriaRad) const ;
+      bool CalcOptimalZConstCurves( const ISurfFlatRegion* pSfrLoc, const SURFLOCALVECTOR& vSrfLoc,
+                                    const Frame3d& frSurf, const Vector3d& vtTool, double dAngDegSplit,
+                                    double dAngDegTol, double dDepth, ICAvToolSurfTm* pCAvTlStm, VECTORPATHS& vPaths, ISurfFlatRegion* pSfrProj) const ;
+      bool CalcOptimalZigZagCurves( const ISurfFlatRegion* pSfrLoc, const Frame3d& frSurf,
+                                    const Vector3d& vtTool, double dDepth, ICAvToolSurfTm* pCAvTlStm, VECTORPATHS& vPaths) const ;
       bool GetOptimalSfr( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfrLoc, const Vector3d& vtTool,
                           double dDepth, double dElev, ISurfFlatRegion* pSfrSpiral, ISurfFlatRegion* pSfrZConst) const ;
       bool CalcZConstSilCrv( ICAvParSilhouettesSurfTm* pCavParSilh, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf,
-                             const ISurfFlatRegion* pSfrClass, const Vector3d& vtTool, double dDepth, std::vector<ICRVCOMPOPOVECTOR>& vCrvCompo) ;
+                             const ISurfFlatRegion* pSfrClass, const Vector3d& vtTool, double dDepth, std::vector<ICRVCOMPOPOVECTOR>& vCrvCompo) const ;
       bool CreateZConstPaths( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, std::vector<ICRVCOMPOPOVECTOR>& vCrvCompo, const Vector3d& vtTool,
-                              const ISurfFlatRegion* pSfr, double dDepth, ICRVCOMPOPOVECTOR& vCrvPath) ;
+                              const ISurfFlatRegion* pSfr, double dDepth, ICRVCOMPOPOVECTOR& vCrvPath) const ;
       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 AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
@@ -149,16 +194,25 @@ 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& vtTool, Point3d& ptP1) const ;
+      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,
+                             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 ;
-      bool GetActiveSurfaces( INTVECTOR& vSurfId) const ;
-      bool MarchingSquares( const VECTORCOLLISIONSFR& vPntM, bool bSpiral, int nStepX, int nStepY, double dClippingAngle,
-                            const Vector3d& vtAxL, const Vector3d& vtMoveL, ICAvToolSurfTm* pCAvTlStm,
+      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 ;
+      Point3d CalcShapedPoint( const PNTUVVECT& myInfoStart, const PNTUVVECT& myInfoEnd, int nType, const Vector3d& vtAxL,
+                               const Vector3d& vtMoveL, double dCosSplitAngle, double dLimInfCosSplitAng,
+                                double dLimSupCosSplitAng, ICAvToolSurfTm* pCAvTlStm, int _nInd_debug) const ;
+      bool TestSubEdges( std::unordered_map<int, Point3d>& umEdgePnt, const INTVECTOR& vEdgeInd, int nType, int nFirst, int nLast,
+                         const VECTORCOLLISIONSFR& vPntM, int nStepX, const Vector3d vtAxL, const Vector3d& vtMoveL,
+                         double dCosSplitAng, double dLimInfCosSplitAng, double dLimSupCosSplitAng, ICAvToolSurfTm* pCAvTlStm, int _nInd_debug) const ;
+      bool MarchingSquares( const VECTORCOLLISIONSFR& vPntM, int nType, double dOffsTol, int nStepX, int nStepY, double dClippingAngle,
+                            double dLimInfClippingAng, double dLimSupClippingAng, const Vector3d& vtAxL, const Vector3d& vtMoveL, ICAvToolSurfTm* pCAvTlStm,
                             ICRVCOMPOPOVECTOR& vCrvCompo) const ;
-      bool CalcShapedPoint( const PNTUVVECT& myInfoStart, const PNTUVVECT& myInfoEnd, bool bSpiral, const Vector3d& vtAxL,
-                            const Vector3d& vtMoveL, double dClippingAngle, ICAvToolSurfTm* pCAvTlStm, Point3d& ptShaped, int _debug_ind = -1) const ;
       double GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const ;
       double GetRadiusForStartEndElevation( void) const ;
 

SurfFinishingData.cpp

@@ -392,7 +392,7 @@ SurfFinishingData::VerifySubType( int nVal) const
    return ( nVal == SURFFIN_SUB_ZIGZAG  ||  nVal == SURFFIN_SUB_ONEWAY  ||
             nVal == SURFFIN_SUB_SPIRALIN  ||  nVal == SURFFIN_SUB_SPIRALOUT  ||
             nVal == SURFFIN_SUB_Z_CONST  ||  nVal == SURFFIN_SUB_OPTIMAL  ||
-            nVal == SURFFIN_SUB_PROJECT) ;
+            nVal == SURFFIN_SUB_PROJECT  ||  nVal == SURFFIN_SUB_PENCIL) ;
 }
 
 //----------------------------------------------------------------------------

SurfRoughing.h

@@ -23,7 +23,6 @@
 #include "/EgtDev/Include/EGkSurfTriMesh.h"
 #include "/EgtDev/Include/EGkIntersPlaneSurfTm.h"
 
-class ICAvToolSurfTm ;
 class ICAvParSilhouettesSurfTm ;
 
 // struttura informazioni sui singoli percorsi
@@ -38,23 +37,93 @@ struct PathInfoSR {
 // tipo percorso
 typedef std::vector<PathInfoSR> PATHINFOSRVECTOR ;
 
+// struttura informazioni per Step/SubSteps durante la loro creazione [quindi temporanei]
+struct StepInfoSRTmp {
+   StepInfoSRTmp( void)
+      : nIndRef( -1), dDepth( 0), bSubStep( false), bPlaneZStep( false), dPercFeed( 0.),
+        pSfrRemoved( nullptr), pSfrPlaneZ( nullptr) {}
+   StepInfoSRTmp( int nIR, double dD, bool bSS, bool bPZ, double dPF, ISurfFlatRegion* pSR, ISurfFlatRegion* pSPZ)
+      : nIndRef( nIR), dDepth( dD), bSubStep( bSS), bPlaneZStep( bPZ), dPercFeed( dPF),
+        pSfrRemoved( pSR), pSfrPlaneZ( pSPZ) {}
+   ~StepInfoSRTmp() {
+      delete( pSfrRemoved) ;
+      delete( pSfrPlaneZ) ;
+   }
+   int nIndRef ;                     // ( usato solo per step intermedi ) posizione step precedente
+   double dDepth ;                   // profondità posizione piano di svuotatura ( in negativo)
+   bool bSubStep ;                   // flag per indicare se lo Step è un SubStep
+   bool bPlaneZStep ;                // flag per indicare se lo Step è un planeZ
+   double dPercFeed ;                // percentuale degli extra steps relativa agli step base ( per Feed ZLoc)
+   ISurfFlatRegion* pSfrRemoved ;    // regione PROGRESSIVA rimossa attuale
+   ISurfFlatRegion* pSfrPlaneZ ;     // regione individuata da PlaneZDetection
+} ;
+// vettore associato
+typedef std::vector<StepInfoSRTmp> STEPINFOTMPSRVECTOR ;
+
+// struttura per salvataggio Sfr con parametri nel GeomDB
+struct SfrGeoDBInfo {
+   SfrGeoDBInfo( ISurfFlatRegion* pMySfr, ISurfFlatRegion* pMySfrLimit, ISurfFlatRegion* pMySfrRemoved,
+                 bool bMySubSubStep, double dMyDepth, double dMyRelativeDepth, double dMyZLocCoefFeed)
+      : bSubStep( bMySubSubStep), dDepth( dMyDepth), dRelativeDepth( dMyRelativeDepth), dZLocCoefFeed( dMyZLocCoefFeed) {
+      pSfr.Set( pMySfr) ;
+      pSfrLimit.Set( pMySfrLimit) ;
+      pSfrRemoved.Set( pMySfrRemoved) ;
+   }
+   SfrGeoDBInfo()
+      : bSubStep( true), dDepth( 0.), dRelativeDepth( 0.), dZLocCoefFeed( 1.) {
+      pSfr.Set( nullptr) ;
+      pSfrLimit.Set( nullptr) ;
+      pSfrRemoved.Set( nullptr) ;
+   }
+   PtrOwner<ISurfFlatRegion> pSfr ;          // superficie di Sgrossatura ( allo step corrente)
+   PtrOwner<ISurfFlatRegion> pSfrLimit ;     // superficie Limite ( allo step corrente)
+   PtrOwner<ISurfFlatRegion> pSfrRemoved ;   // supericie Rimossa ( allo step corrente)
+   bool bSubStep ;                           // flag per indicare se Step semplice o meno ( Extra/PlaneZ)
+   double dDepth ;                           // profondità
+   double dRelativeDepth ;                   // profondità relativa
+   double dZLocCoefFeed ;                    // coefficiente di riduzione della Feed complessivo
+} ;
+// vettore associato
+typedef std::vector<SfrGeoDBInfo> SFRGEODBINFOVECTOR ;
+
 // struttura informazioni per Step/SubSteps complessivi
 struct StepInfoSR {
    double dDepth ;                                 // profondità dello step attuale
    double dRelativeDepth ;                         // profondità relativa allo step al di sopra
-   double dZlocCoeffFeed ;                         // coeffiziente riduzione Feed lungo Zloc
+   double dZlocCoeffFeed ;                         // coefficiente riduzione Feed lungo Zloc
    int nSubType ;                                  // tipo di lavorazione dello Step corrente
    bool bIsExtraStep ;                             // flag per SubStep o PlaneZStep
    bool bInverted ;                                // se percorsi invertiti
-   PtrOwner<ISurfFlatRegion> pSfrPock ;            // regione piana di svuotatura
-   PtrOwner<ISurfFlatRegion> pSfrLimit ;           // regione piana da non svuotare
+   PtrOwner<ISurfFlatRegion> pSfrPock ;            // regione piana di sgrossatura
+   PtrOwner<ISurfFlatRegion> pSfrLimit ;           // regione piana da non rovinare
    PATHINFOSRVECTOR vPaths ;                       // percorsi di Pocketing
 } ;
-// tipo step
+// vettore associato
 typedef std::vector<StepInfoSR> STEPINFOSRVECTOR ;
 // planeZ detection <SfrFace, dDepth>
 typedef std::pair<PtrOwner<ISurfFlatRegion>, double> PLANEZFACE ;
 typedef std::vector<PLANEZFACE> PLANEZFACEVECTOR ;
+// posizione reciproca tra Step/SubStep/PlaneZ
+enum { DOWN = 0, PLANAR = 1, ABOVE = 2} ;
+
+// struttura per ordinamento mediante ZChunk
+struct StepData {
+   PtrOwner<ISurfFlatRegion> pSfrChunk ;     // regione piana di sgrossatura
+   PtrOwner<ISurfFlatRegion> pSfrLimit ;     // regione piana da non rovinare
+   PtrOwner<ISurfFlatRegion> pSfrRemoved ;   // regione piana rimossa alla Depth corrente
+   bool bIsSubStep ;                         // Flag per Step base o Extra ( SubStep/PlaneZ)
+   double dDepth ;                           // profondità
+   double dRelativeDepth ;                   // profondità relativa
+   double dZLocCoeffFeed ;                   // coefficiente di riduzione della Feed
+} ;
+// vettore di StepData
+typedef std::vector<StepData> STEPDATAVECTOR ;
+// Matrice di StepData
+typedef std::vector<STEPDATAVECTOR> STEPDATAMATRIX ;
+// ordine <Ind, ZMin, ZMax>
+typedef std::pair<int, std::pair<double, double>> INTDBLDBL ;
+// vettore associato
+typedef std::vector<INTDBLDBL> INTDBLDBLVECTOR ;
 
 //----------------------------------------------------------------------------
 class SurfRoughing : public Machining
@@ -71,8 +140,14 @@ class SurfRoughing : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_SURFROUGHING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nPaths == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nPaths == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -95,7 +170,7 @@ class SurfRoughing : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 
@@ -111,8 +186,15 @@ class SurfRoughing : public Machining
       bool DetectPlaneZ( const CISURFTMPVECTOR& vpStm, const Frame3d& frCompo, const Vector3d& vtTool, PLANEZFACEVECTOR& vPlaneZ,
                          double dMinDepth, double dMaxDepth) const ;
       bool CalcPaths( const INTINTVECTOR& vPocket, STEPINFOSRVECTOR& vStepInfo) const ;
+      bool OrderByZChunk( SFRGEODBINFOVECTOR& vInfoSfrGeomDB, int nTempInd, const ISurfFlatRegion* pSfrSgro) const ;
+      bool OrderZChunkSteps( STEPDATAMATRIX& vvDataSteps, STEPDATAMATRIX& vIndepChunkGroup,
+                             INTDBLDBLVECTOR& vMapGrpZLoc) const ;
+      bool GetLinkFromPaths( STEPINFOSRVECTOR& vStepInfo, int i, int j, const Point3d& ptStart,
+                             const Vector3d& vtTool, double dSafeZ, double dExtraElev, double& dEndElev,
+                             ICurveComposite* pCrvLink) const ;
       bool CalcRegionElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double dLen, double& dElev) const ;
-      bool AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, double dElev, double dStep, double dSubStep, bool bSplitArcs) ;
+      bool AddRoughing( const INTINTVECTOR& vPocket, const Vector3d& vtTool, double dElev, double dStep,
+                        double dSubStep, bool bSplitArcs) ;
       bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr, bool bOutStart, bool bAbsFirst) ;
       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) ;
@@ -124,10 +206,14 @@ class SurfRoughing : public Machining
       bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
                        const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, Point3d& ptP1) ;
       ISurfTriMesh* GetRaw( void) const ;
-      ISurfTriMesh* GetStmOutSideSfr( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pStmRaw, const Vector3d& vtExtr) const ;
+      ISurfTriMesh* GetStmOutSideSfr( const ISurfFlatRegion* pSfr, double dDepth, const ISurfTriMesh* pStmRaw, const Vector3d& vtExtr) const ;
       ISurfFlatRegion* GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs = 0) const ;
       ISurfFlatRegion* GetSfrSilhouette( ICAvParSilhouettesSurfTm* pCavParSilh, double dDepth, double Sil_tol, bool& bOk) const ;
-      bool GetActiveSurfaces( INTVECTOR& vSurfId) const ;
+      ISurfFlatRegion* GetSfrCornerColl( ISurfFlatRegion* pSfr, const ISurfFlatRegion* pSfrLimit,
+                                         const ISurfFlatRegion* pSfrColl, const ISurfFlatRegion* pSfrSearchCorners) const ;
+      bool GetToolCollisionRegion( const ISurfFlatRegion* pSfrSgro, double& dDepth, ISurfFlatRegion* pSfrColl,
+                                   ISurfFlatRegion* pSfrSearchCorners) const ;
+      bool GetActiveSurfaces( INTVECTOR& vSurfId, INTVECTOR& vSurfSuppId) const ;
       double GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const ;
       double GetRadiusForStartEndElevation( void) const ;
       bool ResetCurveAllTempProp( ICurve* pCurve) const ;
@@ -138,8 +224,8 @@ class SurfRoughing : public Machining
       bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfFlatRegion* pSfrRef) const ;
       bool SimplifyCurve( ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvCheck) const ;
       bool SimplyfySfr( ISurfFlatRegion* pSfr) const ;
-      bool CheckSafetyLinearLink( const Point3d& ptCurr, const ISurfFlatRegion* pSfrLimit, const Vector3d& vtTool, 
-                                  const Point3d& ptDest, bool& bSafe) const ;
+      bool CheckSafetyLinearLink( const Point3d& ptCurr, const Point3d& ptDest, const ISurfFlatRegion* pSfrCheck, const Vector3d& vtTool,
+                                  bool& bSafe) const ;
       bool GetHomogeneousParts( const ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCrvs) const ;
       bool VerifyLeadInHelix( const ISurfFlatRegion* pSfr, const Point3d& ptStart, const Point3d& ptCen, double dHelixRad) const ;
       bool VerifyLeadInZigZag( const ISurfFlatRegion* pSfr, const Point3d& ptStart, const Point3d& ptPa, const Point3d& ptPb) const ;
@@ -183,9 +269,9 @@ class SurfRoughing : public Machining
            return m_Params.m_nLeadOutType ; }
 
       /* debug functions */
-       void DrawLoopsSurf( const ISurfFlatRegion* pSfr, bool bWithSurf, Color Col, bool bAlphaCoverage, std::string sName) ;
-       void DrawFeed( const ICurve* pCrv, double dFeed) ;
-       void DrawNormalShaderSurfTm( const ISurfTriMesh* pStm, std::string sName) ;
+       void DrawLoopsSurf( const ISurfFlatRegion* pSfr, bool bWithSurf, Color Col, bool bAlphaCoverage, std::string sName) const ;
+       void DrawFeed( const ICurve* pCrv, double dFeed) const ;
+       void DrawNormalShaderSurfTm( const ISurfTriMesh* pStm, std::string sName) const ;
       /* end debug functions */
 
    private :
@@ -201,5 +287,6 @@ class SurfRoughing : public Machining
       double            m_dStepToler ;      // tolleranza di rimozione chunk per Steps
       double            m_dSubStepToler ;   // tolleranza di rimozione chunk per SubSteps
       bool              m_bDetectPlaneZ ;   // flag per calcolo piani in Zloc di Pocketing
+      bool              m_bOrderZ ;         // flag per ordinamento Chunks secondo vtTool
       bool              m_bRunning ;        // flag di calcoli in corso
 } ;

ToolsMgr.cpp

@@ -85,7 +85,12 @@ ToolsMgr::Reload( void)
    Scanner TheScanner ;
    if ( ! TheScanner.Init( m_sToolsPath, ";")) {
       LOG_ERROR( GetEMkLogger(), "ReloadTools : Error on Init")
-      return false ;
+      if ( ExistsDirectory( m_sToolsDir)  &&  ! ExistsFile( m_sToolsPath)) {
+         m_bModified = true ;
+         return true ;
+      }
+      else
+         return false ;
    }
 
   // variabili di stato della lettura

WaterJetting.cpp

@@ -18,6 +18,7 @@
 #include "WaterJetting.h"
 #include "GeoConst.h"
 #include "OperationConst.h"
+#include "OperUserNotesConst.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkCurveComposite.h"
@@ -57,6 +58,7 @@ using namespace std ;
 // 3219 = "Error in WaterJetting : Tool loading failed"
 // 3220 = "Error in WaterJetting : Center work not allowed with side angle"
 // 3221 = "Error in WaterJetting : Path plane different from XY"
+// 3222 = "Error in WaterJetting : special apply not calculable"
 // 3251 = "Warning in WaterJetting : Skipped entity (xx)"
 // 3252 = "Warning in WaterJetting : No machinable path"
 // 3253 = "Warning in WaterJetting : Tool name changed (xx)"
@@ -66,6 +68,7 @@ using namespace std ;
 //----------------------------------------------------------------------------
 const double EXTRA_ACC_LEN = 0.5 ;
 const double INTANG_ROT_LEN = 5.0 ;
+const double LEN_TOL = 100 * EPS_SMALL ;   // valore limite per gestione degli angoli
 
 //----------------------------------------------------------------------------
 USEROBJ_REGISTER( GetOperationClass( OPER_WATERJETTING), WaterJetting) ;
@@ -501,7 +504,8 @@ WaterJetting::SetGeometry( const SELVECTOR& vIds)
   // verifico validità gestore DB geometrico
    if ( m_pGeomDB == nullptr)
       return false ;
-  // reset della geometria corrente
+  // copia temporanea e reset della geometria corrente
+   SELVECTOR vOldId = m_vId ;
    m_vId.clear() ;
   // verifico che gli identificativi rappresentino delle entità ammissibili (tutte curve, tutti testi o tutte facce)
    int nType = GEO_NONE ;
@@ -517,7 +521,8 @@ WaterJetting::SetGeometry( const SELVECTOR& vIds)
       m_vId.emplace_back( Id) ;
    }
   // aggiorno lo stato
-   m_nStatus |= MCH_ST_GEO_MODIF ;
+   if ( m_vId != vOldId)
+      m_nStatus |= MCH_ST_GEO_MODIF ;
   // restituisco presenza geometria da lavorare
    return ( ! m_vId.empty()  ||  vIds.empty()) ;
 }
@@ -621,16 +626,18 @@ WaterJetting::Apply( bool bRecalc, bool bPostApply)
       return false ;
 
   // aggiorno dati geometrici dell'utensile
-   bool bToolChanged = true ;
-   if ( ! UpdateToolData( &bToolChanged)) {
+   if ( ! UpdateToolData()) {
       m_pMchMgr->SetLastError( 3201, "Error in WaterJetting : UpdateToolData failed") ;
       return false ;
    }
    m_nHeadSolCh = m_pMchMgr->GetCurrMachine()->GetHeadSolCh( m_TParams.m_sHead) ;
 
+  // se modificata geometria, necessario ricalcolo
+   if ( ( m_nStatus & MCH_ST_GEO_MODIF) != 0)
+      bRecalc = true ;
+
   // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ! bToolChanged  &&  
-        ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
+   if ( ! bRecalc  &&  ( m_nStatus == MCH_ST_OK  ||  m_nStatus == MCH_ST_NO_POSTAPPL)) {
      // confermo i percorsi di lavorazione
       m_nMills = nCurrMills ;
       string sLog = string( "WaterJetting apply skipped : status ") + ( m_nStatus == MCH_ST_OK ? "already ok" : "no postapply") ;
@@ -761,6 +768,19 @@ WaterJetting::Update( bool bPostApply)
       return false ;
    }
 
+  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
+   CalcAndSetAxesBBox() ;
+
+  // esecuzione eventuali personalizzazioni speciali
+   string sSpecErr ;
+   if ( bPostApply  &&  ! SpecialApply( sSpecErr)) {
+      if ( ! IsEmptyOrSpaces( sSpecErr))
+         m_pMchMgr->SetLastError( 3222, sSpecErr) ;
+      else
+         m_pMchMgr->SetLastError( 3222, "Error in WaterJetting : special apply not calculable") ;
+      return false ;
+   }
+
   // gestione movimenti all'inizio di ogni singolo percorso di lavorazione e alla fine della lavorazione
    if ( ! AdjustStartEndMovements()) {
       string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
@@ -771,10 +791,7 @@ WaterJetting::Update( bool bPostApply)
       return false ;
    }
 
-  // assegno estremi degli assi dei vari percorsi di lavorazione e della lavorazione nel suo complesso
-   CalcAndSetAxesBBox() ;
-
-  // esecuzione eventuali personalizzazioni
+  // esecuzione eventuali personalizzazioni finali
    string sErr ;
    if ( bPostApply  &&  ! PostApply( sErr)) {
       if ( ! IsEmptyOrSpaces( sErr))
@@ -959,7 +976,7 @@ WaterJetting::GetToolData( void) const
 
 //----------------------------------------------------------------------------
 bool
-WaterJetting::UpdateToolData( bool* pbChanged)
+WaterJetting::UpdateToolData( void)
 {
   // recupero il gestore DB utensili della macchina corrente
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
@@ -1010,9 +1027,9 @@ WaterJetting::UpdateToolData( bool* pbChanged)
                       m_Params.m_sToolName + ")" ;
       m_pMchMgr->SetWarning( 3254, sInfo) ;
    }
-  // se definito parametro di ritorno, lo assegno
-   if ( pbChanged != nullptr)
-      *pbChanged = bChanged ;
+  // se modificato, aggiusto lo stato
+   if ( bChanged)
+      m_nStatus = MCH_ST_TO_VERIFY ;
    return true ;
 }
 
@@ -1198,9 +1215,6 @@ WaterJetting::Chain( int nGrpDestId)
   // vettore puntatori alle curve
    ICURVEPOVECTOR vpCrvs ;
    vpCrvs.reserve( m_vId.size()) ;
-  // vettore selettori delle curve originali
-   SELVECTOR vInds ;
-   vInds.reserve( m_vId.size()) ;
   // recupero tutte le curve e le porto in globale
    for ( const auto& Id : m_vId) {
      // prendo le curve
@@ -1210,14 +1224,16 @@ WaterJetting::Chain( int nGrpDestId)
          m_pMchMgr->SetWarning( 3251, sInfo) ;
       }
       for ( auto pCrv : lstPC) {
+        // salvo l'id geometrico della curva nelle sue temp prop per i conti successivi
+         pCrv->SetTempProp( Id.nId, 0) ;
+         pCrv->SetTempProp( Id.nSub, 1) ;
          vpCrvs.emplace_back( pCrv) ;
-         vInds.emplace_back( Id) ;
       }
    }
-  // verifico se sono necessarie sistemazioni per collegamenti (bridges)
+  // verifico se sono necessarie sistemazioni per collegamenti ( bridges)
    if ( abs( m_Params.m_dSideAngle) < EPS_ANG_SMALL  &&
         m_pGeomDB->GetFirstNameInGroup( m_pMchMgr->GetCurrMachGroup(), MACH_BRIDGES_GROUP) != GDB_ID_NULL) {
-      AdjustCurvesForBridges( vpCrvs, vInds) ;
+      AdjustCurvesForBridges( vpCrvs) ;
    }
   // preparo i dati per il concatenamento
    bool bFirst = true ;
@@ -1246,8 +1262,8 @@ WaterJetting::Chain( int nGrpDestId)
    }
   // recupero i percorsi concatenati
    int nCount = 0 ;
-   INTVECTOR vnId2 ;
-   while ( chainC.GetChainFromNear( ptNear, false, vnId2)) {
+   INTVECTOR vnId ;
+   while ( chainC.GetChainFromNear( ptNear, false, vnId)) {
      // creo una curva composita
       PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
       if ( IsNull( pCrvCompo))
@@ -1256,18 +1272,18 @@ WaterJetting::Chain( int nGrpDestId)
       Vector3d vtExtr = Z_AX ;
       double dThick = 0 ;
      // vettore Id originali
-      SELVECTOR vId2 ;
-      vId2.reserve( vnId2.size()) ;
+      SELVECTOR vOrigId ;
+      vOrigId.reserve( vnId.size()) ;
      // recupero le curve semplici e le inserisco nella curva composita
-      for ( size_t i = 0 ; i < vnId2.size() ; ++ i) {
-         int nId = abs( vnId2[i]) - 1 ;
-         bool bInvert = ( vnId2[i] < 0) ;
-         vId2.emplace_back( vInds[nId]) ;
+      for ( int i = 0 ; i < int( vnId.size()) ; ++ i) {
+         int nId = abs( vnId[i]) - 1 ;
+         bool bInvert = ( vnId[i] < 0) ;        
         // recupero la curva
          ICurve* pCrv = vpCrvs[nId] ;
+         vOrigId.emplace_back( pCrv->GetTempProp( 0), pCrv->GetTempProp( 1)) ;
         // se necessario, la inverto
          if ( bInvert)
-            pCrv->Invert() ;
+            pCrv->Invert() ;         
         // recupero eventuali estrusione e spessore
          Vector3d vtTemp ;
          if ( pCrv->GetExtrusion( vtTemp)) {
@@ -1296,7 +1312,7 @@ WaterJetting::Chain( int nGrpDestId)
       if ( nPathId == GDB_ID_NULL)
          return false ;
       m_pGeomDB->SetName( nPathId, MCH_PATH + ToString( ++ nCount)) ;
-      m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( vId2)) ;
+      m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( vOrigId)) ;
      // inserisco la curva composita nel gruppo destinazione
       int nNewId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, ::Release( pCrvCompo)) ;
       if ( nNewId == GDB_ID_NULL)
@@ -1307,7 +1323,7 @@ WaterJetting::Chain( int nGrpDestId)
 
 //----------------------------------------------------------------------------
 bool
-WaterJetting::AdjustCurvesForBridges( ICURVEPOVECTOR& vpCrvs, SELVECTOR& vInds)
+WaterJetting::AdjustCurvesForBridges( ICURVEPOVECTOR& vpCrvs)
 {
   // Gruppo dei collegamenti
    struct Bridge {
@@ -1338,44 +1354,49 @@ WaterJetting::AdjustCurvesForBridges( ICURVEPOVECTOR& vpCrvs, SELVECTOR& vInds)
    }
 
   // Verifico i collegamenti che interessano le geometrie della lavorazione
+   double const DIST_MAX = 5 ;
    for ( int i = 0 ; i < int( vBridges.size()) ; ++ i) {
-     // cerco le due curve interessate dal collegamento 
+     // cerco le due curve interessate dal collegamento calcolando e verificando anche la posizione dei punti di collegamento sulle 
+     // due curve
+      double dMinLen = vBridges[i].dWidth + m_TParams.m_dDiam ; 
       int nI1 = -1 ;
-      for ( int j = 0 ; j < int( vInds.size()) ; ++ j) {
-         if ( vInds[j].nId == vBridges[i].nEnt1) {
-            nI1 = j ;
-            break ;
+      double dDist1, dU1, dLenP1, dLen1 ; int nF1 ;
+      for ( int j = 0 ; j < int( vpCrvs.size()) ; ++ j) {
+        // recupero l'id geometrico della curva dalla sua temp prop
+         int nCrvId = vpCrvs[j]->GetTempProp() ;
+         if ( nCrvId == vBridges[i].nEnt1) {
+            DistPointCurve distPC1( vBridges[i].ptP1, *vpCrvs[j]) ;
+            if ( distPC1.GetDist( dDist1)  &&  dDist1 < DIST_MAX   &&
+                 distPC1.GetParamAtMinDistPoint( 0, dU1, nF1)  &&
+                 vpCrvs[j]->GetLengthAtParam( dU1, dLenP1)  &&
+                 vpCrvs[j]->GetLength( dLen1)  &&
+                 dLenP1 > dMinLen - EPS_SMALL  &&
+                 ( dLen1 - dLenP1) > dMinLen - EPS_SMALL) {
+               nI1 = j ;
+               break ;
+            }
          }
       }
       int nI2 = -1 ;
-      for ( int j = 0 ; j < int( vInds.size()) ; ++ j) {
-         if ( vInds[j].nId == vBridges[i].nEnt2) {
-            nI2 = j ;
-            break ;
+      double dDist2, dU2, dLenP2, dLen2 ; int nF2 ;
+      for ( int j = 0 ; j < int( vpCrvs.size()) ; ++ j) {
+         int nCrvId = vpCrvs[j]->GetTempProp() ; 
+         if ( nCrvId == vBridges[i].nEnt2) {
+            DistPointCurve distPC2( vBridges[i].ptP2, *vpCrvs[j]) ;
+            if ( distPC2.GetDist( dDist2)  &&  dDist2 < DIST_MAX  &&
+                 distPC2.GetParamAtMinDistPoint( 0, dU2, nF2)  &&
+                 vpCrvs[j]->GetLengthAtParam( dU2, dLenP2)  &&
+                 vpCrvs[j]->GetLength( dLen2)  &&
+                 dLenP2 > dMinLen - EPS_SMALL  &&
+                 ( dLen2 - dLenP2) > dMinLen - EPS_SMALL) {
+               nI2 = j ;
+               break ;
+            }                      
          }
       }
       if ( nI1 == -1  ||  nI2 == -1)
          continue ;
-     // calcolo e verifico la posizione dei punti di collegamento sulle due curve
-      double const DIST_MAX = 5 ;
-      double dDist1, dU1, dLenP1, dLen1 ; int nF1 ;
-      DistPointCurve distPC1( vBridges[i].ptP1, *vpCrvs[nI1]) ;
-      if ( ! distPC1.GetDist( dDist1)  ||  dDist1 > DIST_MAX  ||
-           ! distPC1.GetParamAtMinDistPoint( 0, dU1, nF1)  ||
-           ! vpCrvs[nI1]->GetLengthAtParam( dU1, dLenP1)  ||
-           ! vpCrvs[nI1]->GetLength( dLen1)  ||
-           dLenP1 < vBridges[i].dWidth + m_TParams.m_dDiam  ||
-           ( dLen1 - dLenP1) < vBridges[i].dWidth + m_TParams.m_dDiam)
-         continue ;
-      double dDist2, dU2, dLenP2, dLen2 ; int nF2 ;
-      DistPointCurve distPC2( vBridges[i].ptP2, *vpCrvs[nI2]) ;
-      if ( ! distPC2.GetDist( dDist2)  ||  dDist2 > DIST_MAX  ||
-           ! distPC2.GetParamAtMinDistPoint( 0, dU2, nF2)  ||
-           ! vpCrvs[nI2]->GetLengthAtParam( dU2, dLenP2)  ||
-           ! vpCrvs[nI2]->GetLength( dLen2)  ||
-           dLenP2 < vBridges[i].dWidth + m_TParams.m_dDiam  ||
-           ( dLen2 - dLenP2) < vBridges[i].dWidth + m_TParams.m_dDiam)
-         continue ;
+
      // spezzo le curve nei punti del collegamento e creo i segmenti di collegamento
       PtrOwner<ICurve> pCopy1( vpCrvs[nI1]->Clone()) ;
       PtrOwner<ICurve> pCopy2( vpCrvs[nI2]->Clone()) ;
@@ -1393,15 +1414,11 @@ WaterJetting::AdjustCurvesForBridges( ICURVEPOVECTOR& vpCrvs, SELVECTOR& vInds)
       Point3d ptBs ; vpCrvs[nI2]->GetEndPoint( ptBs) ;
       Point3d ptBe ; pCopy1->GetStartPoint( ptBe) ;
       pLinkB->Set( ptBs, ptBe) ;
-     // inserisco le nuove curve nel vettore delle curve e aggiorno il vettore degli indici
+     // inserisco le nuove curve nel vettore delle curve
       vpCrvs.emplace_back( Release( pCopy1)) ;
-      vInds.emplace_back( vInds[nI1]) ;
       vpCrvs.emplace_back( Release( pCopy2)) ;
-      vInds.emplace_back( vInds[nI2]) ;
       vpCrvs.emplace_back( Release( pLinkA)) ;
-      vInds.emplace_back( 0, 0) ;
       vpCrvs.emplace_back( Release( pLinkB)) ;
-      vInds.emplace_back( 0, 0) ;
    }
 
    return true ;
@@ -1492,7 +1509,9 @@ WaterJetting::ProcessPath( int nPathId, int nPvId, int nClId)
   // recupero direzione utensile da estrusione
    Vector3d vtTool ;
    pCompo->GetExtrusion( vtTool) ;
-   if ( ! ( vtTool - Z_AX).IsSmall()) {
+   if ( vtTool.IsSmall())
+      vtTool = Z_AX ;
+   if ( ! AreSameVectorApprox( vtTool, Z_AX)) {
       m_pMchMgr->SetLastError( 3221, "Error in WaterJetting : Path plane different from XY") ;
       return false ;
    }
@@ -1501,18 +1520,19 @@ WaterJetting::ProcessPath( int nPathId, int nPvId, int nClId)
    if ( pCompo->IsClosed()) {
      // recupero indicazione lato di inizio
       int nStart = 0 ;
-      string sMyNotes = m_Params.m_sUserNotes ;
-      ToUpper( sMyNotes) ;
-      if ( sMyNotes.find( "START=XP") != string::npos)
-         nStart = 1 ;
-      else if ( sMyNotes.find( "START=XM") != string::npos)
-         nStart = -1 ;
-      else if ( sMyNotes.find( "START=YP") != string::npos)
-         nStart = 2 ;
-      else if ( sMyNotes.find( "START=YM") != string::npos)
-         nStart = -2 ;
-      else if ( sMyNotes.find( "START=") != string::npos)
-         nStart = 11 ;
+      string sStart ;
+      if ( GetValInNotes( m_Params.m_sUserNotes, UN_START, sStart)) {
+         if ( sStart == "XP")
+            nStart = 1 ;
+         else if ( sStart == "XM")
+            nStart = -1 ;
+         else if ( sStart == "YP")
+            nStart = 2 ;
+         else if ( sStart == "YM")
+            nStart = -2 ;
+         else
+            nStart = 11 ;
+      }
      // se richiesta sistemazione punto di inizio
       if ( nStart != 0  &&  nStart != 11) {
          const double COS_ANG_PERD_TG = cos( 5 * DEGTORAD) ;
@@ -1575,12 +1595,12 @@ WaterJetting::ProcessPath( int nPathId, int nPvId, int nClId)
       }
      // se altrimenti suggerito punto di inizio
       else if ( nStart == 11) {
-         ReplaceString( sMyNotes, "(", "") ;
-         ReplaceString( sMyNotes, ")", "") ;
+         TrimLeft( sStart, "(") ;
+         TrimRight( sStart, ")") ;
          Point3d ptStart ;
          double dPar ;
          int nFlag ;
-         if ( GetValInNotes( sMyNotes, "START", ptStart)  &&
+         if ( FromString( sStart, ptStart)  &&
               DistPointCurve( ptStart, *pCompo).GetParamAtMinDistPoint( 0, dPar, nFlag)) {
             pCompo->ChangeStartPoint( dPar) ;
          }
@@ -1720,6 +1740,8 @@ WaterJetting::ProcessPath( int nPathId, int nPvId, int nClId)
          return false ;
       m_pGeomDB->SetName( nPxId, sPathName) ;
       m_pGeomDB->SetMaterial( nPxId, GREEN) ;
+     // Sistemazioni per angoli interni
+      AdjustPathForInternalAngles( pCompo) ;
      // creo l'anteprima del percorso
       if ( ! GeneratePreView( nPxId, pCompo, dAddedOverlap))
          return false ;
@@ -1777,6 +1799,7 @@ WaterJetting::GeneratePreView( int nPathId, const ICurveComposite* pCompo, doubl
       pCrv->TrimStartAtLen( dAddedOverlap) ;
       pCrv->Invert() ;
    }
+   bool bClosed = pCrv->IsClosed() ;
   // calcolo la regione ridotta
    PtrOwner<ISurfFlatRegion> pSfr ;
    double dSideCoeff = ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL ? 1. / cos( m_Params.m_dSideAngle * DEGTORAD) : 1) ;
@@ -1799,19 +1822,35 @@ WaterJetting::GeneratePreView( int nPathId, const ICurveComposite* pCompo, doubl
    m_pGeomDB->SetMaterial( nRRId, INVISIBLE) ;
  
   // regione per attacco
-   PtrOwner<ISurfFlatRegion> pSfrLI( GenerateLeadInPreview( pCompo)) ;
+   PtrOwner<ISurfFlatRegion> pSfrLI( GenerateLeadInPreview( pCompo, bClosed)) ;
    if ( IsNull( pSfrLI))
       return false ;
-   if ( pSfrLI->IsValid()) {
-     // se regione definita la aggiungo alla regione completa
-      if ( ! pSfrTot->Add( *pSfrLI))
-         return false ;
-     // aggiungo nel DB     
-      int nRLiId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfrLI)) ;
-      if ( nRLiId == GDB_ID_NULL)
-         return false ;
-      m_pGeomDB->SetName( nRLiId, MCH_PV_RLICUT) ;
-      m_pGeomDB->SetMaterial( nRLiId, INVISIBLE) ;
+   if ( pSfrLI->IsValid()) {    
+     // se nessun attacco pSrfLI è solo un cerchio segnaposto, aggiungo la sua curva di bordo al DB 
+      if ( GetLeadInType() == WJET_LI_NONE) {
+         PtrOwner<ICurve> pCrvLI( pSfrLI->GetLoop( 0, 0)) ;
+         if ( IsNull( pCrvLI))
+            return false ;
+         int nCLIId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrvLI)) ;
+        // int nCLIId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfrLI)) ;
+         if ( nCLIId == GDB_ID_NULL)
+            return false ;
+        // assegno nome e colore
+         m_pGeomDB->SetName( nCLIId, MCH_PV_CUT) ;
+         m_pGeomDB->SetMaterial( nCLIId, colCut) ;
+      }
+     // altrimenti aggiungo la regione
+      else {
+        // aggiungo alla regione completa
+         if ( ! pSfrTot->Add( *pSfrLI))
+            return false ;
+        // aggiungo nel DB
+         int nRLiId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfrLI)) ;
+         if ( nRLiId == GDB_ID_NULL)
+            return false ;
+         m_pGeomDB->SetName( nRLiId, MCH_PV_RLICUT) ;
+         m_pGeomDB->SetMaterial( nRLiId, INVISIBLE) ;     
+      }
    }
 
   // regione per uscita
@@ -1976,22 +2015,33 @@ WaterJetting::GeneratePreView( int nPathId, const ICurveComposite* pCompo, doubl
 
 //----------------------------------------------------------------------------
 ISurfFlatRegion*
-WaterJetting::GenerateLeadInPreview( const ICurveComposite* pCompo)
+WaterJetting::GenerateLeadInPreview( const ICurveComposite* pCompo, bool bClosed)
 {
   // Creo la superficie
    PtrOwner<ISurfFlatRegion> pSfr( CreateSurfFlatRegion()) ;
    if ( IsNull( pSfr))
       return nullptr ;
 
-  // Assegno il tipo
-   int nType = GetLeadInType() ;
-   if ( nType == WJET_LI_NONE)
-      return Release( pSfr) ;
+   double dSideCoeff = ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL ? 1. / cos( m_Params.m_dSideAngle * DEGTORAD) : 1) ;
+   double dRad = 0.49 * m_TParams.m_dDiam * dSideCoeff ;   // non 0.5 per evitare problemi di coincidenza
+
   // Recupero punto e direzione iniziali del percorso
    Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;
    Vector3d vtStart ; pCompo->GetStartDir( vtStart) ;
   // Recupero versore estrusione
    Vector3d vtN ; pCompo->GetExtrusion( vtN) ;
+
+  // Verifico il tipo
+   int nType = GetLeadInType() ;
+   if ( nType == WJET_LI_NONE) {
+     // se nessun attacco e curva chiusa creo segnaposto per indicare punto di inizio
+      if ( bClosed) {
+         pSfr.Set( GetSurfFlatRegionDisk( dRad)) ;
+         if ( ! IsNull( pSfr))
+            pSfr->Translate( ptStart - ORIG) ;         
+      }
+      return Release( pSfr) ;
+   }     
   // Calcolo punto iniziale dell'attacco
    Point3d ptP1 ;
    if ( ! CalcLeadInStart( ptStart, vtStart, vtN, pCompo, ptP1))
@@ -2014,9 +2064,7 @@ WaterJetting::GenerateLeadInPreview( const ICurveComposite* pCompo)
    default :
       return nullptr ;
    }
-  // calcolo la regione
-   double dSideCoeff = ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL ? 1. / cos( m_Params.m_dSideAngle * DEGTORAD) : 1) ;
-   double dRad = 0.49 * m_TParams.m_dDiam * dSideCoeff ;   // non 0.5 per evitare problemi di coincidenza
+  // calcolo la regione   
    pSfr.Set( GetSurfFlatRegionFromFatCurve( Release( pCrv), dRad, false, false)) ;
    if ( IsNull( pSfr))
       return nullptr ;
@@ -2107,55 +2155,61 @@ WaterJetting::AddLoopsPreview( const ICurveComposite* pCompo, ISurfFlatRegion* p
    for ( int i = 1 ; i <= nMaxInd ; ++ i) {
      // curva corrente
       const ICurve* pCrvC = pCompo->GetCurve( i) ;
-     // Recupero versore estrusione
-      Vector3d vtN ; pCompo->GetExtrusion( vtN) ;
-     // direzione finale precedente 
+     // curva precedente 
       const ICurve* pCrvP = pCompo->GetCurve( i - 1) ;
+     // verifico che tratti abbiano lunghezza sufficiente per gestione angolo 
+      double dLenC ; pCrvC->GetLength( dLenC) ;
+      double dLenP ; pCrvP->GetLength( dLenP) ;
+      if ( dLenC < LEN_TOL  ||  dLenP < LEN_TOL)
+         continue ;
+     // angolo tra direzione finale precedente e direzione iniziale corrente
       Vector3d vtEnd ; pCrvP->GetEndDir( vtEnd) ;
-     // direzione iniziale corrente
       Vector3d vtStart ; pCrvC->GetStartDir( vtStart) ;
-     // angolo tra le direzioni
       double dAng ; vtEnd.GetAngleXY( vtStart, dAng) ;
      // se previsto e angolo esterno, si aggiunge l'anello
       if ( m_Params.m_nExtCornerType == WJET_EC_LOOP  &&  IsExternalAngle( dAng)) {
         // curva dell'anello
-         PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
-         if ( IsNull( pCompo))
+         PtrOwner<ICurveComposite> pLoop( CreateCurveComposite()) ;
+         if ( IsNull( pLoop))
             return false ;
         // lunghezza tratti lineari e loro punti estremi
-         double dTgLen = 0.5 * m_TParams.m_dDiam * tan( 0.5 * dAng * DEGTORAD) ;
+         double dTgLen = 0.5 * m_TParams.m_dDiam * tan( 0.5 * abs( dAng) * DEGTORAD) ;
          if ( m_Params.m_dSideAngle > EPS_ANG_SMALL) {
             double dW = m_dElev * sin( m_Params.m_dSideAngle * DEGTORAD) ;
-            double dExtraLen = dW / tan( ( 180 - abs( dAng)) / 2 * DEGTORAD) ; 
+            double dExtraLen = dW / tan( 0.5 * ( 180 - abs( dAng)) * DEGTORAD) ; 
             dTgLen += dExtraLen ;
          }
          Point3d ptP ; pCrvC->GetStartPoint( ptP) ;
          Point3d ptPe = ptP + vtEnd * dTgLen ;
          Point3d ptPs = ptP - vtStart * dTgLen ;
         // tratto prima dell'anello
-         if ( ! pCompo->AddPoint( ptP)  ||  ! pCompo->AddLine( ptPe))
+         if ( ! pLoop->AddPoint( ptP)  ||  ! pLoop->AddLine( ptPe))
             return false ;
         // anello
-         if ( ! pCompo->AddArcTg( ptPs))
+         if ( ! pLoop->AddArcTg( ptPs))
             return false ;
+        // verifico che l'anello non interferisca con la curva di lavoro
+         IntersCurveCurve intAC( *pLoop->GetLastCurve(), *pCompo) ;
+         if ( intAC.GetIntersCount() > 0)
+            continue ;
         // tratto dopo l'anello
-         if ( ! pCompo->AddLine( ptP))
+         if ( ! pLoop->AddLine( ptP))
             return false ;
         // lo porto in antiorario
          double dArea ;
-         if ( ! pCompo->GetAreaXY( dArea))
+         if ( ! pLoop->GetAreaXY( dArea))
             return false ;
          if ( dArea < 0)
-            pCompo->Invert() ;
+            pLoop->Invert() ;
         // ne eseguo l'offset
          double dSideCoeff = ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL ? 1. / cos( m_Params.m_dSideAngle * DEGTORAD) : 1) ;
          double Rad = 0.49 * m_TParams.m_dDiam * dSideCoeff ;   // non 0.5 per evitare problemi di coincidenza 
-         if ( ! pCompo->SimpleOffset( Rad, ICurve::OFF_FILLET))
+         if ( ! pLoop->SimpleOffset( Rad, ICurve::OFF_FILLET))
             return false ;
         // calcolo la regione
          PtrOwner<ISurfFlatRegion> pSfr ;
          SurfFlatRegionByContours SfrCntr ;
-         SfrCntr.AddCurve( Release( pCompo)) ;
+         SfrCntr.AddCurve( Release( pLoop)) ;
          pSfr.Set( SfrCntr.GetSurf()) ;
         // Unisco le due regioni
          if ( IsNull( pSfr)  ||  ! pSPV->Add( *pSfr))
@@ -2224,7 +2278,7 @@ WaterJetting::AdjustPathForInternalAngles( ICurveComposite* pCompo)
          double dExtraLen = dSlowLen + INTANG_ROT_LEN - dLen ;
          if ( dExtraLen > 0) {
            // se entità successiva è in tangenza e abbastanza lunga, allungo la corrente a scapito della successiva
-            if ( ! bNextIntAng  &&  dNextLen > dExtraLen) {
+            if ( abs( dNextAng) < EPS_ANG_SMALL  &&  dNextLen > dExtraLen) {
                double dU ; Point3d ptP ;
                if ( pCrvN->GetParamAtLength( dExtraLen, dU)  &&
                     pCrvN->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP))
@@ -2241,7 +2295,7 @@ WaterJetting::AdjustPathForInternalAngles( ICurveComposite* pCompo)
          double dExtraLen = dSlowLen + INTANG_ROT_LEN - dLen ;
          if ( dExtraLen > 0) {
            // se entità precedente è in tangenza e abbastanza lunga, allungo la corrente a scapito della precedente
-            if ( ! bPrevIntAng  &&  dPrevLen > dExtraLen) {
+            if ( abs( dPrevAng) < EPS_ANG_SMALL  &&  dPrevLen > dExtraLen) {
                double dU ; Point3d ptP ;
                if ( pCrvP->GetParamAtLength( dPrevLen - dExtraLen, dU)  &&
                     pCrvP->GetPointD1D2( dU, ICurve::FROM_MINUS, ptP))
@@ -2260,6 +2314,8 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
 {
   // numero punti di accelerazione/decelerazione 
    const int ACC_PNT_NUM = 7 ;
+  // lunghezza minima per poter suddividere con punti di accelerazione/decelerazione
+   const double MIN_ACC_LEN = 1.0 ;
 
   // recupero distanze di sicurezza
    double dSafeZ = GetSafeZ() ;
@@ -2281,6 +2337,7 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
       PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
       if ( IsNull( pCurve))
          return false ;
+      double dLen ; pCurve->GetLength( dLen) ;
       double dUprev = 0 ;
       bool bSlowFull = false ;    // modalità speciale per angoli interni con rallentamento uniforme su tutta l'entità
      // se prima entità, approccio e affondo
@@ -2316,19 +2373,23 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
         // direzione finale precedente 
          const ICurve* pCrvP = pCompo->GetCurve( i - 1) ;
          Vector3d vtEnd ; pCrvP->GetEndDir( vtEnd) ;
+         double dLenP ; pCrvP->GetLength( dLenP) ;
         // direzione iniziale corrente
          Vector3d vtStart ; pCrvC->GetStartDir( vtStart) ;
         // angolo tra le direzioni
-         double dAng ;
+         double dAng = 0 ;
          vtEnd.GetAngleXY( vtStart, dAng) ;
+        // se tratto sotto la tolleranza, ignoro la gestione dell'angolo
+         if ( dLen < LEN_TOL  ||  dLenP < LEN_TOL)
+            dAng = 0 ;            
         // Se angolo esterno e richiesto anello esterno
          if ( IsExternalAngle( dAng)  &&  m_Params.m_nExtCornerType == WJET_EC_LOOP) {
            // lunghezza tratti lineari
-            double dTgLen = 0.5 * m_TParams.m_dDiam * tan( 0.5 * dAng * DEGTORAD) ;
+            double dTgLen = 0.5 * m_TParams.m_dDiam * tan( 0.5 * abs( dAng) * DEGTORAD) ;
             if ( m_Params.m_dSideAngle > EPS_ANG_SMALL) {
               // se inclinazione positiva calcolo di quanto deve uscire per non rovinare lo spigolo
                double dW = m_dElev * sin( m_Params.m_dSideAngle * DEGTORAD) ;
-               double dExtraLen = dW / tan( ( 180 - abs( dAng)) / 2 * DEGTORAD) ; 
+               double dExtraLen = dW / tan( 0.5 * ( 180 - abs( dAng)) * DEGTORAD) ; 
                dTgLen += dExtraLen ;
             }         
            // calcolo punti estremi
@@ -2342,31 +2403,42 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
                return false ;
 
            // anello
+            bool bLoopOk = true ;
             PtrOwner<ICurve> pCrvA( GetArc2PVN( ptPe, ptPs, vtEnd, vtN)) ;
             if ( ! IsNull( pCrvA)  &&  pCrvA->GetType() == CRV_ARC) {
-              // suddivido l'anello in due parti per forzare il passaggio dalla posizione vtTool = Z_AX
-               PtrOwner<ICurveComposite> pCompoArc( ConvertCurveToComposite( Release( ( pCrvA)))) ;
-               if ( IsNull( pCompoArc))
-                  return false ;
-               if ( pCompoArc->AddJoint( 0.5)) {
-                 // aggiungo il primo tratto
-                  Vector3d vtCorr = CalcCorrDir( pCompoArc, 1) ;                   
-                  SetToolCorrAuxDir( Z_AX, vtCorr) ;
-                  if ( AddCurveMove( pCompoArc->GetCurve(0), bSplitArcs) == GDB_ID_NULL)
+              // verifico che l'anello non interferisca con la curva di lavoro
+               IntersCurveCurve intAC( *pCrvA, *pCompo) ;
+               if ( intAC.GetIntersCount() == 0) {
+                 // suddivido l'anello in due parti per forzare il passaggio dalla posizione vtTool = Z_AX
+                  PtrOwner<ICurveComposite> pCompoArc( ConvertCurveToComposite( Release( ( pCrvA)))) ;
+                  if ( IsNull( pCompoArc))
                      return false ;
-                 // aggiungo secondo tratto
-                  CalcAndSetToolCorrAuxDir( pCompo, i + 0.5) ;
-                  if ( AddCurveMove( pCompoArc->GetCurve(1), bSplitArcs) == GDB_ID_NULL)
-                     return false ;               
+                  if ( pCompoArc->AddJoint( 0.5)) {
+                    // aggiungo il primo tratto
+                     Vector3d vtCorr = CalcCorrDir( pCompoArc, 1) ;                   
+                     SetToolCorrAuxDir( Z_AX, vtCorr) ;
+                     if ( AddCurveMove( pCompoArc->GetCurve( 0), bSplitArcs) == GDB_ID_NULL)
+                        return false ;
+                    // aggiungo secondo tratto
+                     CalcAndSetToolCorrAuxDir( pCompo, i + 0.5) ;
+                     if ( AddCurveMove( pCompoArc->GetCurve( 1), bSplitArcs) == GDB_ID_NULL)
+                        return false ;               
+                  }
+                  else {
+                    // se non è possibile suddividere anello 
+                     CalcAndSetToolCorrAuxDir( pCompo, i + 0.5) ;
+                     if ( AddCurveMove( pCompoArc, bSplitArcs) == GDB_ID_NULL)
+                        return false ;   
+                  }
                }
-               else {
-                 // se non è possibile suddividere anello 
-                  CalcAndSetToolCorrAuxDir( pCompo, i + 0.5) ;
-                  if ( AddCurveMove( pCompoArc, bSplitArcs) == GDB_ID_NULL)
-                     return false ;   
-               }               
+               else
+                  bLoopOk = false ;
             }
-            else {
+            else
+               bLoopOk = false ;
+
+           // se anello non possibile
+            if ( ! bLoopOk) {
                CalcAndSetToolCorrAuxDir( pCompo, i + 0.5) ;
                if ( AddLinearMove( ptPs, bSplitArcs) == GDB_ID_NULL)
                   return false ;
@@ -2385,9 +2457,12 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
            // Feed ridotta
             double dMinFeed = GetActualReducedFeed() ;
            // ciclo sui punti di accelerazione
-            for ( int j = 1 ; j <= ACC_PNT_NUM ; ++ j) {
-               double dCoeff = j / double( ACC_PNT_NUM) ;
-               double dU ; pCrvC->GetParamAtLength( dCoeff * dAccLen, dU) ;
+            int nAccPntNum = dAccLen > MIN_ACC_LEN - EPS_SMALL ? ACC_PNT_NUM : 1 ;
+            for ( int j = 1 ; j <= nAccPntNum ; ++ j) {
+               double dCoeff = j / double( nAccPntNum) ;
+               double dU = dUprev ; pCrvC->GetParamAtLength( dCoeff * dAccLen, dU) ;
+               if ( abs( dU - dUprev) < EPS_SMALL)
+                  continue ;
                PtrOwner<ICurve> pCrvT( pCrvC->Clone()) ;
                if ( IsNull( pCrvT)  ||  ! pCrvT->TrimStartEndAtParam( dUprev, dU))
                   return false ;
@@ -2428,15 +2503,19 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
                }                          
             }
             if ( ! bSlowFull) {
-               dAccLen = min( dFreeLen - EXTRA_ACC_LEN, ( bReduceFeed ? m_Params.m_dCornerSlowLen : INTANG_ROT_LEN)) ;
+               double dMinLen = dFreeLen / 2 - EXTRA_ACC_LEN ;
+               if ( dMinLen < EPS_SMALL  &&  abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL)
+                  dMinLen = dFreeLen / 2 ;
+               dAccLen = min( dMinLen, ( bReduceFeed ? m_Params.m_dCornerSlowLen : INTANG_ROT_LEN)) ;
                if ( m_Params.m_dSideAngle > 0) {
+                 // verifico sia rispettata la lunghezza minima per non rovinare l'angolo
                   double dW = m_dElev * sin( m_Params.m_dSideAngle * DEGTORAD) ;
                   double dSlowLen = dW / tan( ( 180 - abs( dAng)) / 2 * DEGTORAD) ;
-                  if ( dSlowLen > dFreeLen - EXTRA_ACC_LEN) {
+                  if ( dSlowLen > dFreeLen + EPS_SMALL) {
                      m_pMchMgr->SetLastError( 3204, "Error in WaterJetting : entity too small near inside corner") ;
                      return false ;
                   }
-                  dAccLen = min( dSlowLen + m_Params.m_dCornerSlowLen, dFreeLen - EXTRA_ACC_LEN) ;
+                  dAccLen = max( dAccLen, dSlowLen) ;
                }            
             }
 
@@ -2447,10 +2526,13 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
             double dUend ; pCrvC->GetParamAtLength( dAccLen, dUend) ;
             Vector3d vtTp = CalcToolDir( pCompo, i + dUsta) ;
             Vector3d vtTn = CalcToolDir( pCompo, i + dUend) ;
+            int nAccPntNum = dAccLen > MIN_ACC_LEN - EPS_SMALL ? ACC_PNT_NUM : 1 ;
            // ciclo sui punti di accelerazione
-            for ( int j = 1 ; j <= ACC_PNT_NUM ; ++ j) {
-               double dCoeff = j / double( ACC_PNT_NUM) ;
-               double dU ; pCrvC->GetParamAtLength( dCoeff * dAccLen, dU) ;
+            for ( int j = 1 ; j <= nAccPntNum ; ++ j) {
+               double dCoeff = j / double( nAccPntNum) ;
+               double dU = dUprev ; pCrvC->GetParamAtLength( dCoeff * dAccLen, dU) ;               
+               if ( abs( dUprev - dU) < EPS_SMALL)
+                  continue ;
                PtrOwner<ICurve> pCrvT( pCrvC->Clone()) ;
                if ( IsNull( pCrvT)  ||  ! pCrvT->TrimStartEndAtParam( dUprev, dU))
                   return false ;
@@ -2477,8 +2559,13 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
         // direzione iniziale successiva
          const ICurve* pCrvN = pCompo->GetCurve( i + 1) ;
          Vector3d vtStart ; pCrvN->GetStartDir( vtStart) ;
+         double dLenN ; pCrvN->GetLength( dLenN) ;
         // angolo tra le direzioni
-         double dAng ; vtEnd.GetAngleXY( vtStart, dAng) ;
+         double dAng = 0 ;        
+         vtEnd.GetAngleXY( vtStart, dAng) ;
+         // se tratto sotto la tolleranza, ignoro la gestione dell'angolo
+         if ( dLen < LEN_TOL  ||  dLenN < LEN_TOL)
+            dAng = 0 ;
         // se angolo esterno e richiesto rallentamento esterno, aggiungo decelerazione
          if ( IsExternalAngle( dAng)  &&  m_Params.m_nExtCornerType == WJET_EC_SLOW) {
            // lunghezza entità
@@ -2488,9 +2575,10 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
            // Feed ridotta
             double dMinFeed = GetActualReducedFeed() ;
            // ciclo sui punti di decelerazione
-            for ( int j = 0 ; j < ACC_PNT_NUM ; ++ j) {
-               double dCoeff = j / double( ACC_PNT_NUM) ;
-               double dU ; pCrvC->GetParamAtLength( dLen - ( 1 - dCoeff) * dAccLen, dU) ;
+            int nAccPntNum = dAccLen > MIN_ACC_LEN - EPS_SMALL ? ACC_PNT_NUM : 1 ;
+            for ( int j = 0 ; j < nAccPntNum ; ++ j) {
+               double dCoeff = j / double( nAccPntNum) ;
+               double dU = dUprev ; pCrvC->GetParamAtLength( dLen - ( 1 - dCoeff) * dAccLen, dU) ;
                if ( abs( dUprev - dU) < EPS_SMALL)
                   continue ;
                PtrOwner<ICurve> pCrvT( pCrvC->Clone()) ;
@@ -2516,46 +2604,49 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
             
            // se prima entità e modalità WJET_IC_SLOW_FULL verifico se davvero applicabile controllando angolo con ultima entità 
             if ( i == 0  &&  m_Params.m_nIntCornerType == WJET_IC_SLOW_FULL) {
-                bSlowFull = true ;
-                if ( bClosed) {
-                  // creo una copia della curva senza l'overlap aggiunto
-                   PtrOwner<ICurveComposite> pCrvTmp( pCompo->Clone()) ;
-                   double dLen ; pCrvTmp->GetLength( dLen) ;
-                   if ( IsNull( pCrvTmp)  ||  ! pCrvTmp->TrimEndAtLen( dLen - dAddedOverlap))
-                      return false ;
-                  // verifico che anche angolo sullo start della curva sia di tipo prev
-                   const ICurve* pCrvLast = pCrvTmp->GetLastCurve() ;
-                   Vector3d vtStart ; pCurve->GetStartDir( vtStart) ;
-                   Vector3d vtEnd ; pCrvLast->GetEndDir( vtEnd) ;
-                   if ( AreSameVectorApprox( vtStart, vtEnd)) {
-                     // se curve in tangenza controllo angolo tra l'ultima e la penultima curva
-                      int nCrvNbr = pCrvTmp->GetCurveCount() ;
-                      const ICurve* pCrvP = pCrvTmp->GetCurve( nCrvNbr - 2) ;
-                      pCrvLast->GetStartDir( vtStart) ;
-                      pCrvP->GetEndDir( vtEnd) ;
-                   }
-                  // se angolo precedente non è interno il tratto non va realizzato in modalità full 
-                   double dAngPrev ; vtEnd.GetAngleXY( vtStart, dAngPrev) ;
-                   if ( ! IsInternalAngle( dAngPrev))
-                      bSlowFull = false ;                 
-                }
-               // salvo il valore per l'ultima entità
-                bStartSlowFull = bSlowFull ;
+               bSlowFull = true ;
+               if ( bClosed) {
+                 // creo una copia della curva senza l'overlap aggiunto
+                  PtrOwner<ICurveComposite> pCrvTmp( pCompo->Clone()) ;
+                  double dLen ; pCrvTmp->GetLength( dLen) ;
+                  if ( IsNull( pCrvTmp)  ||  ! pCrvTmp->TrimEndAtLen( dLen - dAddedOverlap))
+                     return false ;
+                 // verifico che anche angolo sullo start della curva sia di tipo prev
+                  const ICurve* pCrvLast = pCrvTmp->GetLastCurve() ;
+                  Vector3d vtStart ; pCurve->GetStartDir( vtStart) ;
+                  Vector3d vtEnd ; pCrvLast->GetEndDir( vtEnd) ;
+                  if ( AreSameVectorApprox( vtStart, vtEnd)) {
+                    // se curve in tangenza controllo angolo tra l'ultima e la penultima curva
+                     int nCrvNbr = pCrvTmp->GetCurveCount() ;
+                     const ICurve* pCrvP = pCrvTmp->GetCurve( nCrvNbr - 2) ;
+                     pCrvLast->GetStartDir( vtStart) ;
+                     pCrvP->GetEndDir( vtEnd) ;
+                  }
+                 // se angolo precedente non è interno il tratto non va realizzato in modalità full 
+                  double dAngPrev ; vtEnd.GetAngleXY( vtStart, dAngPrev) ;
+                  if ( ! IsInternalAngle( dAngPrev))
+                     bSlowFull = false ;                 
+               }
+              // salvo il valore per l'ultima entità
+               bStartSlowFull = bSlowFull ;
             }
 
             if ( bSlowFull)
               // sfrutto tutta la lunghezza a disposizone
                dAccLen = dFreeLen ;
             else {
-               dAccLen = min( dFreeLen - EXTRA_ACC_LEN, ( bReduceFeed ? m_Params.m_dCornerSlowLen : INTANG_ROT_LEN)) ;
+               double dMinLen = dFreeLen - EXTRA_ACC_LEN ;
+               if ( dMinLen < EPS_SMALL  &&  abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL)
+                  dMinLen = dFreeLen ;
+               dAccLen = min( dMinLen, ( bReduceFeed ? m_Params.m_dCornerSlowLen : INTANG_ROT_LEN)) ;
                if ( m_Params.m_dSideAngle > 0) {
                   double dW = m_dElev * sin( m_Params.m_dSideAngle * DEGTORAD) ;
                   double dSlowLen = dW / tan( ( 180 - abs( dAng)) / 2 * DEGTORAD) ;
-                  if ( dSlowLen > dFreeLen - EXTRA_ACC_LEN) {
+                  if ( dSlowLen > dFreeLen + EPS_SMALL) {
                      m_pMchMgr->SetLastError( 3204, "Error in WaterJetting : entity too small near inside corner") ;
                      return false ;
                   }
-                  dAccLen = min( dSlowLen + m_Params.m_dCornerSlowLen, dFreeLen - EXTRA_ACC_LEN) ;
+                  dAccLen = max( dAccLen, dSlowLen) ;
                }
             }
 
@@ -2566,10 +2657,11 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
             double dUend = 1 ;            
             Vector3d vtTp = CalcToolDir( pCompo, i + dUsta) ;        
             Vector3d vtTn = CalcToolDir( pCompo, i + dUend) ;
+            int nAccPntNum = dAccLen > MIN_ACC_LEN - EPS_SMALL ? ACC_PNT_NUM : 1 ;
            // ciclo sui punti di decelerazione
-            for ( int j = 0 ; j < ACC_PNT_NUM ; ++ j) {
-               double dCoeff = j / double( ACC_PNT_NUM) ;
-               double dU ; pCrvC->GetParamAtLength( dLen - ( 1 - dCoeff) * dAccLen, dU) ;
+            for ( int j = 0 ; j < nAccPntNum ; ++ j) {
+               double dCoeff = j / double( nAccPntNum) ;
+               double dU = dUprev ; pCrvC->GetParamAtLength( dLen - ( 1 - dCoeff) * dAccLen, dU) ;
                if ( abs( dUprev - dU) < EPS_SMALL)
                   continue ;
                PtrOwner<ICurve> pCrvT( pCrvC->Clone()) ;
@@ -2862,9 +2954,11 @@ WaterJetting::CalcAndSetToolCorrAuxDir( const ICurveComposite* pCompo, double dU
   // verifico curva
    if ( pCompo == nullptr)
       return false ;
-  // se utensile centrato, direzione di correzione nulla
-   if ( m_Params.m_nWorkSide == WJET_WS_CENTER)
+  // se utensile centrato, direzione di correzione nulla e direzione utensile sempre Z+
+   if ( m_Params.m_nWorkSide == WJET_WS_CENTER) {
+      SetToolDir( Z_AX) ;
       return true ;
+   }      
   // calcolo del versore fresa
    Vector3d vtTool = CalcToolDir( pCompo, dU) ;
   // calcolo del versore correzione
@@ -3013,11 +3107,17 @@ WaterJetting::CalcOffset( ICurveComposite* pCompo, double dSignOffs)
    if ( pCompo->IsClosed()) {
       Vector3d vtStart ; pCompo->GetStartDir( vtStart) ;
       Vector3d vtEnd ; pCompo->GetEndDir( vtEnd) ;
-      if ( ! AreSameVectorEpsilon( vtStart, vtEnd, sin( 5 * DEGTORAD)))
-         nFlag |= ICurve::OFF_FORCE_OPEN ;
+      if ( ! AreSameVectorEpsilon( vtStart, vtEnd, sin( 5 * DEGTORAD))) {
+        // se spigolo forzo apertura solo se è loop esterno
+         double dArea = 0 ; pCompo->GetAreaXY( dArea) ;
+         if ( ( dArea > 0  &&  m_Params.m_nWorkSide == WJET_WS_RIGHT)  ||
+              ( dArea < 0  &&  m_Params.m_nWorkSide == WJET_WS_LEFT))
+            nFlag |= ICurve::OFF_FORCE_OPEN ;
+      }         
    }
   // eseguo offset semplice
-   if ( pCompo->SimpleOffset( dSignOffs, nFlag))
+   constexpr double MAX_ANG_EXT = 135 ;
+   if ( pCompo->SimpleOffset( dSignOffs, nFlag, MAX_ANG_EXT))
       return true ;
   // se curva piatta, provo con offset avanzato
    bool bOk = false ;
@@ -3027,8 +3127,17 @@ WaterJetting::CalcOffset( ICurveComposite* pCompo, double dSignOffs)
       if ( OffsCrv.Make( pCompo, dSignOffs, nFlag)) {
          ICurve* pOffs = OffsCrv.GetLongerCurve() ;
          if ( pOffs != nullptr) {
+            Point3d ptStart ; pCompo->GetStartPoint( ptStart) ;
+            Vector3d vtExtr ; pCompo->GetExtrusion( vtExtr) ;
             pCompo->Clear() ;
             pCompo->AddCurve( pOffs) ;
+           // ripristino estrusione della curva compo ( rimossa dal Clear)
+            pCompo->SetExtrusion( vtExtr) ;
+           // ripristino punto iniziale
+            double dPar ; 
+            int nFlagDist ;
+            if ( DistPointCurve( ptStart, *pCompo).GetParamAtMinDistPoint( 0, dPar, nFlagDist))
+               pCompo->ChangeStartPoint( dPar) ;
             bOk = true ;
          }
       }

WaterJetting.h

@@ -36,8 +36,14 @@ class WaterJetting : public Machining
    public :                           // Operation
       int  GetType( void) const override
               { return OPER_WATERJETTING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nMills == 0) ; }
+      bool IsEmpty( int nEmptyType = NEED_GEOM) const override
+              { if ( m_nMills == 0)
+                   return true ;
+                if ( nEmptyType == NEED_ONE_TP_OK)
+                   return ( ! IsAtLeastOnePathOk()) ;
+                if ( nEmptyType == NEED_ALL_TP_OK)
+                   return ( ! AreAllPathsOk()) ;
+                return false ; }
       bool UpdateStatus( int nModif) override
               { m_nStatus |= nModif ; return true ; }
 
@@ -61,7 +67,7 @@ class WaterJetting : public Machining
       bool GetParam( int nType, int& nVal) const override ;
       bool GetParam( int nType, double& dVal) const override ;
       bool GetParam( int nType, std::string& sVal) const override ;
-      bool UpdateToolData( bool* pbChanged = nullptr) override ;
+      bool UpdateToolData( void) override ;
       const ToolData& GetToolData( void) const override ;
       bool GetGeometry( SELVECTOR& vIds) const override ;
 
@@ -72,12 +78,12 @@ class WaterJetting : public Machining
       bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
       bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
       bool Chain( int nGrpDestId) ;
-      bool AdjustCurvesForBridges( ICURVEPOVECTOR& vpCrvs, SELVECTOR& vInds) ;
+      bool AdjustCurvesForBridges( ICURVEPOVECTOR& vpCrvs) ;
       bool VerifySideAngle( void) ;
       bool ProcessPath( int nPathId, int nPvId, int nClId) ;
       bool AdjustPathForInternalAngles( ICurveComposite* pCompo) ;
       bool GeneratePreView( int nPathId, const ICurveComposite* pCompo, double dAddedOverlap) ;
-      ISurfFlatRegion* GenerateLeadInPreview( const ICurveComposite* pCompo) ;
+      ISurfFlatRegion* GenerateLeadInPreview( const ICurveComposite* pCompo, bool bClosed) ;
       ISurfFlatRegion* GenerateLeadOutPreview( const ICurveComposite* pCompo) ;
       bool AddLoopsPreview( const ICurveComposite* pCompo, ISurfFlatRegion* pSPV) ;
       bool AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTool, bool bSplitArcs, double dAddedOverlap) ;