EgtMachKernel :

- modifica funzione lati aperti.

Chiseling.cpp

@@ -1010,7 +1010,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, 0) ;
      // la restituisco
       lstPC.emplace_back( Release( pCrvCompo)) ;
       return true ;
@@ -1046,7 +1046,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, 0) ;
            // la restituisco
             lstPC.emplace_back( Release( pCrvCompo)) ;
          }
@@ -1517,7 +1517,7 @@ Chiseling::GenerateChiselingCl( const SqHole& hole, int nPathId)
    SetAuxDir( hole.vtAux) ;
   // 1 -> punto approccio
    SetFlag( 1) ;
-   double dAppr = GetSafeZ() ;
+   double dAppr = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
    Point3d ptP1 = hole.ptIni + hole.vtExtr * dAppr ;
    if ( AddRapidStart( ptP1) == GDB_ID_NULL)
       return false ;

Disposition.cpp

@@ -887,7 +887,7 @@ Disposition::MoveToCornerRawPart( int nRawId, const Point3d& ptP, int nFlag, boo
    case MCH_CR_TR :
       vtMove = ( m_ptRef1 + ptP) - Point3d( b3Raw.GetMax().x, b3Raw.GetMax().y, b3Raw.GetMin().z) ;
       break ;
-   default : // MCH_CR_BL
+   default : // RPCP_BL
       vtMove = ( m_ptRef1 + ptP) - b3Raw.GetMin() ;
       break ;
    case MCH_CR_BR :
@@ -938,7 +938,7 @@ Disposition::MoveToCenterRawPart( int nRawId, const Point3d& ptP, int nFlag, boo
    case MCH_CE_TC :
       vtMove = ( m_ptRef1 + ptP) - Point3d( ptCen.x, b3Raw.GetMax().y, ptCen.z) ;
       break ;
-   default : // MCH_CE_ML
+   default : // RPCE_ML
       vtMove = ( m_ptRef1 + ptP) - Point3d( b3Raw.GetMin().x, ptCen.y, ptCen.z) ;
       break ;
    case MCH_CE_MR :
@@ -1062,7 +1062,7 @@ Disposition::RotateRawPart( int nRawId, const Vector3d& vtAx, double dAngRotDeg)
          case MCH_CR_TR :
             vtCorr = Vector3d( b3Raw.GetMax().x - b3OriRaw.GetMax().x, b3Raw.GetMax().y - b3OriRaw.GetMax().y, b3Raw.GetMin().z - b3OriRaw.GetMin().z) ;
             break ;
-         default : // MCH_CR_BL
+         default : // RPCP_BL
             vtCorr = Vector3d( b3Raw.GetMin().x - b3OriRaw.GetMin().x, b3Raw.GetMin().y - b3OriRaw.GetMin().y, b3Raw.GetMin().z - b3OriRaw.GetMin().z) ;
             break ;
          case MCH_CR_BR :
@@ -1077,7 +1077,7 @@ Disposition::RotateRawPart( int nRawId, const Vector3d& vtAx, double dAngRotDeg)
          case MCH_CE_TC :
             vtCorr = Vector3d( ptCen.x - ptOriCen.x, b3Raw.GetMax().y - b3OriRaw.GetMax().y, ptCen.z - ptOriCen.z) ;
             break ;
-         default : // MCH_CE_ML
+         default : // RPCE_ML
             vtCorr = Vector3d( b3Raw.GetMin().x - b3OriRaw.GetMin().x, ptCen.y - ptOriCen.y, ptCen.z - ptOriCen.z) ;
             break ;
          case MCH_CE_MR :

Drilling.cpp

@@ -51,7 +51,6 @@ using namespace std ;
 // 2115 = "Error in Drilling : Mirror for Double calculation failed"
 // 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"
 // 2151 = "Warning in Drilling : Skipped entity (xx)"
 // 2152 = "Warning in Drilling : No machinable path"
 // 2153 = "Warning in Drilling : Tool name changed (xx)"
@@ -97,6 +96,7 @@ struct HoleInfo {
       int nIndInSelVector = 0 ;     // indice nel vettore m_vId (id fori selezionati)
    } ;
 
+
 struct ToolInfo
 {
    const ToolData* pTool ;        // puntatore per utensile (nullo se utensile non presente)
@@ -246,7 +246,6 @@ Drilling::Drilling( void)
 {
    m_Params.m_sName = "*" ;
    m_Params.m_sToolName = "*" ;
-   m_Params.m_sDepth = "TH" ;
    m_TParams.m_sName = "*" ;
    m_TParams.m_sHead = "*" ;
    m_nStatus = MCH_ST_TO_VERIFY ;
@@ -490,15 +489,17 @@ Drilling::SetGeometry( const SELVECTOR& vIds)
    m_vId.clear() ;
   // se lavorazione standard
    if ( m_Params.m_nSubType == DRI_SUB_STD) {
-     // verifico che gli identificativi rappresentino dei fori (il corretto diametro è verificato dopo)
+     // recupero il valore di tolleranza sul diametro
+     //double dDiamTol = m_pMchMgr->GetCurrMachiningsMgr()->GetHoleDiamToler() ;
+     // verifico che gli identificativi rappresentino dei fori con il corretto diametro
       for ( int i = 0 ; i < int( vIds.size()) ; ++ i) {
         // recupero i dati del foro
-         Hole hole ;
-         if ( ! GetHoleData( vIds[i], hole)) {
-            string sInfo = "Warning in Drilling : Skipped entity " + ToString( vIds[i].nId) ;
-            m_pMchMgr->SetWarning( 2151, sInfo) ;
-            continue ;
-         }
+         //Hole hole ;
+         //if ( ! GetHoleData( vIds[i], hole)  ||  !VerifyDiameter(hole.dDiam, m_TParams.m_dDiam, dDiamTol)) {
+         //   string sInfo = "Warning in Drilling : Skipped entity " + ToString( vIds[i].nId) ;
+         //   m_pMchMgr->SetWarning( 2151, sInfo) ;
+         //   continue ;
+         //}
         // posso aggiungere alla lista
          m_vId.push_back( vIds[i]) ;
       }
@@ -615,12 +616,6 @@ Drilling::Apply( bool bRecalc, bool bPostApply)
       nDblId = GDB_ID_NULL ;
    }
 
-  // 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( 2118, "Error in Drilling : Tool loading failed") ;
-      return false ;
-   }
-
   // se lavorazione standard
    if ( m_Params.m_nSubType == DRI_SUB_STD) {
       if ( ! StandardProcess( bRecalc, GDB_ID_NULL, nClId))
@@ -717,67 +712,28 @@ Drilling::Update( bool bPostApply)
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-Drilling::VerifyMultiParallelFixedDrills( void)
-{
-  // se aggregato da sotto, sicuramente con una sola punta
-   bool bAggrBottom = IsAggrBottom( m_TParams.m_sHead) ;
-   if ( bAggrBottom)
-      return false ;
-  // se una sola uscita, inutile continuare
-   int nExitCnt = m_pMchMgr->GetCurrMachine()->GetHeadExitCount( m_TParams.m_sHead) ;
-   if ( nExitCnt == 1)
-      return false ;
-  // verifico che le uscite siano fisse
-   int nSelectType = m_pMchMgr->GetCurrMachine()->GetHeadSelectType( m_TParams.m_sHead) ;
-   if ( nSelectType != MCH_SLT_FIXEDEXITS)
-      return false ;
-  // recupero la direzione dell'utensile principale
-   Point3d ptMainExit ; Vector3d vtMainTool, vtMainAux ;
-   m_pMchMgr->GetCurrMachine()->GetHeadExitPosDirAux( m_TParams.m_sHead, m_TParams.m_nExit, ptMainExit, vtMainTool, vtMainAux) ;
-  // verifico ci sia almeno un'altra uscita attrezzata parallela a quella principale
-   for ( int nT = 0 ; nT < nExitCnt ; ++ nT) {
-      if ( nT + 1 == m_TParams.m_nExit)
-         continue ;
-      string sToolName ;
-      if ( m_pMchMgr->GetLoadedTool( m_TParams.m_sHead, nT + 1, sToolName)  &&  ! sToolName.empty()) {
-        // recupero la tipologia di utensile
-         int nType = TT_NONE ;
-         string sCurrTool ; m_pMchMgr->TdbGetCurrToolParam( TPA_NAME, sCurrTool) ;
-         if ( m_pMchMgr->TdbSetCurrTool( sToolName)) {
-            m_pMchMgr->TdbGetCurrToolParam( TPA_TYPE, nType) ;
-            if ( ! IsEmptyOrSpaces( sCurrTool))
-               m_pMchMgr->TdbSetCurrTool( sCurrTool) ;
-         }
-        // verifico punta o fresa con direzione corretta
-         Point3d ptExit ; Vector3d vtTool, vtAux ;
-         if ( ( ( nType & TF_DRILLBIT) != 0  ||  nType == TT_MILL_STD)  &&
-              m_pMchMgr->GetCurrMachine()->GetHeadExitPosDirAux(m_TParams.m_sHead, nT + 1, ptExit, vtTool, vtAux)  &&
-              AreSameVectorApprox( vtTool, vtMainTool))
-            return true ;
-      }
-   }
-  // non è stato trovato niente
-   return false ;
-}
-
 //----------------------------------------------------------------------------
 bool
 Drilling::StandardProcess( bool bRecalc, int nPvId, int nClId)
 {
-  // se ho almeno un'altra punta fissa parallela alla principale ...
-   if ( VerifyMultiParallelFixedDrills()) {
-      TABMHDRILL tabDrills ;
-      double dMHOff = 0 ;
-      if ( ! MultiHeadDrilling( m_vId, nClId, tabDrills, dMHOff))
+  // controllo se ho più uscite
+   string sCurrHead ;
+   if ( ! m_pMchMgr->GetCurrMachine()->GetCurrHead( sCurrHead))
+      return false ;
+   int nExitCnt = m_pMchMgr->GetCurrMachine()->GetHeadExitCount( sCurrHead) ;
+   TABMHDRILL tabDrills ;
+   double dMHOff = 0 ;
+  // se ho più uscite...
+   if ( nExitCnt > 1) {
+      if ( ! MultiHeadDrilling( nExitCnt, m_vId, nClId, tabDrills, dMHOff))
          return false ;
-      if ( tabDrills.empty())
+      if( tabDrills.size() == 0)
          return true ;
+      int j = 0 ;
       for ( int i = 0 ; i < ( int)tabDrills.size() ; ++i) {
         // se richiesto preview
          if ( nPvId != GDB_ID_NULL) {
-            if ( ! GenerateHolePv( i, m_vId[tabDrills[i][0].nInd_id_hole], MCH_PATH, nPvId))
+            if ( ! GenerateHolePv( j, m_vId[tabDrills[i][0].nInd_id_hole], MCH_PATH, nClId))
                return false ;
            // creo la regione di ingombro del foro
             int nDriId = m_pGeomDB->GetFirstInGroup( m_pGeomDB->GetLastGroupInGroup( nPvId)) ;
@@ -785,15 +741,17 @@ Drilling::StandardProcess( bool bRecalc, int nPvId, int nClId)
          }
         // se richiesta lavorazione
          if ( nClId != GDB_ID_NULL) {
-            if ( ! GenerateHoleCl( i, m_vId[tabDrills[i][0].nInd_id_hole], MCH_PATH, nClId, dMHOff, tabDrills[i][0].vtAux))
+            if ( ! GenerateHoleCl( j, m_vId[tabDrills[i][0].nInd_id_hole], MCH_PATH, nClId, dMHOff, tabDrills[i][0].vtAux))
                return false ;
          }
+        // incremento indice
+         ++j ;
       }
       return true ;
    }
   // ... altrimenti elaboro i singoli fori
-   for ( int i = 0 ; i < int( m_vId.size()) ; ++ i) {
-      const auto& vId = m_vId[i] ;
+   int i = 0 ;
+   for ( const auto& vId : m_vId) {
      // se richiesto preview
       if ( nPvId != GDB_ID_NULL) {
          if ( ! GenerateHolePv( i, vId, MCH_PATH, nPvId))
@@ -807,6 +765,8 @@ Drilling::StandardProcess( bool bRecalc, int nPvId, int nClId)
          if ( ! GenerateHoleCl( i, vId, MCH_PATH, nClId))
             return false ;
       }
+     // incremento indice
+      ++i ;
    }
 
    return true ;
@@ -814,29 +774,29 @@ Drilling::StandardProcess( bool bRecalc, int nPvId, int nClId)
 
 //----------------------------------------------------------------------------
 bool 
-Drilling::MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& tabDrills, double& dMHOff, bool bOrd)
+Drilling::MultiHeadDrilling( int nExitCnt, const SELVECTOR& vId, int nClId, TABMHDRILL& tabDrills, double& dMHOff, bool bOrd)
 {
   // controllo parametri
    tabDrills.clear() ;
    if ( vId.empty())
       return true ;
+
+  // recupero il nome della testa
+   string sHead ;
+   m_pMchMgr->GetCurrMachine()->GetCurrHead( sHead) ;
   
   // gestore degli utensili
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
 
-  // recupero il nome della testa e il numero di uscite
-   string sHead ;
-   m_pMchMgr->GetCurrMachine()->GetCurrHead( sHead) ;
-   int nExitCnt = m_pMchMgr->GetCurrMachine()->GetHeadExitCount( sHead) ;
-
   // Recupero i dati degli utensili montati sulla testa
    int nMainToolInd = -1 ;
    VECTORTOOL vTools ; vTools.reserve( nExitCnt) ;
   // ricavo gli utensili presenti sulle uscite
    for ( int nT = 0 ; nT < nExitCnt ; ++ nT) {
       string sToolName ;
+      ToolInfo TInf ;
       if ( ! m_pMchMgr->GetLoadedTool( sHead, nT + 1, sToolName)  ||  sToolName.empty()) {
         // non c'è utensile 
          vTools.emplace_back( nullptr) ;
@@ -856,23 +816,9 @@ Drilling::MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& tabDri
       return false ;
    }
 
-  // recupero i dati dell'uscita dell'utensile principale
+  // carico i dati della testa con le sue uscite
    Vector3d vtTool, vtAux ;
-   Point3d ptExit ;
-   m_pMchMgr->GetCurrMachine()->GetHeadExitPosDirAux( sHead, nMainToolInd + 1, ptExit, vtTool, vtAux) ;
-   vTools[nMainToolInd].ptToolTip = ptExit - vtTool * vTools[nMainToolInd].pTool->m_dLen ;
-   if ( vtAux.IsSmall()  &&  m_pMchMgr->GetCurrMachine()->GetCurrRotAxes() == 0)
-      vtAux = FromUprightOrtho( vtTool) ;
-   if ( vtTool.IsSmall()  ||  vtAux.IsSmall()) {
-      m_pMchMgr->SetLastError( 2117, "Error in Drilling : incorrect multi drilling head") ;
-      return false ;
-   }
-
-  // carico gli altri dati della testa con le sue uscite
    for ( int nT = 0 ; nT < nExitCnt ; ++ nT) {
-     // se utensile principale, salto al successivo
-      if ( nT == nMainToolInd)
-         continue ;
      // se non attrezzato, salto al successivo
       if ( vTools[nT].pTool == nullptr)
          continue ;
@@ -880,14 +826,26 @@ Drilling::MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& tabDri
       Point3d ptExit ;
       Vector3d vtCurrDir, vtCurrAux ;
       m_pMchMgr->GetCurrMachine()->GetHeadExitPosDirAux( sHead, nT + 1, ptExit, vtCurrDir, vtCurrAux) ;
-     // controllo abbia la stessa direzione del principale, altrimenti disattrezzo
-      if ( ! AreSameVectorApprox( vtCurrDir, vtTool)) {
-         vTools[nT].pTool = nullptr ;
-         continue ;
+     // se utensile successivo
+      if ( ! vtTool.IsSmall()) {
+        // controllo abbia la stessa direzione dei precedenti, altrimenti errore
+         if ( ! AreSameVectorApprox( vtCurrDir, vtTool)) {
+            vtTool = V_NULL ;
+            break ;
+         }
+      }
+     // altrimenti primo utensile
+      else {
+         vtTool = vtCurrDir ;
+         vtAux = vtCurrAux ;
       }
      // assegno tip utensile
       vTools[nT].ptToolTip = ptExit - vtCurrDir * vTools[nT].pTool->m_dLen ;
    }
+   if ( vtTool.IsSmall()  ||  vtAux.IsSmall()) {
+      m_pMchMgr->SetLastError( 2117, "Error in Drilling : incorrect multi drilling head") ;
+      return false ;
+   }
 
   // Recupero le geometrie dei fori
    bool bSomeHoleOk = false ;
@@ -928,7 +886,7 @@ Drilling::MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& tabDri
   // i fori con dimensione 0 del vettore vToolHole non possono essere lavorati
    int nNoDrillHoles = 0 ;
    for ( int i = 0 ; i < ( int)vHoles.size() ; ++ i) {
-      if ( vHoles[i].vToolHole.empty())
+      if ( vHoles[i].vToolHole.size() == 0)
          ++ nNoDrillHoles ;
    }
 
@@ -939,19 +897,10 @@ Drilling::MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& tabDri
   // numero di fori lavorati
    int nOkHole = 0 ;
 
-  // se c'è un solo foro va sicuramente bene
-   if ( vHoles.size() == 1  &&  ! vHoles[0].vVtAux.empty()) {
-      vHoles[0].bForToolM = true ;
-      vHoles[0].nIndTool = nMainToolInd ;
-      vHoles[0].nIndHoleToolM = 0 ;
-      vHoles[0].vtAux = vHoles[0].vVtAux[0] ;
-   }
-
   // decido in quali fori inserire il tool principale
    for ( int nCheck = 1 ; nCheck < ( int)vHoles.size()  &&  nOkHole < ( int)vHoles.size() - nNoDrillHoles ; ++ nCheck) {
       for ( int i = 0 ; i < ( int)vHoles.size() ; ++i) {
-        // prendo tutti i fori con vToolHope di lunghezza nCheck non già lavorati
-         if ( vHoles[i].vToolHole.size() == nCheck  &&  ! vHoles[i].bDrill) {
+         if ( vHoles[i].vToolHole.size() == nCheck  &&  ! vHoles[i].bDrill) { // prendo tutti i fori con vToolHope di lunghezza nCheck non già svuotati
             vHoles[vHoles[i].vToolHole[0]].bForToolM = true ;
             vHoles[vHoles[i].vToolHole[0]].nIndTool = nMainToolInd ;
             vHoles[vHoles[i].vToolHole[0]].nIndHoleToolM = vHoles[i].vToolHole[0] ;
@@ -1070,7 +1019,7 @@ Drilling::CalcMask( VECTORHOLE& vHoles, const VECTORTOOL& vTools, int nIndMT, co
       return false ;
 
   // recupero il valore di tolleranza sul diametro
-   double dDiamToler = GetHoleDiamToler() ;
+   double dDiamToler = m_pMchMgr->GetCurrMachiningsMgr()->GetHoleDiamToler() ;
 
    int nExitCnt = ( int)vTools.size() ;
    int nNullTools = 0 ;
@@ -1106,8 +1055,6 @@ Drilling::CalcMask( VECTORHOLE& vHoles, const VECTORTOOL& vTools, int nIndMT, co
      // nuova configurazione del versore A ottenuta
       if ( ! m_pMchMgr->GetCalcAuxDirFromAngles( vAng1, vtAnew))
          continue ;
-      if ( vtAnew.IsSmall()  &&  m_pMchMgr->GetCurrMachine()->GetCurrRotAxes() == 0)
-         vtAnew = vtAux ;
 
      // creo un nuovo sistema di riferimento centrato nel Tool principale
       Frame3d frMT ; 
@@ -1577,7 +1524,7 @@ Drilling::GenerateHolePv( int nInd, const SelData& nCircId, const string& sPName
    m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( nCircId)) ;
    m_pGeomDB->SetMaterial( nPathId, GREEN) ;
   // recupero il valore di tolleranza sul diametro
-   double dDiamTol = GetHoleDiamToler() ;
+   double dDiamTol = m_pMchMgr->GetCurrMachiningsMgr()->GetHoleDiamToler() ;
   // recupero i dati del foro
    Hole hole ;
    if ( ! GetHoleData( nCircId, hole)  ||  ! VerifyDiameter( hole.dDiam, m_TParams.m_dDiam, dDiamTol)) {
@@ -1621,7 +1568,7 @@ Drilling::GenerateHoleCl( int nInd, const SelData& nCircId, const string& sPName
    m_pGeomDB->SetInfo( nPathId, KEY_IDS, ToString( nCircId)) ;
    m_pGeomDB->SetMaterial( nPathId, GREEN) ;
   // recupero il valore di tolleranza sul diametro
-   double dDiamTol = GetHoleDiamToler() ;
+   double dDiamTol = m_pMchMgr->GetCurrMachiningsMgr()->GetHoleDiamToler() ;
   // recupero i dati del foro
    Hole hole ;
    if ( ! GetHoleData( nCircId, hole)  ||  ! VerifyDiameter( hole.dDiam, m_TParams.m_dDiam, dDiamTol)) {
@@ -1690,7 +1637,7 @@ Drilling::GenerateHoleCl( int nInd, const SelData& nCircId, const string& sPName
       }
    }
    else {
-      if ( DoPeckDrilling( hole, nCircId, nPathId, dMHOff, vtA)) {
+      if ( DoPeckDrilling( hole, nCircId, nPathId)) {
         // aggiorno numero forature
          ++ m_nDrillings ;
       }
@@ -1711,7 +1658,7 @@ Drilling::GenerateHoleRegionPv( int nFirstId, int nCount, int nPvId)
   // raggio dei fori
    double dRad = m_TParams.m_dDiam / 2 ;
   // extra raggio
-   double dExtraR = GetExtraROnDrillRegion() ;
+   double dExtraR = m_pMchMgr->GetCurrMachiningsMgr()->GetExtraROnDrillRegion() ;
 
   // gruppo di inserimento
    int nGroupId = m_pGeomDB->GetLastGroupInGroup( nPvId) ;
@@ -2097,7 +2044,7 @@ Drilling::VerifyHoleFromBottom( const Hole& hole, SelData Id)
 
 //----------------------------------------------------------------------------
 bool
-Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double dMHOff, const Vector3d& vtA)
+Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double dMHOff, Vector3d vtA)
 {
   // aggiusto alcuni parametri del ciclo di foratura
    double dStartSlowLen = abs( m_Params.m_dStartSlowLen) ;
@@ -2119,46 +2066,30 @@ Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double
    GetElevation( m_nPhase, hole.ptIni, hole.vtDir, m_TParams.m_dDiam / 2, hole.vtDir, dElev) ;
   // determino alcune caratteristiche dell'utensile
    double dTExtrLen = max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;
-  // necessità di spezzatura per robot
-   bool bSplitArcs = GetSplitArcs( V_NULL) ;
   // imposto dati comuni
    SetPathId( nPathId) ;
    SetToolDir( hole.vtDir) ;
   // 1 -> punto approccio (se con aggregato da sotto è una sequenza di approccio)
    SetFlag( 1) ;
-   double dSafeZ = GetSafeZ() ;
-   double dSafeAggrBottZ = GetSafeAggrBottZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
+   double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
    double dAppr = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
    Point3d ptP1 = hole.ptIni + hole.vtDir * ( dAppr + dElev + dTExtrLen + dMHOff) ;
    if ( m_bAggrBottom) {
       Point3d ptP0 = ptP1 + m_vtAggrBottom * ( m_dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
+      Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ;
       // se rinvio da sotto che richiede speciale rotazione
       if ( m_AggrBottom.nType == 1) {
-        // punto ruotato
-         Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ;
          Vector3d vtAux = m_vtAggrBottom ;
          vtAux.Rotate( Z_AX, 0, 1) ;
          SetAuxDir( vtAux) ;
          if ( AddRapidStart( ptP00, MCH_CL_AGB_DWN) == GDB_ID_NULL)
             return false ;
-        // vado al punto standard
          SetAuxDir( m_vtAggrBottom) ;
          SetFlag( 0) ;
-         if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_IN) == GDB_ID_NULL)
+         if ( AddRapidMove( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
             return false ;
       }
-     // se altrimenti con rotazione per minimizzare la sporgenza
-      else if ( m_AggrBottom.nType == 3) {
-        // punto standard ruotato
-         Vector3d vtAux = m_vtAggrBottom ;
-         vtAux.Rotate( Z_AX, 0, 1) ;
-         SetAuxDir( vtAux) ;
-         if ( AddRapidStart( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
-            return false ;
-        // la rotazione viene eseguita nel movimento successivo al punto sopra l'inizio lavorazione
-         SetAuxDir( m_vtAggrBottom) ;
-         SetFlag( 0) ;
-      }
       // altrimenti rinvio normale
       else {
          SetAuxDir( m_vtAggrBottom) ;
@@ -2166,11 +2097,11 @@ Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double
             return false ;
          SetFlag( 0) ;
       }
-      if ( AddRapidMove( ptP1, bSplitArcs) == GDB_ID_NULL)
+      if ( AddRapidMove( ptP1) == GDB_ID_NULL)
          return false ;
    }
    else {
-      if ( ! vtA.IsSmall())
+      if( ! vtA.IsSmall())
          SetAuxDir( vtA) ;
       if ( AddRapidStart( ptP1) == GDB_ID_NULL)
          return false ;
@@ -2179,7 +2110,7 @@ Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double
   // 2 -> punto fuori (se diverso dal precedente)
    if ( m_Params.m_dStartPos < dAppr) {
       Point3d ptP2 = hole.ptIni + hole.vtDir * ( m_Params.m_dStartPos + dTExtrLen) ;
-      if ( AddRapidMove( ptP2, bSplitArcs) == GDB_ID_NULL)
+      if ( AddRapidMove( ptP2) == GDB_ID_NULL)
          return false ;
    }
   // 3 -> punto termine velocità ridotta iniziale (se previsto)
@@ -2190,7 +2121,7 @@ Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double
       Point3d ptP3 = hole.ptIni - hole.vtDir * dStartSlowLen ;
       if ( ! bStd  &&  ! bEndSlow)
          ptP3 -= hole.vtDir * dAddLen ;
-      if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
+      if ( AddLinearMove( ptP3) == GDB_ID_NULL)
          return false ;
    }
   // 4 -> punto termine velocità standard (se risulta)
@@ -2201,7 +2132,7 @@ Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double
       Point3d ptP4 = hole.ptIni - hole.vtDir * ( hole.dLen - dEndSlowLen) ;
       if ( ! bEndSlow)
          ptP4 -= hole.vtDir * dAddLen ;
-      if ( AddLinearMove( ptP4, bSplitArcs) == GDB_ID_NULL)
+      if ( AddLinearMove( ptP4) == GDB_ID_NULL)
          return false ;
    }
   // 5 -> punto termine velocità finale ridotta (se previsto)
@@ -2209,35 +2140,27 @@ Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double
       SetFeed( GetTipFeed()) ;
       SetFlag( 101) ;          // fondo del foro
       Point3d ptP5 = hole.ptIni - hole.vtDir * ( hole.dLen + dAddLen) ;
-      if ( AddLinearMove( ptP5, bSplitArcs) == GDB_ID_NULL)
+      if ( AddLinearMove( ptP5) == GDB_ID_NULL)
          return false ;
    }
   // 6 -> ritorno all'approccio del foro
    SetFeed( GetEndFeed()) ;
    SetFlag( 104) ;             // risalita sopra il foro
-   if ( AddLinearMove( ptP1, bSplitArcs) == GDB_ID_NULL)
+   if ( AddLinearMove( ptP1) == GDB_ID_NULL)
       return false ;
   // 7 -> punto fuori (se uso aggregato da sotto)
    if ( m_bAggrBottom) {
-     // se con rotazione per minimizzare la sporgenza
-      if ( m_AggrBottom.nType == 3) {
-        // imposto rotazione su punto standard
-         Vector3d vtAux = m_vtAggrBottom ;
-         vtAux.Rotate( Z_AX, 0, 1) ;
-         SetAuxDir( vtAux) ;
-      }
       SetFlag( 0) ;
-     // vado al punto
       Point3d ptP0 = ptP1 + m_vtAggrBottom * ( m_dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
-      if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_OUT) == GDB_ID_NULL)
+      Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ;
+      if ( AddRapidMove( ptP0, MCH_CL_AGB_OUT) == GDB_ID_NULL)
          return false ;
-     // se rinvio da sotto che richiede speciale rotazione
+      // se rinvio da sotto che richiede speciale rotazione
       if ( m_AggrBottom.nType == 1) {
-         Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ;
          Vector3d vtAux = m_vtAggrBottom ;
          vtAux.Rotate( Z_AX, 0, 1) ;
          SetAuxDir( vtAux) ;
-         if ( AddRapidMove( ptP00, bSplitArcs, MCH_CL_AGB_UP) == GDB_ID_NULL)
+         if ( AddRapidMove( ptP00, MCH_CL_AGB_UP) == GDB_ID_NULL)
             return false ;
       }
    }
@@ -2250,7 +2173,7 @@ Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double
 
 //----------------------------------------------------------------------------
 bool
-Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHOff, const Vector3d& vtA)
+Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId)
 {
   // aggiusto alcuni parametri del ciclo di foratura
    double dStartSlowLen = abs( m_Params.m_dStartSlowLen) ;
@@ -2274,46 +2197,30 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHO
    GetElevation( m_nPhase, hole.ptIni, hole.vtDir, m_TParams.m_dDiam / 2, hole.vtDir, dElev) ;
   // determino alcune caratteristiche dell'utensile
    double dTExtrLen = max( 0.0, m_TParams.m_dTLen - m_TParams.m_dLen) ;
-  // necessità di spezzatura per robot
-   bool bSplitArcs = GetSplitArcs( V_NULL) ;
   // imposto dati comuni
    SetPathId( nPathId) ;
    SetToolDir( hole.vtDir) ;
   // 1 -> punto approccio
    SetFlag( 1) ;
-   double dSafeZ = GetSafeZ() ;
-   double dSafeAggrBottZ = GetSafeAggrBottZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
+   double dSafeAggrBottZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ;
    double dAppr = ( m_bAggrBottom ? dSafeAggrBottZ : dSafeZ) ;
-   Point3d ptP1 = hole.ptIni + hole.vtDir * ( dAppr + dElev + dTExtrLen + dMHOff) ;
+   Point3d ptP1 = hole.ptIni + hole.vtDir * ( dAppr + dElev + dTExtrLen) ;
    if ( m_bAggrBottom) {
       Point3d ptP0 = ptP1 + m_vtAggrBottom * ( m_dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
+      Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ;
       // se rinvio da sotto che richiede speciale rotazione
       if ( m_AggrBottom.nType == 1) {
-        // punto ruotato
-         Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ;
          Vector3d vtAux = m_vtAggrBottom ;
          vtAux.Rotate( Z_AX, 0, 1) ;
          SetAuxDir( vtAux) ;
          if ( AddRapidStart( ptP00, MCH_CL_AGB_DWN) == GDB_ID_NULL)
             return false ;
-        // vado al punto standard
          SetFlag( 0) ;
          SetAuxDir( m_vtAggrBottom) ;
-         if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_IN) == GDB_ID_NULL)
+         if ( AddRapidMove( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
             return false ;
       }
-     // se altrimenti con rotazione per minimizzare la sporgenza
-      else if ( m_AggrBottom.nType == 3) {
-        // punto standard ruotato
-         Vector3d vtAux = m_vtAggrBottom ;
-         vtAux.Rotate( Z_AX, 0, 1) ;
-         SetAuxDir( vtAux) ;
-         if ( AddRapidStart( ptP0, MCH_CL_AGB_IN) == GDB_ID_NULL)
-            return false ;
-        // la rotazione viene eseguita nel movimento successivo al punto sopra l'inizio lavorazione
-         SetAuxDir( m_vtAggrBottom) ;
-         SetFlag( 0) ;
-      }
       // altrimenti rinvio normale
       else {
          SetAuxDir( m_vtAggrBottom) ;
@@ -2321,12 +2228,10 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHO
             return false ;
          SetFlag( 0) ;
       }
-      if ( AddRapidMove( ptP1, bSplitArcs) == GDB_ID_NULL)
+      if ( AddRapidMove( ptP1) == GDB_ID_NULL)
          return false ;
    }
    else {
-      if ( ! vtA.IsSmall())
-         SetAuxDir( vtA) ;
       if ( AddRapidStart( ptP1) == GDB_ID_NULL)
          return false ;
    }
@@ -2334,11 +2239,11 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHO
   // 2 -> punto fuori (se diverso dal precedente)
    if ( m_Params.m_dStartPos < dAppr) {
       Point3d ptP2 = hole.ptIni + hole.vtDir * ( m_Params.m_dStartPos + dTExtrLen) ;
-      if ( AddRapidMove( ptP2, bSplitArcs) == GDB_ID_NULL)
+      if ( AddRapidMove( ptP2) == GDB_ID_NULL)
          return false ;
    }
   // ciclo di affondamento a step
-   const double MIN_STEP = 1 ;
+   const double MIN_STEP = 5 ;
    const double APPR_STEP = 1 ;
    const double MIN_MOVE = 1 ;
    double dStep = max( m_Params.m_dStep, MIN_STEP) ;
@@ -2354,13 +2259,13 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHO
          SetFeed( GetEndFeed()) ;
          SetFlag( 103) ;             // punto di scarico truciolo
          Point3d ptPr = hole.ptIni + hole.vtDir * dReturnPos ;
-         if ( AddLinearMove( ptPr, bSplitArcs) == GDB_ID_NULL)
+         if ( AddLinearMove( ptPr) == GDB_ID_NULL)
             return false ;
         // riaffondo
          SetFeed( GetEndFeed()) ;
          SetFlag( 0) ;
          Point3d ptPa = hole.ptIni - hole.vtDir * ( dCurrLen - APPR_STEP) ;
-         if ( AddLinearMove( ptPa, bSplitArcs) == GDB_ID_NULL)
+         if ( AddLinearMove( ptPa) == GDB_ID_NULL)
             return false ;
       }
      // lunghezza di fine step
@@ -2383,7 +2288,7 @@ 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)
+         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
             return false ;
         // aggiorno posizione e verifico se step completato
          dCurrLen = dLen ;
@@ -2408,7 +2313,7 @@ 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)
+         if ( AddLinearMove( ptP4) == GDB_ID_NULL)
             return false ;
         // aggiorno posizione e verifico se step completato
          dCurrLen = dLen ;
@@ -2432,7 +2337,7 @@ 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)
+         if ( AddLinearMove( ptP5) == GDB_ID_NULL)
             return false ;
         // aggiorno posizione
          dCurrLen = dLen ;
@@ -2442,30 +2347,22 @@ 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 ( AddLinearMove( ptP1, bSplitArcs) == GDB_ID_NULL)
+   if ( AddLinearMove( ptP1) == GDB_ID_NULL)
       return false ;
 
   // 7 -> punto fuori (se uso aggregato da sotto)
    if ( m_bAggrBottom) {
-     // se con rotazione per minimizzare la sporgenza
-      if ( m_AggrBottom.nType == 3) {
-        // imposto rotazione su punto standard
-         Vector3d vtAux = m_vtAggrBottom ;
-         vtAux.Rotate( Z_AX, 0, 1) ;
-         SetAuxDir( vtAux) ;
-      }
-     // vado al punto
       SetFlag( 0) ;
       Point3d ptP0 = ptP1 + m_vtAggrBottom * ( m_dDistBottom + m_AggrBottom.dEncH + dSafeZ) ;
-      if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_OUT) == GDB_ID_NULL)
+      Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ;
+      if ( AddRapidMove( ptP0, MCH_CL_AGB_OUT) == GDB_ID_NULL)
          return false ;
       // se rinvio da sotto che richiede speciale rotazione
       if ( m_AggrBottom.nType == 1) {
-         Point3d ptP00 = ptP0 + Z_AX * ( m_AggrBottom.dEncV + m_TParams.m_dLen + dAppr + dTExtrLen) ;
          Vector3d vtAux = m_vtAggrBottom ;
          vtAux.Rotate( Z_AX, 0, 1) ;
          SetAuxDir( vtAux) ;
-         if ( AddRapidMove( ptP00, bSplitArcs, MCH_CL_AGB_UP) == GDB_ID_NULL)
+         if ( AddRapidMove( ptP00, MCH_CL_AGB_UP) == GDB_ID_NULL)
             return false ;
       }
    }

Drilling.h

@@ -84,14 +84,13 @@ class Drilling : public Machining
       bool GenerateHoleRegionPv( int nFirstId, int nCount, int nPvId) ;
       bool VerifyDiameter( double dHdiam, double dTdiam, double ddiamTol) ;
       bool VerifyHoleFromBottom( const Hole& hole, SelData Id) ;
-      bool DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double nMHOff, const Vector3d& vtA) ;
-      bool DoPeckDrilling( const Hole& hole, SelData Id, int nPathId, double dMHOff, const Vector3d& vtA) ;
-      bool MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& vDrills, double& dMHOff, bool bOrd = true) ;
+      bool DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double nMHOff, Vector3d vtA) ;
+      bool DoPeckDrilling( const Hole& hole, SelData Id, int nPathId) ;
+      bool MultiHeadDrilling( int nExitCnt, const SELVECTOR& vId, int nClId, TABMHDRILL& vDrills, double& dMHOff, bool bOrd = true) ;
       bool CalcMask( VECTORHOLE& vHoles, const VECTORTOOL& vTools, int nIndMT, const Vector3d& vtTool, const Vector3d& vtAux) ;
       bool CheckOtherHolesWithTools( VECTORHOLE& vHoles, const VECTORTOOL& vTools, int nIndTM, int nIndHTM, Hole holeICP,
                                      const Frame3d& frHTM, const Frame3d& frHMTOP, double dDiamToler, int& nDrills) ;
       bool MultiHeadVerifyHole( Hole& hole, const ToolData* Tool, double dDiamToler, SelData Id) ;
-      bool VerifyMultiParallelFixedDrills( void) ;
 
    private :
       double GetSpeed() const

EgtMachKernel.vcxproj

@@ -100,7 +100,7 @@
       <Optimization>Disabled</Optimization>
       <DebugInformationFormat>ProgramDatabase</DebugInformationFormat>
       <MultiProcessorCompilation>true</MultiProcessorCompilation>
-      <PreprocessorDefinitions>WIN32;_WINDOWS;I_AM_EMK;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
+      <PreprocessorDefinitions>WIN32;_WINDOWS;I_AM_EMK;_VRONI;_DEBUG;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <MinimalRebuild>false</MinimalRebuild>
       <OpenMPSupport>false</OpenMPSupport>
       <PrecompiledHeader>Use</PrecompiledHeader>
@@ -237,8 +237,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="EMkDllMain.cpp" />
     <ClCompile Include="Estimator.cpp" />
     <ClCompile Include="Exit.cpp" />
-    <ClCompile Include="FiveAxisMilling.cpp" />
-    <ClCompile Include="FiveAxisMillingData.cpp" />
     <ClCompile Include="Generator.cpp" />
     <ClCompile Include="GenMachining.cpp" />
     <ClCompile Include="GenMachiningData.cpp" />
@@ -283,8 +281,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="SawRoughing.cpp" />
     <ClCompile Include="SawRoughingData.cpp" />
     <ClCompile Include="SetupMgr.cpp" />
-    <ClCompile Include="SimulatorSP.cpp" />
-    <ClCompile Include="SimulatorMP.cpp" />
+    <ClCompile Include="Simulator.cpp" />
     <ClCompile Include="stdafx.cpp">
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">Create</PrecompiledHeader>
       <PrecompiledHeader Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Create</PrecompiledHeader>
@@ -294,8 +291,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClCompile Include="Head.cpp" />
     <ClCompile Include="SurfFinishing.cpp" />
     <ClCompile Include="SurfFinishingData.cpp" />
-    <ClCompile Include="SurfRoughing.cpp" />
-    <ClCompile Include="SurfRoughingData.cpp" />
     <ClCompile Include="Table.cpp" />
     <ClCompile Include="TcPos.cpp" />
     <ClCompile Include="ToolData.cpp" />
@@ -308,15 +303,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EGkArcSpecial.h" />
     <ClInclude Include="..\Include\EGkBBox1d.h" />
     <ClInclude Include="..\Include\EGkBBox3d.h" />
-    <ClInclude Include="..\Include\EGkBiArcs.h" />
-    <ClInclude Include="..\Include\EGkCalcPocketing.h" />
-    <ClInclude Include="..\Include\EGkCAvSilhouetteSurfTm.h" />
-    <ClInclude Include="..\Include\EGkCAvToolSurfTm.h" />
-    <ClInclude Include="..\Include\EGkCDeBoxClosedSurfTm.h" />
-    <ClInclude Include="..\Include\EGkCDeClosedSurfTmClosedSurfTm.h" />
-    <ClInclude Include="..\Include\EGkCDeConeFrustumClosedSurfTm.h" />
-    <ClInclude Include="..\Include\EGkCDeCylClosedSurfTm.h" />
-    <ClInclude Include="..\Include\EGkCDeSpheClosedSurfTm.h" />
+    <ClInclude Include="..\Include\EGkCDeBoxPolyhedron.h" />
     <ClInclude Include="..\Include\EGkChainCurves.h" />
     <ClInclude Include="..\Include\EGkColor.h" />
     <ClInclude Include="..\Include\EGkCurve.h" />
@@ -324,11 +311,8 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EGkCurveAux.h" />
     <ClInclude Include="..\Include\EGkCurveComposite.h" />
     <ClInclude Include="..\Include\EGkCurveLine.h" />
-    <ClInclude Include="..\Include\EGkCurveLocal.h" />
     <ClInclude Include="..\Include\EGkCurvePointDiffGeom.h" />
     <ClInclude Include="..\Include\EGkDistPointCurve.h" />
-    <ClInclude Include="..\Include\EGkDistPointLine.h" />
-    <ClInclude Include="..\Include\EGkDistPointSurfTm.h" />
     <ClInclude Include="..\Include\EGkExtText.h" />
     <ClInclude Include="..\Include\EGkFrame3d.h" />
     <ClInclude Include="..\Include\EGkGdbConst.h" />
@@ -341,13 +325,10 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EGkGeoObjType.h" />
     <ClInclude Include="..\Include\EGkGeoPoint3d.h" />
     <ClInclude Include="..\Include\EGkGeoVector3d.h" />
-    <ClInclude Include="..\Include\EGkHashGrids1d.h" />
     <ClInclude Include="..\Include\EGkHashGrids2d.h" />
     <ClInclude Include="..\Include\EGkIntersCurves.h" />
-    <ClInclude Include="..\Include\EGkIntersCurveSurfTm.h" />
     <ClInclude Include="..\Include\EGkIntersLineSurfTm.h" />
     <ClInclude Include="..\Include\EGkIntersLineTria.h" />
-    <ClInclude Include="..\Include\EGkIntersPlaneSurfTm.h" />
     <ClInclude Include="..\Include\EGkIntervals.h" />
     <ClInclude Include="..\Include\EGkLuaAux.h" />
     <ClInclude Include="..\Include\EGkMaterial.h" />
@@ -358,10 +339,7 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EGkPoint3d.h" />
     <ClInclude Include="..\Include\EGkPointGrid3d.h" />
     <ClInclude Include="..\Include\EGkPolyArc.h" />
-    <ClInclude Include="..\Include\EGkPolygon3d.h" />
-    <ClInclude Include="..\Include\EGkPolygonElevation.h" />
     <ClInclude Include="..\Include\EGkPolyLine.h" />
-    <ClInclude Include="..\Include\EGkQuaternion.h" />
     <ClInclude Include="..\Include\EGkSelection.h" />
     <ClInclude Include="..\Include\EGkSfrCreate.h" />
     <ClInclude Include="..\Include\EGkStmFromCurves.h" />
@@ -369,7 +347,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EGkStringUtils3d.h" />
     <ClInclude Include="..\Include\EGkSurf.h" />
     <ClInclude Include="..\Include\EGkSurfFlatRegion.h" />
-    <ClInclude Include="..\Include\EGkSurfLocal.h" />
     <ClInclude Include="..\Include\EGkSurfTriMesh.h" />
     <ClInclude Include="..\Include\EGkTriangle3d.h" />
     <ClInclude Include="..\Include\EGkUiUnits.h" />
@@ -379,7 +356,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EGkVolZmap.h" />
     <ClInclude Include="..\Include\EGnEgtUUID.h" />
     <ClInclude Include="..\Include\EGnFileUtils.h" />
-    <ClInclude Include="..\Include\EGnGetKeyData.h" />
     <ClInclude Include="..\Include\EGnGetModuleVer.h" />
     <ClInclude Include="..\Include\EGnLuaAux.h" />
     <ClInclude Include="..\Include\EGnLuaMgr.h" />
@@ -394,7 +370,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="..\Include\EgtLibVer.h" />
     <ClInclude Include="..\Include\EgtNumCollection.h" />
     <ClInclude Include="..\Include\EgtNumUtils.h" />
-    <ClInclude Include="..\Include\EgtPerfCounter.h" />
     <ClInclude Include="..\Include\EgtPointerOwner.h" />
     <ClInclude Include="..\Include\EgtStringBase.h" />
     <ClInclude Include="..\Include\EgtStringConverter.h" />
@@ -422,8 +397,6 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="DrillingData.h" />
     <ClInclude Include="Estimator.h" />
     <ClInclude Include="Exit.h" />
-    <ClInclude Include="FiveAxisMilling.h" />
-    <ClInclude Include="FiveAxisMillingData.h" />
     <ClInclude Include="Generator.h" />
     <ClInclude Include="GenMachining.h" />
     <ClInclude Include="GenMachiningData.h" />
@@ -460,14 +433,10 @@ copy $(TargetPath) \EgtProg\Dll64</Command>
     <ClInclude Include="SetTempPhase.h" />
     <ClInclude Include="SetupMgr.h" />
     <ClInclude Include="Simulator.h" />
-    <ClInclude Include="SimulatorSP.h" />
-    <ClInclude Include="SimulatorMP.h" />
     <ClInclude Include="stdafx.h" />
     <ClInclude Include="Head.h" />
     <ClInclude Include="SurfFinishing.h" />
     <ClInclude Include="SurfFinishingData.h" />
-    <ClInclude Include="SurfRoughing.h" />
-    <ClInclude Include="SurfRoughingData.h" />
     <ClInclude Include="Table.h" />
     <ClInclude Include="TcPos.h" />
     <ClInclude Include="ToolData.h" />

EgtMachKernel.vcxproj.filters

@@ -150,7 +150,7 @@
     <ClCompile Include="MachMgrDBTools.cpp">
       <Filter>Source Files\MachMgr</Filter>
     </ClCompile>
-    <ClCompile Include="SimulatorSP.cpp">
+    <ClCompile Include="Simulator.cpp">
       <Filter>Source Files\Output</Filter>
     </ClCompile>
     <ClCompile Include="MachMgrPhases.cpp">
@@ -234,21 +234,6 @@
     <ClCompile Include="TcPos.cpp">
       <Filter>Source Files\Machine</Filter>
     </ClCompile>
-    <ClCompile Include="FiveAxisMillingData.cpp">
-      <Filter>Source Files\Machinings</Filter>
-    </ClCompile>
-    <ClCompile Include="FiveAxisMilling.cpp">
-      <Filter>Source Files\Operations</Filter>
-    </ClCompile>
-    <ClCompile Include="SurfRoughingData.cpp">
-      <Filter>Source Files\Machinings</Filter>
-    </ClCompile>
-    <ClCompile Include="SurfRoughing.cpp">
-      <Filter>Source Files\Operations</Filter>
-    </ClCompile>
-    <ClCompile Include="SimulatorMP.cpp">
-      <Filter>Source Files\Output</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="DllMain.h">
@@ -344,7 +329,7 @@
     <ClInclude Include="..\Include\EMkDispositionConst.h">
       <Filter>Header Files\Include</Filter>
     </ClInclude>
-    <ClInclude Include="SimulatorSP.h">
+    <ClInclude Include="Simulator.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="Generator.h">
@@ -425,6 +410,9 @@
     <ClInclude Include="..\Include\EGkBBox3d.h">
       <Filter>Header Files\Include</Filter>
     </ClInclude>
+    <ClInclude Include="..\Include\EGkCDeBoxPolyhedron.h">
+      <Filter>Header Files\Include</Filter>
+    </ClInclude>
     <ClInclude Include="..\Include\EGkChainCurves.h">
       <Filter>Header Files\Include</Filter>
     </ClInclude>
@@ -680,87 +668,6 @@
     <ClInclude Include="..\Include\EGkBBox1d.h">
       <Filter>Header Files\Include</Filter>
     </ClInclude>
-    <ClInclude Include="FiveAxisMillingData.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="FiveAxisMilling.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="SurfRoughingData.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="SurfRoughing.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkBiArcs.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkCalcPocketing.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkCAvSilhouetteSurfTm.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkCAvToolSurfTm.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkCDeBoxClosedSurfTm.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkCDeClosedSurfTmClosedSurfTm.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkCDeConeFrustumClosedSurfTm.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkCDeCylClosedSurfTm.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkCDeSpheClosedSurfTm.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkCurveLocal.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkDistPointLine.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkDistPointSurfTm.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkHashGrids1d.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkIntersCurveSurfTm.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkIntersPlaneSurfTm.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkPolygon3d.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkPolygonElevation.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkQuaternion.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGkSurfLocal.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EGnGetKeyData.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="..\Include\EgtPerfCounter.h">
-      <Filter>Header Files\Include</Filter>
-    </ClInclude>
-    <ClInclude Include="SimulatorMP.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="Simulator.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="EgtMachKernel.rc">

FiveAxisMilling.cpp

@@ -1,984 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : FiveAxisMilling.cpp        Data : 22.05.24        Versione : 2.6e5
-// Contenuto : Implementazione gestione lavorazione 5 assi.
-//
-//
-//
-// Modifiche : 22.05.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "MachMgr.h"
-#include "DllMain.h"
-#include "FiveAxisMilling.h"
-#include "OperationConst.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 --------------------------------------
-// 3301 = "Error in FiveAxisMilling : UpdateToolData failed"
-// 3302 = "Error in FiveAxisMilling : missing Script (xxx)"
-// 3303 = "Error in FiveAxisMilling : Error in xxx (nnn)"
-// 3304 = "Error in FiveAxisMilling : axes values not calculable"
-// 3305 = "Error in FiveAxisMilling : outstroke xx"
-// 3306 = "Error in FiveAxisMilling : link movements not calculable"
-// 3307 = "Error in FiveAxisMilling : link outstroke xx"
-// 3308 = "Error in FiveAxisMilling : post apply not calculable"
-// 3309 = "Error in FiveAxisMilling : Tool loading failed"
-// 3310 = "Error in FiveAxisMilling : aggregate from bottom not allowed"
-// 3351 = "Warning in FiveAxisMilling : Skipped entity (xx)"
-// 3352 = "Warning in FiveAxisMilling : No machinable path"
-// 3353 = "Warning in FiveAxisMilling : Tool name changed (xx)"
-// 3354 = "Warning in FiveAxisMilling : 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_OFFSR = ".OFFSR" ;        // IN (num) offset radiale 
-static const string EVAR_OFFSL = ".OFFSL" ;        // IN (num) offset longitudinale 
-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_TMAXMAT = ".TMAXMAT" ;    // IN (num) massimo materiale
-static const string EVAR_TDIAM = ".TDIAM" ;        // IN (num) diametro utensile
-static const string EVAR_TTOTDIAM = ".TTOTDIAM" ;  // IN (num) diametro totale utensile
-static const string EVAR_TLEN = ".TLEN" ;          // IN (num) lunghezza utensile
-static const string EVAR_TTOTLEN = ".TTOTLEN" ;    // IN (num) lunghezza totale utensile
-static const string EVAR_TTHICK = ".THICK" ;       // IN (num) spessore per lame o altezza taglienti
-static const string EVAR_TCORNRAD = ".TCORNRAD" ;  // IN (num) raggio corner
-static const string EVAR_TSIDEANG = ".TSIDEANG" ;  // IN (num) angolo del fianco rispetto all'asse
-static const string EVAR_FEED = ".FEED" ;          // IN (num) feed dell'utensile
-static const string EVAR_STARTFEED = ".STARTFEED" ;// IN (num) feed di inizio dell'utensile
-static const string EVAR_ENDFEED = ".ENDFEED" ;    // IN (num) feed di fine dell'utensile
-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_FIVEAXISMILLING), FiveAxisMilling) ;
-
-//----------------------------------------------------------------------------
-const string&
-FiveAxisMilling::GetClassName( void) const
-{
-   return USEROBJ_GETNAME( FiveAxisMilling) ;
-}
-
-//----------------------------------------------------------------------------
-FiveAxisMilling*
-FiveAxisMilling::Clone( void) const
-{
-  // alloco oggetto
-   FiveAxisMilling* pGenM = new(nothrow) FiveAxisMilling ;
-  // 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
-FiveAxisMilling::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
-FiveAxisMilling::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
-FiveAxisMilling::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 ;
-}
-
-//----------------------------------------------------------------------------
-//----------------------------------------------------------------------------
-FiveAxisMilling::FiveAxisMilling( 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
-FiveAxisMilling::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 FiveAxisMillingData* pDdata = GetFiveAxisMillingData( 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
-FiveAxisMilling::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
-FiveAxisMilling::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
-FiveAxisMilling::SetParam( int nType, double dVal)
-{
-   switch ( nType) {
-   case MPA_SPEED :
-      if ( ! m_TParams.VerifySpeed( dVal))
-         return false ;
-      if ( abs( m_TParams.m_dSpeed - dVal) < EPS_MACH_ANG_PAR)
-         dVal = 0 ;
-      if ( abs( dVal - m_Params.m_dSpeed) > EPS_MACH_ANG_PAR)
-         m_nStatus |= MCH_ST_PARAM_MODIF ;
-      m_Params.m_dSpeed = dVal ;
-      return true ;
-   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_OFFSR :
-      if ( abs( m_TParams.m_dOffsR - dVal) < EPS_MACH_LEN_PAR)
-         dVal = UNKNOWN_PAR ;
-      if ( abs( dVal - m_Params.m_dOffsR) > EPS_MACH_LEN_PAR)
-         m_nStatus |= MCH_ST_PARAM_MODIF ;
-      m_Params.m_dOffsR = dVal ;
-      return true ;
-   case MPA_OFFSL :
-      if ( abs( m_TParams.m_dOffsL - dVal) < EPS_MACH_LEN_PAR)
-         dVal = UNKNOWN_PAR ;
-      if ( abs( dVal - m_Params.m_dOffsL) > EPS_MACH_LEN_PAR)
-         m_nStatus |= MCH_ST_PARAM_MODIF ;
-      m_Params.m_dOffsL = 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
-FiveAxisMilling::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
-FiveAxisMilling::SetGeometry( const SELVECTOR& vIds)
-{
-  // verifico validità gestore DB geometrico
-   if ( m_pGeomDB == nullptr)
-      return false ;
-  // reset della geometria corrente
-   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 FiveAxisMilling : Skipped entity " + ToString( Id) ;
-         m_pMchMgr->SetWarning( 3351, sInfo) ;
-         continue ;
-      }
-     // posso aggiungere alla lista
-      m_vId.emplace_back( Id) ;
-   }
-  // aggiorno lo stato
-   m_nStatus |= MCH_ST_GEO_MODIF ;
-  // restituisco presenza geometria da lavorare
-   return ( ! m_vId.empty()  ||  vIds.empty()) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMilling::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( 3301, "Error in FiveAxisMilling : 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( 3309, "Error in FiveAxisMilling : 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 = FIVEAXISMILLING_SCRIPT_KEY + ToString( m_Params.m_nSubType) ;
-   string sName = GetPrivateProfileStringUtf8( FIVEAXISMILLING_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 FiveAxisMilling : missing Script " + sPreview ;
-      m_pMchMgr->SetLastError( 3302, 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_OFFSR, GetOffsR()) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSL, GetOffsL()) ;
-   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_TMAXMAT, m_TParams.m_dMaxMat) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TDIAM, m_TParams.m_dDiam) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTDIAM, m_TParams.m_dTDiam) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TLEN, m_TParams.m_dLen) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTLEN, m_TParams.m_dTLen) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTHICK, m_TParams.m_dThick) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TCORNRAD, m_TParams.m_dCornRad) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TSIDEANG, m_TParams.m_dSideAng) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_FEED, GetFeed()) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTFEED, GetStartFeed()) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ENDFEED, GetEndFeed()) ;
-   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 FiveAxisMilling : Error in " + sPreview + " (" + ToString( nErr) + ")" ;
-      m_pMchMgr->SetLastError( 3303, sErr) ;
-      return false ;
-   }
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMilling::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
-   bool bToolChanged = true ;
-   if ( ! UpdateToolData( &bToolChanged)) {
-      m_pMchMgr->SetLastError( 3301, "Error in FiveAxisMilling : UpdateToolData failed") ;
-      return false ;
-   }
-
-  // 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 ;
-   }
-
-  // verifico se necessario continuare nell'aggiornamento
-   if ( ! bRecalc  &&  ! bToolChanged  &&  
-        ( m_nStatus == MCH_ST_OK  ||  ( ! bPostApply  &&  m_nStatus == MCH_ST_NO_POSTAPPL))) {
-     // confermo i percorsi di lavorazione
-      m_nMills = nCurrMills ;
-      LOG_DBG_INFO( GetEMkLogger(), "FiveAxisMilling apply skipped : status already ok") ;
-     // eseguo aggiornamento assi macchina e collegamento con operazione precedente
-      if ( ! Update( bPostApply))
-         return false ;
-      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( 3309, "Error in FiveAxisMilling : 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 = FIVEAXISMILLING_SCRIPT_KEY + ToString( m_Params.m_nSubType) ;
-   string sName = GetPrivateProfileStringUtf8( FIVEAXISMILLING_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 FiveAxisMilling : missing Script " + sApply ;
-      m_pMchMgr->SetLastError( 3302, 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_OFFSR, GetOffsR()) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSL, GetOffsL()) ;
-   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_TMAXMAT, m_TParams.m_dMaxMat) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TDIAM, m_TParams.m_dDiam) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTDIAM, m_TParams.m_dTDiam) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TLEN, m_TParams.m_dLen) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTOTLEN, m_TParams.m_dTLen) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TTHICK, m_TParams.m_dThick) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TCORNRAD, m_TParams.m_dCornRad) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_TSIDEANG, m_TParams.m_dSideAng) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_FEED, GetFeed()) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTFEED, GetStartFeed()) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_ENDFEED, GetEndFeed()) ;
-   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 FiveAxisMilling : Error in " + sApply + " (" + ToString( nErr) + ")" ;
-      m_pMchMgr->SetLastError( 3303, 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(), "FiveAxisMilling apply done") ;
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMilling::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( 3352, "Warning in FiveAxisMilling : 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( 3304, "Error in FiveAxisMilling : axes values not calculable") ;
-      else
-         m_pMchMgr->SetLastError( 3305, "Error in FiveAxisMilling : outstroke ") ;
-      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)) {
-      string sInfo = m_pMchMgr->GetOutstrokeInfo() ;
-      if ( sInfo.empty())
-         m_pMchMgr->SetLastError( 3306, "Error in FiveAxisMilling : link movements not calculable") ;
-      else
-         m_pMchMgr->SetLastError( 3307, "Error in FiveAxisMilling : link outstroke ") ;
-      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) ;
-      else
-         m_pMchMgr->SetLastError( 3308, "Error in FiveAxisMilling : post apply not calculable") ;
-      return false ;
-   }
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMilling::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
-FiveAxisMilling::GetParam( int nType, int& nVal) const
-{
-   switch ( nType) {
-   case MPA_TYPE :
-      nVal = MT_FIVEAXISMILLING ;
-      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
-FiveAxisMilling::GetParam( int nType, double& dVal) const
-{
-   switch ( nType) {
-   case MPA_SPEED :
-      dVal = GetSpeed() ;
-      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_OFFSR :
-      dVal = GetOffsR() ;
-      return true ;
-   case MPA_OFFSL :
-      dVal = GetOffsL() ;
-      return true ;
-   case MPA_STARTPOS :
-      dVal = m_Params.m_dStartPos ;
-      return true ;
-   }
-   dVal = 0 ;
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMilling::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&
-FiveAxisMilling::GetToolData( void) const
-{
-   return m_TParams ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMilling::UpdateToolData( bool* pbChanged)
-{
-  // recupero il gestore DB utensili della macchina corrente
-   ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
-   if ( pTMgr == nullptr)
-      return false ;
-  // recupero l'utensile nel DB utensili
-   const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
-  // 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 FiveAxisMilling : tool name changed (" +
-                     m_Params.m_sToolName + "->" + m_TParams.m_sName + ")" ;
-      m_pMchMgr->SetWarning( 3353, sInfo) ;
-      m_Params.m_sToolName = m_TParams.m_sName ;
-   }
-   if ( bChanged) {
-      string sInfo = "Warning in FiveAxisMilling : tool data changed (" +
-                     m_Params.m_sToolName + ")" ;
-      m_pMchMgr->SetWarning( 3354, sInfo) ;
-   }
-  // se definito parametro di ritorno, lo assegno
-   if ( pbChanged != nullptr)
-      *pbChanged = bChanged ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMilling::GetGeometry( SELVECTOR& vIds) const
-{
-  // restituisco l'elenco delle entità
-   vIds = m_vId ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMilling::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
-FiveAxisMilling::GetApproxLinTol( void) const
-{
-   double dLinTol ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "LinTol", dLinTol))
-      return dLinTol ;
-   else
-      return Operation::GetApproxLinTol() ;
-}

FiveAxisMilling.h

@@ -1,94 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : FiveAxisMilling.h         Data : 22.05.24         Versione : 2.6e5
-// Contenuto : Dichiarazione della classe FiveAxisMilling.
-//
-//
-//
-// Modifiche : 22.05.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "Machining.h"
-#include "FiveAxisMillingData.h"
-#include "ToolData.h"
-
-class ICurve ;
-class ICurveComposite ;
-
-//----------------------------------------------------------------------------
-class FiveAxisMilling : public Machining
-{
-   public :                           // IUserObj
-      FiveAxisMilling* 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_FIVEAXISMILLING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nMills == 0) ; }
-      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( bool* pbChanged = nullptr) override ;
-      const ToolData& GetToolData( void) const override ;
-      bool GetGeometry( SELVECTOR& vIds) const override ;
-
-   public :
-      FiveAxisMilling( void) ;
-
-   private :
-      bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
-      double GetApproxLinTol( void) const override ;
-
-   private :
-      double GetSpeed() const
-         { return ( IsNullAngValue( m_Params.m_dSpeed) ? m_TParams.m_dSpeed : m_Params.m_dSpeed) ; }
-      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) ; }
-      double GetOffsL() const
-         { return ( IsUnknownValue( m_Params.m_dOffsL) ? m_TParams.m_dOffsL : m_Params.m_dOffsL) ; }
-      double GetOffsR() const
-         { return ( IsUnknownValue( m_Params.m_dOffsR) ? m_TParams.m_dOffsR : m_Params.m_dOffsR) ; }
-
-   private :
-      SELVECTOR            m_vId ;             // identificativi entità geometriche da lavorare
-      FiveAxisMillingData  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
-} ;

FiveAxisMillingData.cpp

@@ -1,557 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : FiveAxisMillingData.cpp     Data : 22.05.24        Versione : 2.6e5
-// Contenuto : Implementazione struttura dati fresatura a 5 assi.
-//
-//
-//
-// Modifiche : 22.05.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "FiveAxisMillingData.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 nFiveAxisMillingKey {
-   KEY_AB = 0,
-   KEY_AI,
-   KEY_DH,
-   KEY_F,
-   KEY_FE,
-   KEY_FS,
-   KEY_FT,
-   KEY_INV,
-   KEY_NAME,
-   KEY_NNS,
-   KEY_NNU,
-   KEY_OL,
-   KEY_OR,
-   KEY_PS,
-   KEY_S,
-   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> sFiveAxisMillingKey = {
-   "AB",
-   "AI",
-   "DH",
-   "F",
-   "FE",
-   "FS",
-   "FT",
-   "INV",
-   "NAME",
-   "NNS",
-   "NNU",
-   "OL",
-   "OR",
-   "PS",
-   "S",
-   "SCC",
-   "SUB",
-   "TI",
-   "TN",
-   "TU",
-   "UUID"} ;
-
-//----------------------------------------------------------------------------
-MCHDATA_REGISTER( MT_FIVEAXISMILLING, "FIVEAXISMILLING", FiveAxisMillingData) ;
-
-//----------------------------------------------------------------------------
-FiveAxisMillingData*
-FiveAxisMillingData::Clone( void) const
-{
-  // alloco oggetto
-   FiveAxisMillingData* pDdata = new(nothrow) FiveAxisMillingData ;
-  // copio i dati
-   if ( pDdata != nullptr) {
-      if ( ! pDdata->CopyFrom( this)) {
-         delete pDdata ;
-         return nullptr ;
-      }
-   }
-   return pDdata ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::CopyFrom( const MachiningData* pMdata)
-{
-  // è inutile copiare se sorgente coincide con destinazione
-   if ( pMdata == this)
-      return true ;
-  // la sorgente deve essere dello stesso tipo
-   const FiveAxisMillingData* pFdata = GetFiveAxisMillingData( pMdata) ;
-   if ( pFdata == nullptr)
-      return false ;
-  // eseguo copia
-   m_Uuid = pFdata->m_Uuid ;
-   m_sName = pFdata->m_sName ;
-   m_ToolUuid = pFdata->m_ToolUuid ;
-   m_sToolName = pFdata->m_sToolName ;
-   m_sBlockedAxis = pFdata->m_sBlockedAxis ;
-   m_sInitAngs = pFdata->m_sInitAngs ;
-   m_nSolCh = pFdata->m_nSolCh ;
-   m_dSpeed = pFdata->m_dSpeed ;
-   m_dFeed = pFdata->m_dFeed ;
-   m_dEndFeed = pFdata->m_dEndFeed ;
-   m_dStartFeed = pFdata->m_dStartFeed ;
-   m_dTipFeed = pFdata->m_dTipFeed ;
-   m_dOffsL = pFdata->m_dOffsL ;
-   m_dOffsR = pFdata->m_dOffsR ;
-   m_bToolInvert = pFdata->m_bToolInvert ;
-   m_bInvert = pFdata->m_bInvert ;
-   m_sDepth = pFdata->m_sDepth ;
-   m_dStartPos = pFdata->m_dStartPos ;
-   m_nSubType = pFdata->m_nSubType ;
-   m_sSysNotes = pFdata->m_sSysNotes ;
-   m_sUserNotes = pFdata->m_sUserNotes ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::SameAs(const MachiningData* pMdata) const
-{
-  // se coincide con altro -> uguali
-   if ( pMdata == this)
-      return true ;
-  // se sono di tipo diverso -> diversi
-   const FiveAxisMillingData* pFdata = GetFiveAxisMillingData( pMdata) ;
-   if ( pFdata == nullptr)
-      return false ;
-  // confronto termine a termine
-   return ( m_Uuid == pFdata->m_Uuid  &&
-            m_sName == pFdata->m_sName  &&
-            m_ToolUuid == pFdata->m_ToolUuid  &&
-            m_sToolName == pFdata->m_sToolName  &&
-            m_sBlockedAxis == pFdata->m_sBlockedAxis  &&
-            m_sInitAngs == pFdata->m_sInitAngs  &&
-            m_nSolCh == pFdata->m_nSolCh  &&
-            abs( m_dSpeed - pFdata->m_dSpeed) < EPS_MACH_ANG_PAR  &&
-            abs( m_dFeed - pFdata->m_dFeed) < EPS_MACH_LEN_PAR  &&
-            abs( m_dEndFeed - pFdata->m_dEndFeed) < EPS_MACH_LEN_PAR  &&
-            abs( m_dStartFeed - pFdata->m_dStartFeed) < EPS_MACH_LEN_PAR  &&
-            abs( m_dTipFeed - pFdata->m_dTipFeed) < EPS_MACH_LEN_PAR  &&
-            abs( m_dOffsL - pFdata->m_dOffsL) < EPS_MACH_LEN_PAR  &&
-            abs( m_dOffsR - pFdata->m_dOffsR) < EPS_MACH_LEN_PAR  &&
-            m_bToolInvert == pFdata->m_bToolInvert  &&
-            m_bInvert == pFdata->m_bInvert  &&
-            m_sDepth == pFdata->m_sDepth  &&
-            abs( m_dStartPos - pFdata->m_dStartPos) < EPS_MACH_LEN_PAR  &&
-            m_nSubType == pFdata->m_nSubType  &&
-            m_sSysNotes == pFdata->m_sSysNotes  &&
-            m_sUserNotes == pFdata->m_sUserNotes) ;
-}
-
-//----------------------------------------------------------------------------
-int
-FiveAxisMillingData::GetSize( void) const
-{
-  // in debug verifico validità ultimo campo
-   assert( sFiveAxisMillingKey[KEY_UUID] == "UUID") ;
-   return KEY_ZZZ ;
-}
-//----------------------------------------------------------------------------
-string
-FiveAxisMillingData::GetTitle( void) const
-{
-   return MCHDATA_GETNAME( FiveAxisMillingData) ;
-}
-
-//----------------------------------------------------------------------------
-int
-FindFiveAxisMillingKey( const string& sKey)
-{
-   auto TheRange = equal_range( sFiveAxisMillingKey.cbegin(), sFiveAxisMillingKey.cend(), sKey) ;
-   if ( TheRange.first == TheRange.second)
-      return - 1 ;
-   return int( TheRange.first - sFiveAxisMillingKey.cbegin()) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::FromString( const string& sString, int& nKey)
-{
-  // separo chiave da valore
-   string sKey, sVal ;
-   SplitFirst( sString, "=", sKey, sVal) ;
-  // riconosco la chiave
-   nKey = FindFiveAxisMillingKey( 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_OL :
-      bOk = ::FromString( sVal, m_dOffsL) ;
-      break ;
-   case KEY_OR :
-      bOk = ::FromString( sVal, m_dOffsR) ;
-      break ;
-   case KEY_PS :
-      bOk = ::FromString( sVal, m_dStartPos) ;
-      break ;
-   case KEY_S :
-      bOk = ::FromString( sVal, m_dSpeed) ;
-      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
-FiveAxisMillingData::ToString( int nKey) const
-{
-   switch ( nKey) {
-   case KEY_AB : return ( sFiveAxisMillingKey[KEY_AB] + "=" +  m_sBlockedAxis) ;
-   case KEY_AI : return ( sFiveAxisMillingKey[KEY_AI] + "=" +  m_sInitAngs) ;
-   case KEY_DH : return ( sFiveAxisMillingKey[KEY_DH] + "=" + m_sDepth) ;
-   case KEY_F : return ( sFiveAxisMillingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ;
-   case KEY_FE : return ( sFiveAxisMillingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ;
-   case KEY_FS : return ( sFiveAxisMillingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ;
-   case KEY_FT : return ( sFiveAxisMillingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ;
-   case KEY_INV : return ( sFiveAxisMillingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
-   case KEY_NAME : return ( sFiveAxisMillingKey[KEY_NAME] + "=" + m_sName) ;
-   case KEY_NNS : return ( sFiveAxisMillingKey[KEY_NNS] + "=" + m_sSysNotes) ;
-   case KEY_NNU : return ( sFiveAxisMillingKey[KEY_NNU] + "=" + m_sUserNotes) ;
-   case KEY_OL : return ( sFiveAxisMillingKey[KEY_OL] + "=" + ::ToString( m_dOffsL)) ;
-   case KEY_OR : return ( sFiveAxisMillingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ;
-   case KEY_PS : return ( sFiveAxisMillingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ;
-   case KEY_S : return ( sFiveAxisMillingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ;
-   case KEY_SCC : return ( sFiveAxisMillingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ;
-   case KEY_SUBTYPE : return ( sFiveAxisMillingKey[KEY_SUBTYPE] + "=" + ::ToString( m_nSubType)) ;
-   case KEY_TI : return ( sFiveAxisMillingKey[KEY_TI] + "=" + ::ToString( m_bToolInvert)) ;
-   case KEY_TNAME : return ( sFiveAxisMillingKey[KEY_TNAME] + "=" + m_sToolName) ;
-   case KEY_TUUID : return ( sFiveAxisMillingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
-   case KEY_UUID : return ( sFiveAxisMillingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
-   default : return "" ;
-   }
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::IsOptional( int nKey) const
-{
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::VerifySolCh( int nVal) const
-{
-   return IsValidOperationScc( nVal) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::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_MILL) == 0)
-      return false ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const
-{
-   if ( pToolsMgr == nullptr)
-      return false ;
-   pTdata = pToolsMgr->GetTool( m_ToolUuid) ;
-   return ( pTdata != nullptr) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::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
-FiveAxisMillingData::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
-FiveAxisMillingData::SetParam( int nType, double dVal)
-{
-   switch ( nType) {
-   case MPA_SPEED :
-      m_dSpeed = dVal ;
-      return true ;
-   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_OFFSL :
-      m_dOffsL = dVal ;
-      return true ;
-   case MPA_OFFSR :
-      m_dOffsR = dVal ;
-      return true ;
-   case MPA_DEPTH :
-      m_sDepth = ::ToString( dVal) ;
-      return true ;
-   case MPA_STARTPOS :
-      m_dStartPos = dVal ;
-      return true ;
-   }
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::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
-FiveAxisMillingData::ResetTool( void)
-{
-   m_sToolName.clear() ;
-   m_ToolUuid.Clear() ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::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
-FiveAxisMillingData::GetParam( int nType, int& nVal) const
-{
-   switch ( nType) {
-   case MPA_TYPE :
-      nVal = MT_FIVEAXISMILLING ;
-      return true ;
-   case MPA_SCC :
-      nVal = m_nSolCh ;
-      return true ;
-   case MPA_SUBTYPE :
-      nVal = m_nSubType ;
-      return true ;
-   }
-   nVal = 0 ;
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::GetParam( int nType, double& dVal) const
-{
-   switch ( nType) {
-   case MPA_SPEED :
-      dVal = m_dSpeed ;
-      return true ;
-   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_OFFSL :
-      dVal = m_dOffsL ;
-      return true ;
-   case MPA_OFFSR :
-      dVal = m_dOffsR ;
-      return true ;
-   case MPA_STARTPOS :
-      dVal = m_dStartPos ;
-      return true ;
-   }
-   dVal = 0 ;
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-FiveAxisMillingData::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 ;
-}

FiveAxisMillingData.h

@@ -1,76 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : FiveAxisMillingData.h      Data : 22.05.24        Versione : 2.6e5
-// Contenuto : Dichiarazione della struct FiveAxisMillingData e costanti associate.
-//
-//
-//
-// Modifiche : 22.05.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "MachiningData.h"
-
-//----------------------------------------------------------------------------
-struct FiveAxisMillingData : 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_dSpeed ;          // velocità di rotazione (+ se CCW, - se CW)  ( se 0 da utensile)
-   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)
-   double      m_dOffsR ;          // offset radiale ( se UNKNOWN_PAR da utensile)
-   double      m_dOffsL ;          // offset longitudinale ( se UNKNOWN_PAR 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 [GenMachining] di Ini di macchina
-   std::string m_sSysNotes ;       // note interne
-   std::string m_sUserNotes ;      // note dell'utente
-
-   FiveAxisMillingData( void)
-      : m_ToolUuid(), m_nSolCh( 0), m_dSpeed( 0), m_dFeed( 0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0),
-        m_dOffsR( 0), m_dOffsL( 0), m_bToolInvert( false), m_bInvert( false), m_dStartPos( 0), m_nSubType( 0) {}
-   FiveAxisMillingData* Clone( void) const override ;
-   bool CopyFrom( const MachiningData* pMdata) override ;
-   bool SameAs(const MachiningData* pMdata) const override  ;
-   int  GetType( void) const override
-           { return MT_FIVEAXISMILLING ; }
-   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 FiveAxisMillingData* GetFiveAxisMillingData( const MachiningData* pMdata)
-               { if ( pMdata == nullptr  ||  pMdata->GetType() != MT_FIVEAXISMILLING)
-                    return nullptr ;
-                 return ( static_cast<const FiveAxisMillingData*>( pMdata)) ; }
-inline FiveAxisMillingData* GetFiveAxisMillingData( MachiningData* pMdata)
-               { if ( pMdata == nullptr  ||  pMdata->GetType() != MT_FIVEAXISMILLING)
-                    return nullptr ;
-                 return ( static_cast<FiveAxisMillingData*>( pMdata)) ; }

GenMachining.cpp

@@ -39,7 +39,6 @@ using namespace std ;
 // 2806 = "Error in GenMachining : link movements not calculable"
 // 2807 = "Error in GenMachining : link outstroke xx"
 // 2808 = "Error in GenMachining : post apply not calculable"
-// 2809 = "Error in GenMachining : Tool loading failed"
 // 2851 = "Warning in GenMachining : Skipped entity (xx)"
 // 2852 = "Warning in GenMachining : No machinable path"
 // 2853 = "Warning in GenMachining : Tool name changed (xx)"
@@ -55,8 +54,6 @@ static const string EVAR_INVERT = ".INVERT" ;      // IN (bool) flag di inversio
 static const string EVAR_STARTPOS = ".STARTPOS" ;  // IN (num) quota di inizio lavorazione (sempre >= 0) 
 static const string EVAR_OFFSR = ".OFFSR" ;        // IN (num) offset radiale 
 static const string EVAR_OFFSL = ".OFFSL" ;        // IN (num) offset longitudinale 
-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
@@ -73,9 +70,10 @@ static const string EVAR_FEED = ".FEED" ;          // IN (num) feed dell'utensil
 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 EVAR_SYSNOTES = ".SYSNOTES" ;  // IN (string) note interne
+static const string EVAR_USERNOTES = ".USERNOTES" ;// IN (string) note dell'utente
+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_" ;
 
@@ -449,12 +447,6 @@ GenMachining::Preview( bool bRecalc)
       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( 2809, "Error in GenMachining : 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
@@ -499,8 +491,6 @@ GenMachining::Preview( bool bRecalc)
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTPOS, m_Params.m_dStartPos) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSR, GetOffsR()) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSL, GetOffsL()) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_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) ;
@@ -517,7 +507,8 @@ GenMachining::Preview( bool bRecalc)
    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()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_SYSNOTES, m_Params.m_sSysNotes) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_USERNOTES, m_Params.m_sUserNotes) ;  
   // eseguo
    bOk = bOk && pMch->LuaCallFunction( sPreview, false) ;
   // recupero valori parametri obbligatori
@@ -570,12 +561,6 @@ GenMachining::Apply( bool bRecalc, bool bPostApply)
    }
    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( 2809, "Error in GenMachining : 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
@@ -620,8 +605,6 @@ GenMachining::Apply( bool bRecalc, bool bPostApply)
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_STARTPOS, m_Params.m_dStartPos) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSR, GetOffsR()) ;
    bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_OFFSL, GetOffsL()) ;
-   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_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) ;
@@ -638,7 +621,8 @@ GenMachining::Apply( bool bRecalc, bool bPostApply)
    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()) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_SYSNOTES, m_Params.m_sSysNotes) ;
+   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + EVAR_USERNOTES, m_Params.m_sUserNotes) ;  
   // eseguo
    bOk = bOk && pMch->LuaCallFunction( sApply, false) ;
   // recupero valori parametri obbligatori
@@ -964,14 +948,3 @@ GenMachining::VerifyGeometry( SelData Id, int& nSubs, int& nType)
    else
       return false ;
 }
-
-//----------------------------------------------------------------------------
-double
-GenMachining::GetApproxLinTol( void) const
-{
-   double dLinTol ;
-   if ( GetValInNotes( m_Params.m_sUserNotes, "LinTol", dLinTol))
-      return dLinTol ;
-   else
-      return Operation::GetApproxLinTol() ;
-}

GenMachining.h

@@ -67,7 +67,6 @@ class GenMachining : public Machining
 
    private :
       bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
-      double GetApproxLinTol( void) const override ;
 
    private :
       double GetSpeed() const

Generator.cpp

@@ -53,8 +53,8 @@ Generator::Run( const string& sCncFile, const string& sInfo)
    int nRet = GetEGnKeyOptions( KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
                                 nOpt1, nOpt2, nOptExpDays) ;
    if ( ! GetEMkNetHwKey())
-      nRet = GetKeyOptions( GetEMkKey(), KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
-                            nOpt1, nOpt2, nOptExpDays) ;
+      int nRet = GetKeyOptions( GetEMkKey(), KEY_BASELIB_PROD, KEY_BASELIB_VER, KEY_BASELIB_LEV,
+                                nOpt1, nOpt2, nOptExpDays) ;
 
   // Verifica della abilitazione
    bool bMinTime = false ;

GeoConst.h

@@ -20,9 +20,8 @@
 const double LIN_TOL_STD = 0.1 ;
 const double LIN_TOL_MID = 0.05 ;
 const double LIN_TOL_RAW = 0.5 ;
-const double ANG_TOL_STD_DEG = 15 ;
-const double ANG_TOL_MID_DEG = 45 ;
 const double ANG_TOL_MAX_DEG = 90 ;
+const double ANG_TOL_STD_DEG = 15 ;
 const double LIN_FEA_STD = 20 ;
 
 //----------- Costante per offset salva spigoli di lama su cornici curve ----

Head.cpp

@@ -52,7 +52,6 @@ Head::Clone( void) const
             pHead->m_bMaxDeltaR2On1 = m_bMaxDeltaR2On1 ;
             pHead->m_Rot2Stroke = m_Rot2Stroke ;
             pHead->m_nSolCh = m_nSolCh ;
-            pHead->m_vsOtherColl = m_vsOtherColl ;
       }
       catch( ...) {
          delete pHead ;
@@ -74,7 +73,6 @@ Head::Dump( string& sOut, bool bMM, const char* szNewLine) const
    sOut += "ExitCount=" + ToString( m_nExitCount) + szNewLine ;
    sOut += "HSet=" + ToString( m_vsHSet) + szNewLine ;
    sOut += "ADir=" + ToString( m_vtADir) + szNewLine ;
-   sOut += "OtherColl=" + ToString( m_vsOtherColl) + szNewLine ;
    return true ;
 }
 
@@ -105,7 +103,7 @@ Head::GetGeomDB( void) const
 //----------------------------------------------------------------------------
 Head::Head( void)
    : m_nOwnerId( GDB_ID_NULL), m_pGeomDB( nullptr), m_nType( MCH_HT_NONE), m_nExitCount( 0), 
-     m_nSelectType( MCH_SLT_FIXEDEXITS), m_dRot1W( 1), m_bMaxDeltaR2On1( true), m_nSolCh( MCH_SCC_NONE)
+     m_dRot1W( 1), m_bMaxDeltaR2On1( true), m_nSolCh( MCH_SCC_NONE)
 {
    m_Rot2Stroke.Min = - INFINITO ;
    m_Rot2Stroke.Max = INFINITO ;
@@ -113,7 +111,7 @@ Head::Head( void)
 
 //----------------------------------------------------------------------------
 bool
-Head::Set( const string& sName, int nType, int nExitCount, const string& sHSet, int nSelectType, const Vector3d& vtADir,
+Head::Set( const string& sName, int nType, int nExitCount, const string& sHSet, const Vector3d& vtADir,
            double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl)
 {
    m_sName = sName ;
@@ -124,10 +122,6 @@ Head::Set( const string& sName, int nType, int nExitCount, const string& sHSet,
       m_nExitCount = 1 ;
    m_vsHSet.clear() ;
    m_vsHSet.push_back( sHSet) ;
-   if ( nSelectType == MCH_SLT_FIXEDEXITS  ||  nSelectType == MCH_SLT_ONEEXIT  ||  nSelectType == MCH_SLT_MULTIEXITS)
-      m_nSelectType = nSelectType ;
-   else
-      m_nSelectType = MCH_SLT_FIXEDEXITS ;
    m_vtADir = vtADir ;
    m_vtADir.Normalize() ;
    m_dRot1W = dRot1W ;

Head.h

@@ -30,7 +30,7 @@ class Head : public IUserObj
 
    public :
       Head( void) ;
-      bool Set( const std::string& sName, int nType, int nExitCount, const std::string& sHSet, int nSelectType,
+      bool Set( const std::string& sName, int nType, int nExitCount, const std::string& sHSet,
                 const Vector3d& vtADir, double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh,
                 const STRVECTOR& vsOthColl) ;
       bool AddHeadToHSet( const std::string& sHead) ;
@@ -43,8 +43,6 @@ class Head : public IUserObj
                { return m_nExitCount ; }
       const STRVECTOR& GetHSet(void) const
                { return m_vsHSet ; }
-      int GetSelectType( void) const
-               { return m_nSelectType ; }
       const Vector3d& GetADir( void) const
                { return m_vtADir ; }
       double GetRot1W( void) const
@@ -65,7 +63,6 @@ class Head : public IUserObj
       int         m_nType ;
       int         m_nExitCount ;
       STRVECTOR   m_vsHSet ;
-      int         m_nSelectType ;
       Vector3d    m_vtADir ;
       double      m_dRot1W ;
       bool        m_bMaxDeltaR2On1 ;

MachConst.h

@@ -47,10 +47,6 @@ const std::string MACH_RAW_SOLID = "RawSolid" ;
 const std::string MACH_RAW_CENTER = "RawCenter" ;
 // Nome del contorno esterno del grezzo
 const std::string MACH_RAW_OUTLINE = "RawOutline" ;
-// Nome della regione superiore del grezzo
-const std::string MACH_RAW_UP_REG = "RawUpReg" ;
-// Nome della regione inferiore del grezzo
-const std::string MACH_RAW_DOWN_REG = "RawDwnReg" ;
 // Nome del kerf del grezzo
 const std::string MACH_RAW_KERF = "Kerf" ;
 
@@ -84,12 +80,6 @@ const std::string GENMACHINING_SEC = "GenMachining" ;
 // Chiave (radice) per nome lavorazione generica i-esima
 const std::string GENMACHINING_SCRIPT_KEY = "GenScript" ;
 
-//----------------------------------------------------------------------------
-// Sezione fresature 5assi nel file INI di macchina
-const std::string FIVEAXISMILLING_SEC = "5AxMilling" ;
-// Chiave (radice) per nome lavorazione 5assi i-esima
-const std::string FIVEAXISMILLING_SCRIPT_KEY = "5AxScript" ;
-
 //----------------------------------------------------------------------------
 // Sezione di attrezzaggio nel file INI di macchina
 const std::string SETUP_SEC = "Setup" ;
@@ -122,12 +112,6 @@ const std::string MILLHOLDER_KEY = "MillHolder" ;
 // Sezione portautensili nel file INI di macchina
 const std::string TOOLHOLDER_SEC = "ToolHolder" ;
 
-//----------------------------------------------------------------------------
-// Sezione lavorazioni nel file INI di macchina
-const std::string MACHININGS_SEC = "Machinings" ;
-// Chiave per abilitare discesa e risalita in rapido da fresature con estremi fuori dal grezzo
-const std::string RAPIDONOUT_KEY = "RapidOnOut" ;
-
 //----------------------------------------------------------------------------
 // Minimo spessore del grezzo
 const double RAW_MIN_H = 1 ;
@@ -147,10 +131,7 @@ const double LIO_ELEV_TOL = 2.0 ;
 //----------------------------------------------------------------------------
 // Per FlatParts (vedi Nesting di EgtExecutor)
 const std::string NST_EXT_LAYER = "OutLoop" ;
-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)
-const double MIN_ZDIR_VERT_CHSAW = 0.7072 ;

MachMgr.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2023
 //----------------------------------------------------------------------------
-// File : MachMgr.h           Data : 22.04.24          Versione : 2.6d4
+// File : MachMgr.h           Data : 28.10.23          Versione : 2.5j4
 // Contenuto : Dichiarazione della classe MachMgr.
 //
 //
@@ -13,9 +13,6 @@
 //             21.09.22 DS Aggiunta GetAxisOffset.
 //             25.08.23 DS Aggiunta CopyMachGroup.
 //             28.10.23 DS Aggiunte GetClEntAxesVal e GetToolSetupPosInCurrSetup.
-//             30.03.24 DS Aggiunte GetAllAxesNames e GetCalcTable.
-//             02.04.24 DS Aggiunta GetClEntAxesMask.
-//             22.04.24 DS Aggiunta GetExitId.
 //
 //----------------------------------------------------------------------------
 
@@ -102,7 +99,6 @@ class MachMgr : public IMachMgr
       int  AddMachGroup( const std::string& sName, const std::string& sMachineName) override ;
       int  CopyMachGroup( const std::string& sSouName, const std::string& sName) override ;
       bool RemoveMachGroup( int nId) override ;
-      bool ChangeMachGroupName( int nId, const std::string& sNewName) override ;
       std::string GetMachGroupName( int nId) const override ;
       std::string GetMachGroupMachineName( int nId) const override ;
       int  GetMachGroupId( const std::string& sName) const override ;
@@ -298,8 +294,7 @@ class MachMgr : public IMachMgr
       bool MachiningUpdate( bool bPostApply = true) override ;
       bool PreparePreviewMachiningTool( void) const override ;
       bool RemovePreviewMachiningTool( void) const override ;
-      int  GetPreviewMachiningToolStepCount( void) const override ; 
-      int  PreviewMachiningTool( int nEntId, int nStep) const override ;
+      int  PreviewMachiningTool( int nEntId, int nFlag) const override ;
       bool GetMachiningParam( int nType, bool& bVal) const override ;
       bool GetMachiningParam( int nType, int& nVal) const override ;
       bool GetMachiningParam( int nType, double& dVal) const override ;
@@ -312,7 +307,6 @@ class MachMgr : public IMachMgr
       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 GetClEntAxesMask( int nEntId, int& nMask) const override ;
       bool GetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) const override ;
      // Simulation
       bool SimInit( void) override ;
@@ -332,10 +326,9 @@ 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 GetAllCurrAxesName( STRVECTOR& vAxName) const override ;
       bool SetRotAxisBlock( const std::string& sAxis, double dVal) override ;
       bool GetRotAxisBlocked( int nInd, std::string& sAxis, double& dVal) const override ;
-      bool 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 ;
@@ -363,7 +356,6 @@ class MachMgr : public IMachMgr
       int  GetAxisId( const std::string& sAxis) const override ;
       int  GetHeadId( const std::string& sHead) const override ;
       int  GetHeadExitCount( const std::string& sHead) const override ;
-      int  GetExitId( const std::string& sHead, int nExit) const override ;
       int  GetTcPosId( const std::string& sTcPos) const override ;
       bool GetAxisToken( const std::string& sAxis, std::string& sToken) const override ;
       bool GetAxisType( const std::string& sAxis, bool& bLinear) const override ;
@@ -377,7 +369,6 @@ class MachMgr : public IMachMgr
       bool ResetAxisPos( const std::string& sAxis) override ;
       bool ResetAllAxesPos( void) override ;
       bool GetAllTablesNames( STRVECTOR& vNames) const override ;
-      bool GetAllAxesNames( STRVECTOR& vNames) const override ;
       bool GetAllHeadsNames( STRVECTOR& vNames) const override ;
       bool GetAllTcPosNames( STRVECTOR& vNames) const override ;
       bool LoadTool( const std::string& sHead, int nExit, const std::string& sTool) override ;
@@ -448,8 +439,6 @@ class MachMgr : public IMachMgr
       bool GetAllCurrAxesHomePos( DBLVECTOR& vAxHomeVal) const ;
       bool GetCurrAxisHomePos( int nInd, double& dHome) const ;
       const Frame3d& GetCurrLinAxesFrame( void) const ;
-      bool GetCurrIsCenter( void) const ;
-      bool GetCurrIsRobot( void) const ;
       bool ApplyRotAxisBlock( void) ;
       void ClearRotAxisBlock( void)
               { m_vAxisBlock.clear() ; }
@@ -471,14 +460,11 @@ class MachMgr : public IMachMgr
       bool SimAddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType, const Vector3d& vtMove, double dPar1, double dPar2, double dPar3) ;
       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 SimEnableToolsForVmill( bool bEnable) ;
+      bool SimSetToolForVmill( const std::string& sTool, const std::string& sHead, int nExit, const INTVECTOR& vVmill, bool bFirst) ;
       int  SimMoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt) ;
-      bool SimSaveCmd( int nType, int nPar, const std::string& sPar) ;
-
      // Machine
       bool GetHeadAbove( const std::string& sHead) const ;
+      double GetDeltaSafeZ( const std::string& sHead) const ;
       double GetAngDeltaMinForHome( void) const ;
                                               
    private :
@@ -505,7 +491,6 @@ class MachMgr : public IMachMgr
      // RawParts
       int  AddRawPart( int nCrvId, double dOverMat, double dZmin, double dHeight, Color cCol) ;
       int  AddRawPart( int nSurfId, Color cCol) ;
-      int  AddRawPart( int nSurfUpId, int nSurfDownId, double dHeight, Color cCol) ;
       bool SetRawPartCenter( int nRawId) ;
       bool ResetRawPartCenter( int nRawId) ;
      // Parts
@@ -552,5 +537,5 @@ class MachMgr : public IMachMgr
       int           m_nCurrDispId ;         // identificativo della disposizione corrente
       int           m_nCurrMachiningId ;    // identificativo della lavorazione corrente
       AXBLOCKVECTOR m_vAxisBlock ;          // elenco assi da bloccare
-      ISimulator*   m_pSimul ;              // puntatore al simulatore attivo 
+      Simulator*    m_pSimul ;              // puntatore al simulatore attivo 
 } ;

MachMgrBasic.cpp

@@ -311,11 +311,7 @@ MachMgr::SetLastError( int nErr, const string& sErr)
 {
    m_nLastError = nErr ;
    m_sLastError = sErr ;
-   string sInfo ;
-   if ( sErr._Starts_with( "Error"))
-      sInfo = m_sLastError + " (" + ToString( nErr) + ")" ;
-   else
-      sInfo = "Error " + ToString( nErr) + " : " + m_sLastError ;
+   string sInfo = m_sLastError + " (" + ToString( nErr) + ")" ;
    LOG_ERROR( GetEMkLogger(), sInfo.c_str()) ;
    return true ;
 }

MachMgrClEntities.cpp

@@ -16,7 +16,6 @@
 #include "DllMain.h"
 #include "MachMgr.h"
 #include "MachConst.h"
-#include "CamData.h"
 
 using namespace std ;
 
@@ -76,24 +75,6 @@ MachMgr::GetClEntIndex( int nEntId, int& nIndex) const
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-MachMgr::GetClEntAxesMask( int nEntId, int& nMask) const
-{
-  // default
-   nMask = 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 il tipo di movimento
-   nMask = pCamData->GetAxesMask() ;
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 MachMgr::GetClEntAxesVal( int nEntId, DBLVECTOR& vAxes) const

MachMgrDBMachinings.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : MachMgrDBMachinings.cpp      Data : 29.03.24      Versione : 2.6d1
+// File : MachMgrDBMachinings.cpp      Data : 11.11.15       Versione : 1.6k5
 // Contenuto : Implementazione gestione DB lavorazioni della classe MachMgr.
 //
 //
@@ -304,8 +304,6 @@ MachMgr::MdbSetGeneralParam( int nType, double dVal)
       return pMsMgr->SetSafeAggrBottZ( dVal) ;
    case MGP_MAXDEPTHSAFE :
       return pMsMgr->SetMaxDepthSafe( dVal) ;
-   case MGP_APPROXLINTOL :
-      return pMsMgr->SetApproxLinTol( dVal) ;
    }
    return false ;
 }
@@ -381,9 +379,6 @@ MachMgr::MdbGetGeneralParam( int nType, double& dVal) const
    case MGP_MAXDEPTHSAFE :
       dVal = pMsMgr->GetMaxDepthSafe() ;
       return true ;
-   case MGP_APPROXLINTOL :
-      dVal = pMsMgr->GetApproxLinTol() ;
-      return true ;
    }
    return false ;
 }

MachMgrDBTools.cpp

@@ -760,8 +760,6 @@ MachMgr::UpdateCustomToolDraw( const ToolData* pTdata, int nGenCtx, int nToolCtx
    pTdata->GetParam( TPA_DIAM, dDiam) ;
    double dDist = 0 ;
    pTdata->GetParam( TPA_DIST, dDist) ;
-   double dSpeed = 0 ;
-   pTdata->GetParam( TPA_SPEED, dSpeed) ;
   // Imposto contesto per il disegno utensile
    if ( ! ExeSetCurrentContext( nToolCtx))
       return TD_INT_ERR ;
@@ -771,7 +769,6 @@ MachMgr::UpdateCustomToolDraw( const ToolData* pTdata, int nGenCtx, int nToolCtx
    bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.LEN", dLen) ;
    bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.DIAM", dDiam) ;
    bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.DIST", dDist) ;
-   bOk = bOk && ExeLuaSetGlobNumVar( "TOOL.SPEED", dSpeed) ;
   // Eseguo aggiornamento utensile
    bOk = bOk && ExeLuaCallFunction( "AdjustCustomTool") ;
   // Recupero errore

MachMgrGeneration.cpp

@@ -18,7 +18,6 @@
 #include "MachConst.h"
 #include "Generator.h"
 #include "Estimator.h"
-#include "/EgtDev/Include/EGnFileUtils.h"
 
 using namespace std ;
 
@@ -26,22 +25,6 @@ using namespace std ;
 bool
 MachMgr::Generate( const string& sCncFile, const string& sInfo)
 {
-  // se macchina multiprocesso è necessaria stima speciale 
-   if ( GetCurrMachine() != nullptr  &&  GetCurrMachine()->GetMultiProcess()) {
-     // inizializzazione stimatore
-      Estimator estPP ;
-      if ( ! estPP.Init( this)) {
-         LOG_ERROR( GetEMkLogger(), "Error on Estimate Init")
-         return false ;
-      }
-     // esecuzione della stima
-      string sEstFile = ChangeFileExtension( sCncFile, "sest") ;
-      if ( ! estPP.Run( sEstFile, sInfo)) {
-         LOG_ERROR( GetEMkLogger(), "Error on Estimate Run")
-         return false ;
-      }
-   }
-   
   // inizializzazione generatore
    Generator genPP ;
    if ( ! genPP.Init( this)) {
@@ -61,13 +44,13 @@ MachMgr::Generate( const string& sCncFile, const string& sInfo)
 bool
 MachMgr::Estimate( const string& sEstFile, const string& sInfo)
 {
-  // inizializzazione stimatore
+  // inizializzazione generatore
    Estimator estPP ;
    if ( ! estPP.Init( this)) {
       LOG_ERROR( GetEMkLogger(), "Error on Estimate Init")
       return false ;
    }
-  // esecuzione della stima
+  // esecuzione della generazione
    if ( ! estPP.Run( sEstFile, sInfo)) {
       LOG_ERROR( GetEMkLogger(), "Error on Estimate Run")
       return false ;

MachMgrMachGroups.cpp

@@ -268,60 +268,44 @@ MachMgr::VerifyMachGroup( int nId, MachGrp& mgData) const
   // verifica della macchina
    bool bMName = m_pGeomDB->GetInfo( nId, MACH_MACHINE_KEY, mgData.MGeoName) ;
   // scansiono i sottogruppi
+   PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGeomDB)) ;
+   if ( IsNull( pIter))
+      return false ;
    bool bSetup = false ;
    bool bFixt = false ;
    bool bRaw = false ;
    bool bOper = false ;
-   int nGrpId = m_pGeomDB->GetFirstGroupInGroup( nId) ;
-   while ( nGrpId != GDB_ID_NULL) {
+   bool bIter = pIter->GoToFirstGroupInGroup( nId) ;
+   while ( bIter) {
       string sName ;
-      if ( m_pGeomDB->GetName( nGrpId, sName)) {
+      if ( pIter->GetName( sName)) {
          if ( sName == MACH_SETUP_GROUP) {
             if ( ! bSetup)
-               mgData.SetupGroupId = nGrpId ;
+               mgData.SetupGroupId = pIter->GetId() ;
             bSetup = true ;
          }
          else if ( sName == MACH_FIXT_GROUP) {
             if ( ! bFixt)
-               mgData.FixtGroupId = nGrpId ;
+               mgData.FixtGroupId = pIter->GetId() ;
             bFixt = true ;
          }
          else if ( sName == MACH_RAW_GROUP) {
             if ( ! bRaw)
-               mgData.RawGroupId = nGrpId ;
+               mgData.RawGroupId = pIter->GetId() ;
             bRaw = true ;
          }
          else if ( sName == MACH_OPER_GROUP) {
             if ( ! bOper)
-               mgData.OperGroupId = nGrpId ;
+               mgData.OperGroupId = pIter->GetId() ;
             bOper = true ;
          }
       }
      // passo al successivo
-      nGrpId = m_pGeomDB->GetNextGroup( nGrpId) ;
+      bIter = pIter->GoToNextGroup() ;
    }
    return ( bMName && bSetup && bRaw && bOper) ;
 }
 
-//----------------------------------------------------------------------------
-bool
-MachMgr::ChangeMachGroupName( int nId, const string& sNewName)
-{
-  // verifica del gruppo base per le lavorazioni
-   if ( ! VerifyMachBase())
-      return false ;
-  // verifico che il gruppo ricevuto sia corretto
-   if ( m_pGeomDB->GetParentId( nId) != m_nMachBaseId)
-      return false ;
-  // verifico nome non vuoto e non esista già un gruppo con lo stesso nome
-   if ( &sNewName == nullptr  ||  sNewName.empty()  ||  GetMachGroupId( sNewName) != GDB_ID_NULL)
-      return false ;
-  // cambio il nome del gruppo di lavoro
-   if ( ! m_pGeomDB->SetName( nId, sNewName))
-      return false ;
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 string
 MachMgr::GetMachGroupName( int nId) const
@@ -365,14 +349,17 @@ MachMgr::GetMachGroupId( const string& sName) const
    if ( ! VerifyMachBase())
       return GDB_ID_NULL ;
   // recupero l'identificativo del gruppo con il nome indicato
-   int nGrpId = m_pGeomDB->GetFirstGroupInGroup( m_nMachBaseId) ;
-   while ( nGrpId != GDB_ID_NULL) {
+   PtrOwner<IGdbIterator> pIter( CreateGdbIterator( m_pGeomDB)) ;
+   if ( IsNull( pIter))
+      return GDB_ID_NULL ;
+   bool bIter = pIter->GoToFirstGroupInGroup( m_nMachBaseId) ;
+   while( bIter) {
      // verifico il nome
       string sMGroupName ;
-      if ( m_pGeomDB->GetName( nGrpId, sMGroupName)  &&  EqualNoCase( sMGroupName, sName))
-         return nGrpId ;
+      if ( pIter->GetName( sMGroupName)  &&  EqualNoCase( sMGroupName, sName))
+         return pIter->GetId() ;
      // passo al successivo
-      nGrpId = m_pGeomDB->GetNextGroup( nGrpId) ;
+      bIter = pIter->GoToNextGroup() ;
    }
    return GDB_ID_NULL ;
 }

MachMgrMachines.cpp

@@ -274,15 +274,6 @@ MachMgr::GetHeadExitCount( const string& sHead) const
    return ( ( pMch != nullptr) ?  pMch->GetHeadExitCount( sHead) : 0) ;
 }
 
-//----------------------------------------------------------------------------
-int
-MachMgr::GetExitId( const string& sHead, int nExit) const
-{
-   Machine* pMch = GetCurrMachine() ;
-  // recupero identificativo dell'uscita della testa indicata nella macchina corrente
-   return ( ( pMch != nullptr) ?  pMch->GetExitId( sHead, nExit) : GDB_ID_NULL) ;
-}
-
 //----------------------------------------------------------------------------
 int
 MachMgr::GetTcPosId( const string& sTcPos) const
@@ -303,6 +294,18 @@ MachMgr::GetHeadAbove( const string& sHead) const
    return ( ! m_pGeomDB->GetInfo( GetHeadId( sHead), MCH_ABOVE, bAbove)  ||  bAbove) ;
 }
 
+//----------------------------------------------------------------------------
+double
+MachMgr::GetDeltaSafeZ( const string& sHead) const
+{
+   if ( m_pGeomDB == nullptr)
+      return 0 ;
+  // Leggo da testa Info ZSAFEDELTA
+   double dDeltaSafeZ = 0 ;
+   m_pGeomDB->GetInfo( GetHeadId( sHead), MCH_ZSAFEDELTA, dDeltaSafeZ) ;
+   return dDeltaSafeZ ;
+}
+
 //----------------------------------------------------------------------------
 double
 MachMgr::GetAngDeltaMinForHome( void) const
@@ -531,14 +534,6 @@ MachMgr::SetCalcSolCh( int nScc, bool bExact)
    return pMch->SetSolCh( nScc, bExact) ;
 }
 
-//----------------------------------------------------------------------------
-bool
-MachMgr::GetCalcTable( string& sTable) const
-{
-   Machine* pMch = GetCurrMachine() ;
-   return ( ( pMch != nullptr) ? pMch->GetCurrTable( sTable) : false) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 MachMgr::GetCalcTool( string& sTool) const
@@ -614,17 +609,6 @@ MachMgr::GetAllTablesNames( STRVECTOR& vNames) const
    return ( ( pMch != nullptr) ? pMch->GetAllTablesNames( vNames) : false) ;
 }
 
-//----------------------------------------------------------------------------
-bool
-MachMgr::GetAllAxesNames( STRVECTOR& vNames) const
-{
-  // pulisco il vettore
-   vNames.clear() ;
-  // richiedo elenco assi alla macchina corrente
-   Machine* pMch = GetCurrMachine() ;
-   return ( ( pMch != nullptr) ? pMch->GetAllAxesNames( vNames) : false) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 MachMgr::GetAllHeadsNames( STRVECTOR& vNames) const
@@ -665,10 +649,10 @@ MachMgr::GetCurrRotAxes( void) const
 
 //----------------------------------------------------------------------------
 bool
-MachMgr::GetAllCurrAxesNames( STRVECTOR& vAxName) const
+MachMgr::GetAllCurrAxesName( STRVECTOR& vAxName) const
 {
    Machine* pMch = GetCurrMachine() ;
-   return ( ( pMch != nullptr) ? pMch->GetAllCurrAxesNames( vAxName) : false) ;
+   return ( ( pMch != nullptr) ? pMch->GetAllCurrAxesName( vAxName) : false) ;
 }
 
 //----------------------------------------------------------------------------
@@ -699,26 +683,6 @@ MachMgr::GetCurrLinAxesFrame( void) const
    return pMch->GetCurrLinAxesFrame() ;
 }
 
-//----------------------------------------------------------------------------
-bool
-MachMgr::GetCurrIsCenter( void) const
-{
-   Machine* pMch = GetCurrMachine() ;
-   if ( pMch == nullptr)
-      return false ;
-   return ( pMch->GetCurrKinematicChainType() == KIN_CHAIN_CENTER) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-MachMgr::GetCurrIsRobot( void) const
-{
-   Machine* pMch = GetCurrMachine() ;
-   if ( pMch == nullptr)
-      return false ;
-   return ( pMch->GetCurrKinematicChainType() == KIN_CHAIN_ROBOT) ;
-}
-
 //----------------------------------------------------------------------------
 bool
 MachMgr::GetCalcAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
@@ -763,7 +727,7 @@ MachMgr::GetCalcTipFromPositions( double dX, double dY, double dZ, double dAngA,
 {
    DBLVECTOR vAng( 2) ; vAng[0] = dAngA ; vAng[1] = dAngB ;
    Machine* pMch = GetCurrMachine() ;
-   return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, false, ptTip) : false) ;
+   return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, ptTip) : false) ;
 }
 
 //----------------------------------------------------------------------------
@@ -772,7 +736,7 @@ MachMgr::GetCalcTipFromPositions( double dX, double dY, double dZ, const DBLVECT
                                   bool bOverall, bool bBottom, Point3d& ptTip) const
 {
    Machine* pMch = GetCurrMachine() ;
-   return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, false, ptTip) : false) ;
+   return ( ( pMch != nullptr) ? pMch->GetTipFromPositions( dX, dY, dZ, vAng, bOverall, bBottom, ptTip) : false) ;
 }
 
 //----------------------------------------------------------------------------

MachMgrOperations.cpp

@@ -1122,23 +1122,7 @@ MachMgr::RemovePreviewMachiningTool( void) const
 
 //----------------------------------------------------------------------------
 int
-MachMgr::GetPreviewMachiningToolStepCount( void) const
-{
-  // recupero la lavorazione corrente
-   int nCurrMchId = GetCurrMachining() ;
-   if ( nCurrMchId == GDB_ID_NULL)
-      return 0 ;
-  // ne recupero il gestore
-   Machining* pMch = GetMachining( m_pGeomDB->GetUserObj( nCurrMchId)) ;
-   if ( pMch == nullptr)
-      return 0 ;
-  // eseguo
-   return pMch->GetToolPreviewStepCount() ;
-}
-
-//----------------------------------------------------------------------------
-int
-MachMgr::PreviewMachiningTool( int nEntId, int nStep) const
+MachMgr::PreviewMachiningTool( int nEntId, int nFlag) const
 {
   // recupero la lavorazione corrente
    int nCurrMchId = GetCurrMachining() ;
@@ -1149,7 +1133,7 @@ MachMgr::PreviewMachiningTool( int nEntId, int nStep) const
    if ( pMch == nullptr)
       return GDB_ID_NULL ;
   // eseguo
-   return pMch->ToolPreview( nEntId, nStep) ;
+   return pMch->ToolPreview( nEntId, nFlag) ;
 }
 
 //----------------------------------------------------------------------------

MachMgrRawParts.cpp

@@ -29,7 +29,6 @@
 #include "/EgtDev/Include/EGkStmStandard.h"
 #include "/EgtDev/Include/EGkStmFromCurves.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
-#include "/EgtDev/Include/EXeConst.h"
 
 using namespace std ;
 
@@ -97,7 +96,7 @@ MachMgr::AddRawPart( const Point3d& ptOrig, double dLen, double dWidth, double d
    m_pGeomDB->SetInfo( nRawId, MACH_RAW_PHASE, m_nCurrPhase) ;
   // creo solido e outline
    bOk = bOk && ModifyRawPart( nRawId, ptOrig, dLen, dWidth, dHeight, cCol) ;
-  // se qualcosa è andato storto, cancello tutto
+  // se qualcosa è andato storto, cancello tutto
    if ( ! bOk) {
       m_pGeomDB->Erase( nRawId) ;
       return GDB_ID_NULL ;
@@ -113,7 +112,7 @@ MachMgr::ModifyRawPart( int nRawId, const Point3d& ptOrig, double dLen, double d
   // le dimensioni non possono essere nulle
    if ( dLen < EPS_SMALL  ||  dWidth < EPS_SMALL  ||  dHeight < EPS_SMALL)
       return false ;
-  // verifica validità grezzo
+  // verifica validità grezzo
    if ( ! VerifyRawPart( nRawId))
       return false ;
   // creo il solido
@@ -172,7 +171,7 @@ MachMgr::AddRawPartWithPart( int nPartId, int nCrvSrfId, double dOverMat, Color
   // verifico il gruppo dei grezzi nella macchinata corrente
    if ( GetCurrRawGroupId() == GDB_ID_NULL)
       return GDB_ID_NULL ;
-  // verifico che il pezzo non sia già usato nella macchinata corrente
+  // verifico che il pezzo non sia già usato nella macchinata corrente
    if ( m_pGeomDB->GetParentId( nPartId) != GDB_ID_ROOT)
       return GDB_ID_NULL ;
   // recupero il tipo di oggetto per definire il grezzo
@@ -181,7 +180,7 @@ MachMgr::AddRawPartWithPart( int nPartId, int nCrvSrfId, double dOverMat, Color
    Point3d ptRef ;
   // costruzione del grezzo
    int nRawId = GDB_ID_NULL ;
-  // se grezzo da superficie (per ora senza possibilità di offset)
+  // se grezzo da superficie (per ora senza possibilità di offset)
    if ( ( nGtype & GEO_SURF) != 0) {
      // inserisco il grezzo
       nRawId = AddRawPart( nCrvSrfId, cCol) ;
@@ -285,7 +284,7 @@ MachMgr::AddRawPart( int nCrvId, double dOverMat, double dZmin, double dHeight,
    m_pGeomDB->SetInfo( nRawId, MACH_RAW_PHASE, m_nCurrPhase) ;
   // creo solido e outline
    bOk = bOk && ModifyRawPart( nRawId, nCrvId, dOverMat, dZmin, dHeight, cCol) ;
-  // se qualcosa è andato storto, cancello tutto
+  // se qualcosa è andato storto, cancello tutto
    if ( ! bOk) {
       m_pGeomDB->Erase( nRawId) ;
       return GDB_ID_NULL ;
@@ -298,7 +297,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)
 {
-  // verifica validità grezzo
+  // verifica validità grezzo
    if ( ! VerifyRawPart( nRawId))
       return false ;
   // recupero il riferimento della curva
@@ -322,7 +321,7 @@ MachMgr::ModifyRawPart( int nRawId, int nCrvId, double dOverMat, double dZmin, d
   // la schiaccio a Z = 0
    if ( ! pMyCrv->Scale( Frame3d(), 1, 1, 0))
       return false ;
-  // se non è chiusa, la chiudo
+  // se non è chiusa, la chiudo
    pMyCrv->Close() ;
   // la oriento in senso CCW
    double dAreaXY ;
@@ -376,11 +375,11 @@ MachMgr::AddRawPart( int nSurfId, Color cCol)
    if ( nRawGroupId == GDB_ID_NULL)
       return GDB_ID_NULL ;
   // recupero l'ingombro della superficie in globale
-   BBox3d b3Surf ;
-   if ( ! m_pGeomDB->GetGlobalBBox( nSurfId, b3Surf))
+   BBox3d b3Crv ;
+   if ( ! m_pGeomDB->GetGlobalBBox( nSurfId, b3Crv))
       return GDB_ID_NULL ;
   // inserisco il gruppo del grezzo nella macchinata
-   Frame3d frRaw( b3Surf.GetMin()) ;
+   Frame3d frRaw( b3Crv.GetMin()) ;
    int nRawId = m_pGeomDB->AddGroup( GDB_ID_NULL, nRawGroupId, frRaw) ;
    if ( nRawId == GDB_ID_NULL)
       return GDB_ID_NULL ;
@@ -457,11 +456,11 @@ MachMgr::AddRawPart( int nSurfId, Color cCol)
       int nCrvId = ( bOk ? m_pGeomDB->AddGeoObj( GDB_ID_NULL, nRawId, Release( pCrvCompo)) : GDB_ID_NULL) ;
       bOk = bOk && ( nCrvId != GDB_ID_NULL) ;
      // assegno il nome alla curva
-      bOk = bOk && m_pGeomDB->SetName( nCrvId, MACH_RAW_OUTLINE) ;
+      bOk = bOk && m_pGeomDB->SetName( nCrvId, MACH_RAW_SOLID) ;
      // assegno il colore alla curva
-      bOk = bOk && m_pGeomDB->SetMaterial( nCrvId, cCol) ;     
+      bOk = bOk && m_pGeomDB->SetMaterial( nCrvId, cCol) ;
    }
-  // se qualcosa è andato storto, cancello tutto
+  // se qualcosa è andato storto, cancello tutto
    if ( ! bOk) {
       m_pGeomDB->Erase( nRawId) ;
       return GDB_ID_NULL ;
@@ -472,156 +471,6 @@ MachMgr::AddRawPart( int nSurfId, Color cCol)
    return nRawId ;
 }
 
-//----------------------------------------------------------------------------
-int
-MachMgr::AddRawPart( int nSfrUpId, int nSfrDownId, double dHeight, Color cCol)
-{
-  // recupero il gruppo dei grezzi nella macchinata corrente
-   int nRawGroupId = GetCurrRawGroupId() ;
-   if ( nRawGroupId == GDB_ID_NULL)
-      return GDB_ID_NULL ;
-
-  // recupero l'ingombro della superficie up in globale
-   BBox3d b3Surf ;
-   if ( ! m_pGeomDB->GetGlobalBBox( nSfrUpId, b3Surf))
-      return GDB_ID_NULL ;
-  // inserisco il gruppo del grezzo nella macchinata
-   Frame3d frRaw( b3Surf.GetMin()) ;
-   int nRawId = m_pGeomDB->AddGroup( GDB_ID_NULL, nRawGroupId, frRaw) ;
-   if ( nRawId == GDB_ID_NULL)
-      return GDB_ID_NULL ;
-  // assegno il nome al gruppo
-   bool bOk = m_pGeomDB->SetName( nRawId, MACH_RAW_PART) ;
-  // assegno la fase al gruppo
-   bOk = bOk && m_pGeomDB->SetInfo( nRawId, MACH_RAW_PHASE, m_nCurrPhase) ;
-
-  // recupero il frame originale della superficie up ( deve essere lo stesso della down)
-   Frame3d frSurf ; 
-   bOk = bOk && m_pGeomDB->GetGlobFrame( nSfrUpId, frSurf) ;
-
-  // creo il volume in modo approssimativo a partire dalle due superfici considerando soltanto un'approssimazione dei bordi esterni
-  // regione up  
-   PtrOwner<ISurfFlatRegion> pSurfUp( CloneSurfFlatRegion( m_pGeomDB->GetGeoObj( nSfrUpId))) ;
-   bOk = bOk && ( ! IsNull( pSurfUp)) ;
-   // calcolo offset e contro-offset per unificare i chunk ed eliminare eventuali rientranze nella superficie
-   double dOffs = 8 ;
-   bOk = bOk && pSurfUp->Offset( dOffs, ICurve::OFF_FILLET) ;
-   bOk = bOk && pSurfUp->Offset( -dOffs, ICurve::OFF_FILLET) ;
-   // recupero il chunk di area maggiore
-   int nKMax = 0 ;
-   if ( bOk  &&  pSurfUp->GetChunkCount() > 1) {
-      double dAreaMax = -1 ;
-      for ( int k = 0 ; k < pSurfUp->GetChunkCount() ; k ++) {
-         PtrOwner<ISurfFlatRegion> pSfrChunk( pSurfUp->CloneChunk( k)) ;
-         double dArea = -1 ; pSfrChunk->GetGrossArea( dArea) ;
-         if ( dArea > dAreaMax) {
-            nKMax = k ;
-            dAreaMax = dArea ;
-         }
-      }  
-   }
-   PtrOwner<ICurve> pCrvUp ;
-   bOk = bOk && pCrvUp.Set( pSurfUp->GetLoop( nKMax, 0)) ;
-   bOk = bOk && ( ! IsNull( pCrvUp)) ;
-
-  // regione down
-   PtrOwner<ISurfFlatRegion> pSurfDown( CloneSurfFlatRegion( m_pGeomDB->GetGeoObj( nSfrDownId))) ;
-   bOk = bOk && ( ! IsNull( pSurfDown)) ;
-   bOk = bOk && pSurfDown->Offset( dOffs, ICurve::OFF_FILLET) ;
-   bOk = bOk && pSurfDown->Offset( -dOffs, ICurve::OFF_FILLET) ;
-   nKMax = 0 ;
-   if ( bOk  &&  pSurfDown->GetChunkCount() > 1) {
-      double dAreaMax = -1 ;
-      for ( int k = 0 ; k < pSurfDown->GetChunkCount() ; k ++) {
-         PtrOwner<ISurfFlatRegion> pSfrChunk( pSurfDown->CloneChunk( k)) ;
-         double dArea = -1 ; pSfrChunk->GetGrossArea( dArea) ;
-         if ( dArea > dAreaMax) {
-            nKMax = k ;
-            dAreaMax = dArea ;
-         }
-      }  
-   }
-   PtrOwner<ICurveComposite> pCrvDown ;
-   bOk = bOk && pCrvDown.Set( ConvertCurveToComposite( pSurfDown->GetLoop( nKMax, 0))) ;
-   bOk = bOk && ( ! IsNull( pCrvDown)) ;
-   // sposto il punto di inizio il più vicino possibile a quello della curva up per migliorare il calcolo della rigata  
-   if ( bOk) {
-      Point3d ptS ; pCrvUp->GetStartPoint( ptS) ; 
-      DistPointCurve distPC( ptS, *pCrvDown) ;
-      double dPar ; int nFlag ;
-      bOk = bOk && distPC.GetParamAtMinDistPoint( 0, dPar, nFlag) ;
-      bOk = bOk && pCrvDown->ChangeStartPoint( dPar) ;   
-   }  
-
-  // volume
-   PtrOwner<ISurfTriMesh> pStmRaw ;
-   bOk = bOk && pStmRaw.Set( GetSurfTriMeshByFlatContour( pCrvUp)) ;
-   bOk = bOk && ( ! IsNull( pStmRaw)) ;   
-   PtrOwner<ISurfTriMesh> pStmLat ;
-   bOk = bOk && pStmLat.Set( GetSurfTriMeshRuled( pCrvDown, pCrvUp, ISurfTriMesh::RLT_MINDIST)) ;
-   bOk = bOk && ( ! IsNull( pStmLat)) ;
-   bOk = bOk && pStmRaw->DoSewing( *pStmLat) ;
-   PtrOwner<ISurfTriMesh> pStmDown ;
-   bOk = bOk && pStmDown.Set( GetSurfTriMeshByFlatContour( pCrvDown)) ;
-
-   bOk = bOk && pStmDown->Invert() ;
-   bOk = bOk && pStmRaw->DoSewing( *pStmDown) ;
-   bOk = bOk && pStmRaw->DoCompacting() ;
-   bOk = bOk && pStmRaw->Repair() ;
-   bOk = bOk && pStmRaw->LocToLoc( frSurf, frRaw) ;
-   int nId = bOk ? m_pGeomDB->AddGeoObj( GDB_ID_NULL, nRawId, Release( pStmRaw)) : GDB_ID_NULL ;
-   bOk = bOk && ( nId != GDB_ID_NULL) ;
-  // assegno il nome al solido
-   bOk = bOk && m_pGeomDB->SetName( nId, MACH_RAW_SOLID) ;
-  // assegno il colore al solido
-   bOk = bOk && m_pGeomDB->SetMaterial( nId, cCol) ;
-  // rendo visibile il solido
-   bOk = bOk && m_pGeomDB->SetStatus( nId, GDB_ST_ON) ;
-  // calcolo il punto centro del solido
-   bOk = bOk && SetRawPartCenter( nRawId) ;
-
-   if ( bOk) {
-     // costruisco la curva di contorno
-      PtrOwner<ISurfFlatRegion> pSfrUp( CloneSurfFlatRegion( m_pGeomDB->GetGeoObj( nSfrUpId))) ;
-      PtrOwner<ISurfFlatRegion> pSfrDown( CloneSurfFlatRegion( m_pGeomDB->GetGeoObj( nSfrDownId))) ;
-      bOk = bOk && ( ! IsNull( pSfrUp)) && ( ! IsNull( pSfrDown)) ;
-      if ( bOk) 
-         pSfrUp->Add( *pSfrDown) ;
-      PtrOwner<ICurve> pCrv ;
-      bOk = bOk && pCrv.Set( pSfrUp->GetLoop( 0, 0)) ;
-      bOk = bOk && ( ! IsNull( pCrv)) ;
-      bOk = bOk && pCrv->LocToLoc( frSurf, frRaw) ;
-      int nLoop = bOk ? m_pGeomDB->AddGeoObj( GDB_ID_NULL, nRawId, Release( pCrv)) : GDB_ID_NULL ;
-      bOk = bOk && ( nLoop != GDB_ID_NULL) ;
-      bOk = bOk && ExeMove( {nLoop}, -dHeight * Z_AX, RTY_LOC) ;
-     // assegno il nome alla curva
-      bOk = bOk && m_pGeomDB->SetName( nLoop, MACH_RAW_OUTLINE) ;
-     // assegno il colore alla curva
-      bOk = bOk && m_pGeomDB->SetMaterial( nLoop, cCol) ;
-
-     // recupero le superfici up e down
-      int nSurfUpId = ( bOk ? m_pGeomDB->CopyGlob( nSfrUpId, GDB_ID_NULL, nRawId) : GDB_ID_NULL) ;
-      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) ;
-      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) ;
-   }
-
-  // se qualcosa è andato storto, cancello tutto
-   if ( ! bOk) {
-      m_pGeomDB->Erase( nRawId) ;
-      return GDB_ID_NULL ;
-   }
-
-  // tutto ok
-   return nRawId ;
-}
-
 //----------------------------------------------------------------------------
 bool
 MachMgr::ModifyRawPartSize( int nRawId, double dLength, double dWidth, double dHeight)
@@ -629,7 +478,7 @@ MachMgr::ModifyRawPartSize( int nRawId, double dLength, double dWidth, double dH
   // le nuove dimensioni non possono essere nulle
    if ( dLength < EPS_SMALL  ||  dWidth < EPS_SMALL  ||  dHeight < EPS_SMALL)
       return false ;
-  // verifica validità grezzo
+  // verifica validità grezzo
    if ( ! VerifyRawPart( nRawId))
       return false ;
   // recupero il solido del grezzo
@@ -671,10 +520,10 @@ MachMgr::ModifyRawPartSize( int nRawId, double dLength, double dWidth, double dH
 bool
 MachMgr::ModifyRawPartHeight( int nRawId, double dHeight)
 {
-  // la nuova altezza non può essere nulla
+  // la nuova altezza non può essere nulla
    if ( dHeight < EPS_SMALL)
       return false ;
-  // verifica validità grezzo
+  // verifica validità grezzo
    if ( ! VerifyRawPart( nRawId))
       return false ;
   // recupero il solido del grezzo
@@ -703,10 +552,10 @@ MachMgr::GetRawPartPhases( int nRawId, INTVECTOR& vPhase) const
 {
   // pulisco parametro di ritorno
    vPhase.clear() ;
-  // verifica validità grezzo
+  // verifica validità grezzo
    if ( ! VerifyRawPart( nRawId))
       return false ;
-  // recupero le fasi in cui è presente il grezzo (se manca è fase 1)
+  // recupero le fasi in cui è presente il grezzo (se manca è fase 1)
    if ( ! m_pGeomDB->GetInfo( nRawId, MACH_RAW_PHASE, vPhase)  ||  vPhase.empty())
       vPhase.emplace_back( 1) ;
    return true ;
@@ -716,11 +565,11 @@ MachMgr::GetRawPartPhases( int nRawId, INTVECTOR& vPhase) const
 bool
 MachMgr::KeepRawPart( int nRawId, int nSouPhase)
 {
-  // verifico validità e recupero fasi in cui è presente
+  // verifico validità e recupero fasi in cui è presente
    INTVECTOR vPhase ;
    if ( ! GetRawPartPhases( nRawId, vPhase))
       return false ;
-  // se fase corrente già presente, non devo fare alcunché
+  // se fase corrente già presente, non devo fare alcunché
    if ( find( vPhase.begin(), vPhase.end(), m_nCurrPhase) != vPhase.end())
       return true ;
   // aggiungo la fase corrente
@@ -772,7 +621,7 @@ MachMgr::KeepRawPart( int nRawId, int nSouPhase)
 bool
 MachMgr::VerifyRawPartPhase( int nRawId, int nPhase) const
 {
-  // verifico validità e recupero fasi in cui è presente
+  // verifico validità e recupero fasi in cui è presente
    INTVECTOR vPhase ;
    if ( ! GetRawPartPhases( nRawId, vPhase))
       return false ;
@@ -784,11 +633,11 @@ MachMgr::VerifyRawPartPhase( int nRawId, int nPhase) const
 bool
 MachMgr::RemoveRawPartFromCurrPhase( int nRawId)
 {
-  // verifico validità e recupero fasi in cui è presente
+  // verifico validità e recupero fasi in cui è presente
    INTVECTOR vPhase ;
    if ( ! GetRawPartPhases( nRawId, vPhase))
       return false ;
-  // se non appartiene alla fase corrente, non devo fare alcunché
+  // se non appartiene alla fase corrente, non devo fare alcunché
    auto iIter = find( vPhase.begin(), vPhase.end(), m_nCurrPhase) ;
    if ( iIter == vPhase.end())
       return true ;
@@ -815,7 +664,7 @@ MachMgr::RemoveRawPartFromCurrPhase( int nRawId)
 bool
 MachMgr::RemoveRawPart( int nRawId)
 {
-  // verifica validità grezzo
+  // verifica validità grezzo
    if ( ! VerifyRawPart( nRawId))
       return false ;
   // tolgo dalle disposizioni in cui compare gli eventuali movimenti registrati di questo grezzo
@@ -839,7 +688,7 @@ MachMgr::VerifyRawPart( int nRawId, bool bLinkedAllowed) const
    int nRawGroupId = GetCurrRawGroupId() ;
    if ( nRawGroupId != GDB_ID_NULL  &&  m_pGeomDB->GetParentId( nRawId) == nRawGroupId)
       return true ;
-  // se consentito linkaggio ed il grezzo è linkato ad un gruppo della macchina corrente, va bene
+  // se consentito linkaggio ed il grezzo è linkato ad un gruppo della macchina corrente, va bene
    if ( bLinkedAllowed) {
       Machine* pMch = GetCurrMachine() ;
       if ( pMch != nullptr  &&  pMch->IsLinkedRawPart( nRawId))
@@ -959,12 +808,12 @@ MachMgr::ResetRawPartCenter( int nRawId)
 bool
 MachMgr::GetRawPartCenter( int nRawId, Point3d& ptCen)
 {
-  // verifica validità grezzo
+  // verifica validità grezzo
    if ( ! VerifyRawPart( nRawId))
       return false ;
   // cerco di recuperare l'oggetto
    int nGPntId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_CENTER) ;
-  // ne verifico la validità
+  // ne verifico la validità
    int nMode ;
    if ( nGPntId == GDB_ID_NULL  ||
         ! m_pGeomDB->GetMode( nGPntId, nMode)  ||  nMode != GDB_MD_STD) {
@@ -992,7 +841,7 @@ MachMgr::GetRawPartCenter( int nRawId, Point3d& ptCen)
 bool
 MachMgr::GetRawPartBBox( int nRawId, BBox3d& b3Raw)
 {
-  // verifica validità grezzo
+  // verifica validità grezzo
    if ( ! VerifyRawPart( nRawId))
       return false ;
   // recupero solido del grezzo
@@ -1000,103 +849,6 @@ MachMgr::GetRawPartBBox( int nRawId, BBox3d& b3Raw)
    return m_pGeomDB->GetGlobalBBox( nRawSolidId, b3Raw) ;
 }
 
-//---------------------------------------------------------------------------
-static bool
-AssociateSurfs( IGeomDB* pGeomDB, int nSurfUpId, int nSurfDownId, vector<pair<int,int>>& vRawSurfs) 
-{
-  // vRawSurfs contiene tutte le coppie ( id regioneUp, id regioneDown) che definiscono i nuovi grezzi 
-   vRawSurfs.clear() ;
- 
-   int nUpCnt = ExeSurfFrChunkCount( nSurfUpId) ;
-   int nDownCnt = ExeSurfFrChunkCount( nSurfDownId) ;
-  // se non sono stati creati più grezzi
-   if ( nUpCnt == 1  ||  nDownCnt == 1) {
-      vRawSurfs.emplace_back( nSurfUpId, nSurfDownId) ;
-      return true ;
-   }
-
-   int nUpFirstId = ExeExplodeSurface( nSurfUpId, &nUpCnt) ;
-   int nDownFirstId = ExeExplodeSurface( nSurfDownId, &nDownCnt) ;
-
-  // ad ogni chunk della regione up associo i chunk corrispondenti della regione down
-   INTVECTOR vChunks( nUpCnt, GDB_ID_NULL) ; 
-   for ( int nIdD = nDownFirstId ; nIdD < nDownFirstId + nDownCnt ; nIdD ++) {
-      ISurfFlatRegion* pSfrD = GetSurfFlatRegion( pGeomDB->GetGeoObj( nIdD)) ;
-      if ( pSfrD == nullptr)
-         return false ;
-      BBox3d bBoxD ; ExeGetBBox( nIdD, BBF_STANDARD, bBoxD) ;
-     // inidividuo il chunk della superficie up che interagisce maggiormente con il chunk corrente della superficie down
-      int k = -1 ;
-      double dMaxArea = -1 ; 
-      for ( int j = 0 ; j < nUpCnt ; j ++) {
-         BBox3d bBoxU ; ExeGetBBox( nUpFirstId + j, BBF_STANDARD, bBoxU) ;        
-         if ( bBoxU.OverlapsXY( bBoxD)) {
-            PtrOwner<ISurfFlatRegion> pSfrU( CloneSurfFlatRegion( pGeomDB->GetGeoObj( nUpFirstId + j))) ;
-            if ( IsNull( pSfrU))
-               return false ;
-           // le due superfici sono nello stesso frame
-            pSfrU->Intersect( *pSfrD) ;
-            double dArea = -1 ; pSfrU->GetArea( dArea) ;
-            if ( dArea > dMaxArea) {
-               k = j ;
-               dMaxArea = dArea ;
-            }
-         }          
-      }
-     
-     // aggiorno le superfici con l'associazione trovata
-      if ( k == -1)
-         return false ;
-      if ( vChunks[k] == GDB_ID_NULL)
-         vChunks[k] = nIdD ;
-      else {        
-         ExeSurfFrAdd( vChunks[k], nIdD) ;
-         ExeErase( {nIdD}) ;
-      }        
-   }
- 
-  // controllo per ogni chunk della superficie up il corrispondente della nuova superficie down
-   for ( int i = 0 ; i < nUpCnt ; i ++) {     
-      ISurfFlatRegion* pSfrU = GetSurfFlatRegion( pGeomDB->GetGeoObj( nUpFirstId + i)) ;
-      if ( pSfrU == nullptr)
-         return false ;
-      BBox3d bBoxU ; ExeGetBBox( nUpFirstId + i, BBF_STANDARD, bBoxU) ;        
-     // individuo il chunk della superficie down che interagisce maggiormente con il chunk corrente della superficie up 
-      int k = -1 ;
-      double dMaxArea = -1 ;
-      for ( int j = 0 ; j < int( vChunks.size()) ; j ++) {        
-         BBox3d bBoxD ; ExeGetBBox( vChunks[j], BBF_STANDARD, bBoxD) ;
-        // se i box interferiscono allora verifico di quanto si sovrappongono le due regioni
-         if ( bBoxD.OverlapsXY( bBoxU)) {
-            PtrOwner<ISurfFlatRegion> pSfrD( CloneSurfFlatRegion( pGeomDB->GetGeoObj( vChunks[j]))) ;
-            if ( IsNull( pSfrD))
-               return false ;
-            pSfrD->Intersect( *pSfrU) ;
-            double dArea = -1 ; pSfrD->GetArea( dArea) ;
-            if ( dArea > dMaxArea) {
-               k = j ;
-               dMaxArea = dArea ;
-            }         
-         }   
-      }
-
-      if ( k == -1)
-         return false ;
-     // se è la stessa associazione individuata da vChunks allora aggiorno il vettore finale dei grezzi
-      if ( k == i)
-         vRawSurfs.emplace_back( nUpFirstId + i, vChunks[i]) ;
-      else {
-        // altrimenti unisco le regioni associate appena individuate sia per la superficie up sia per la down
-         ExeSurfFrAdd( nUpFirstId + k, nUpFirstId + i) ;
-         ExeErase( {nUpFirstId + i}) ;
-         ExeSurfFrAdd( vChunks[k], vChunks[i]) ;
-         ExeErase( {vChunks[i]}) ;      
-      }       
-   }
-
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 int
 MachMgr::SplitFlatRawPartWithMachinings( int nRawId, const INTVECTOR& vMchId)
@@ -1120,6 +872,7 @@ MachMgr::SplitFlatRawPartWithMachinings( int nRawId, const INTVECTOR& vMchId)
    BBox3d b3Raw ;
    if ( ! m_pGeomDB->GetGlobalBBox( nRawSolId, b3Raw))
       return GDB_ID_NULL ;
+   double dZmin = b3Raw.GetMin().z ;
    double dHeight = b3Raw.GetMax().z - b3Raw.GetMin().z ;
    // il colore del grezzo
    Color cCol = AQUA ;
@@ -1128,31 +881,19 @@ MachMgr::SplitFlatRawPartWithMachinings( int nRawId, const INTVECTOR& vMchId)
    Frame3d frRaw ;
    if ( ! m_pGeomDB->GetGroupGlobFrame( nRawId, frRaw))
       return GDB_ID_NULL ;
+
+  // creo la regione del grezzo a partire dal suo contorno
    // recupero il contorno
    int nOutCrvId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_OUTLINE) ;
    if ( nOutCrvId == GDB_ID_NULL)
       return GDB_ID_NULL ;
-   
-  // creo le regioni inferiore e superiore del grezzo da aggiornare con le lavorazioni
-   int nSfrDownId = GDB_ID_NULL, nSfrUpId = GDB_ID_NULL ;
-   int nSfrDownOrigId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_DOWN_REG) ;
-   int nSfrUpOrigId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_UP_REG) ;
-   if ( nSfrDownOrigId == GDB_ID_NULL  ||  nSfrUpOrigId == GDB_ID_NULL) {
-     // se le regioni del grezzo di partenza non sono definite, le creo a partire dall'outline
-      nSfrDownId = ExeCreateSurfFlatRegion( nRawId, {nOutCrvId}, nullptr) ;
-      if ( nSfrDownId == GDB_ID_NULL)
-         return GDB_ID_NULL ;
-      nSfrUpId = ExeCopyGlob( nSfrDownId, nRawId, GDB_LAST_SON) ;
-      if ( nSfrUpId == GDB_ID_NULL)
-         return GDB_ID_NULL ;
-      ExeMove( { nSfrUpId}, dHeight * Z_AX, RTY_LOC) ;
-   }
-   else {
-      nSfrDownId = ExeCopyGlob( nSfrDownOrigId, nRawId, GDB_LAST_SON) ;
-      nSfrUpId = ExeCopyGlob( nSfrUpOrigId, nRawId, GDB_LAST_SON) ;
-      if ( nSfrDownId == GDB_ID_NULL  ||  nSfrUpId == GDB_ID_NULL)
-         return GDB_ID_NULL ;
-   }
+   // creo la regione
+   INTVECTOR vCrvIds ;
+   vCrvIds.emplace_back( nOutCrvId) ;
+   int nSfrId = ExeCreateSurfFlatRegion( nRawId, vCrvIds, nullptr) ;
+   if ( nSfrId == GDB_ID_NULL)
+      return GDB_ID_NULL ;
+   m_pGeomDB->SetLevel( nSfrId, GDB_LV_TEMP) ;
 
   // se esiste il kerf, ne creo la regione
    PtrOwner<ISurfFlatRegion> pSfrKerf ;
@@ -1167,8 +908,7 @@ MachMgr::SplitFlatRawPartWithMachinings( int nRawId, const INTVECTOR& vMchId)
    }
 
   // recupero le regioni delle lavorazioni
-   INTVECTOR vMchRRegUp ;
-   INTVECTOR vMchRRegDown ;
+   INTVECTOR vMchRReg ;
    for ( auto nMchId : vMchId) {
      // recupero gruppo preview lavorazioni nella lavorazione
       int nPVGrp = m_pGeomDB->GetFirstNameInGroup( nMchId, MCH_PV) ;
@@ -1176,110 +916,94 @@ MachMgr::SplitFlatRawPartWithMachinings( int nRawId, const INTVECTOR& vMchId)
          return GDB_ID_NULL ;
      // se vuoto, cerco il rimando al preview nel pezzo
       if ( m_pGeomDB->GetGroupObjs( nPVGrp) == 0  &&
-         ! m_pGeomDB->GetInfo( nPVGrp, MCH_PV_KEY_RELOCATE, nPVGrp))
+           ! m_pGeomDB->GetInfo( nPVGrp, MCH_PV_KEY_RELOCATE, nPVGrp))
          return GDB_ID_NULL ;
      // ciclo sui percorsi utensile (CL)
       int nClId = m_pGeomDB->GetFirstGroupInGroup( nPVGrp) ;
       while ( nClId != GDB_ID_NULL) {
-        // lavorazioni per regione inferiore 
-         int nCrDownId = m_pGeomDB->GetFirstNameInGroup( nClId, MCH_PV_DOWN_RAWCUT) ;
-        // se non esiste la regione inferiore la lavorazione non è passante quindi può essere ignorata
-         if ( nCrDownId != GDB_ID_NULL) {        
-            while ( nCrDownId != GDB_ID_NULL) {
-               vMchRRegDown.emplace_back( nCrDownId) ;
-               nCrDownId = m_pGeomDB->GetNextName( nCrDownId, MCH_PV_DOWN_RAWCUT) ;
-            }
-           // lavorazioni per regione superiore
-            int nCrUpId = m_pGeomDB->GetFirstNameInGroup( nClId, MCH_PV_UP_RAWCUT) ;
-            while ( nCrUpId != GDB_ID_NULL) {
-               vMchRRegUp.emplace_back( nCrUpId) ;
-               nCrUpId = m_pGeomDB->GetNextName( nCrUpId, MCH_PV_UP_RAWCUT) ;
-            }
-         }        
+        // tagli ridotti
+         int nCrId = m_pGeomDB->GetFirstNameInGroup( nClId, MCH_PV_RRCUT) ;
+         while ( nCrId != GDB_ID_NULL) {
+            vMchRReg.emplace_back( nCrId) ;
+            nCrId = m_pGeomDB->GetNextName( nCrId, MCH_PV_RRCUT) ;
+         }
         // passo al successivo percorso utensile
          nClId = m_pGeomDB->GetNextGroup( nClId) ;
       }
    }
 
-  // sottraggo le lavorazioni alle superfici del grezzo
-   for ( auto nMchRReg : vMchRRegUp) 
-      ExeSurfFrSubtract( nSfrUpId, nMchRReg) ;   
-   for ( auto nMchRReg : vMchRRegDown)
-      ExeSurfFrSubtract( nSfrDownId, nMchRReg) ;
-
-  // classifico i chunks della regione up e down per individuare le regioni che definiscono i nuovi grezzi 
-   vector<pair<int,int>> vSurfRaws ;
-   AssociateSurfs( m_pGeomDB, nSfrUpId, nSfrDownId, vSurfRaws) ;
+  // sottraggo queste regioni a quella del grezzo
+   for ( auto nMchRReg : vMchRReg) {
+      ExeSurfFrSubtract( nSfrId, nMchRReg) ;
+   }
 
   // creo i grezzi risultanti
-    INTVECTOR vNewIds ;
-    for ( int i = 0 ; i < int( vSurfRaws.size()) ; i++) {
-
-      // aggiungo il grezzo
-       int nId = AddRawPart( vSurfRaws[i].first, vSurfRaws[i].second, dHeight, cCol) ;
-       m_pGeomDB->Erase( vSurfRaws[i].first) ;
-       m_pGeomDB->Erase( vSurfRaws[i].second) ;      
-       if ( nId == GDB_ID_NULL)
-          return GDB_ID_NULL ;
-       vNewIds.emplace_back( nId) ;
-   
-      // imposto lo stato del contorno di questo grezzo come quello del grezzo di partenza
-       int nStat = GDB_ST_ON ;
-       if ( m_pGeomDB->GetStatus( nOutCrvId, nStat)  &&  nStat == GDB_ST_OFF)
-          m_pGeomDB->SetStatus( m_pGeomDB->GetFirstNameInGroup( nId, MACH_RAW_OUTLINE), nStat) ;
-      // assegno la fase al gruppo
-       m_pGeomDB->SetInfo( nId, MACH_RAW_PHASE, m_nCurrPhase) ;
-      // se esiste il kerf uso questa curva per creare il kerf del nuovo grezzo
-       if ( ! IsNull( pSfrKerf)) {
-         // riferimento del nuovo grezzo
-          Frame3d frNewRaw ;
-          if ( ! m_pGeomDB->GetGroupGlobFrame( nId, frNewRaw))
-             return GDB_ID_NULL ;
-         // considero il nuovo kerf come la regione superiore del nuovo grezzo
-          int nSfrUpId = m_pGeomDB->GetFirstNameInGroup( nId, MACH_RAW_UP_REG) ;
-          if ( nSfrUpId == GDB_ID_NULL) 
-             return GDB_ID_NULL ;
-          PtrOwner<ISurfFlatRegion> pSfrNewKerf( CloneSurfFlatRegion( m_pGeomDB->GetGeoObj( nSfrUpId))) ;
-          if ( IsNull( pSfrNewKerf))
-             return GDB_ID_NULL ;
-         // porto nello stesso riferimento del grezzo originale
-          pSfrNewKerf->LocToLoc( frNewRaw, frRaw) ;
-         // la limito con la regione di kerf precedente ( va bene anche se fallisce)
-          pSfrNewKerf->Intersect( *pSfrKerf) ;
-         // se risultato non vuoto
-          if ( pSfrNewKerf->IsValid()) {             
-            // la porto dal riferimento del grezzo originale al riferimento di questo grezzo
-             pSfrNewKerf->LocToLoc( frRaw, frNewRaw) ;
-            // recupero il contorno esterno del chunk più grande e lo inserisco come kerf del nuovo grezzo
-             double dAreaMax = -1 ;
-             int nKMax = 0 ;
-             for ( int k = 0 ; k < pSfrNewKerf->GetChunkCount() ; k ++) {
-                PtrOwner<ISurfFlatRegion> pSfrChunk( pSfrNewKerf->CloneChunk( k)) ;
-                double dArea = -1 ; pSfrChunk->GetGrossArea( dArea) ;
-                if ( dArea > dAreaMax) {
-                   nKMax = k ;
-                   dAreaMax = dArea ;
-                }
-             }
-             PtrOwner<ICurve> pCrv( pSfrNewKerf->GetLoop( nKMax, 0)) ;
-             if ( IsNull( pCrv))
-                return GDB_ID_NULL ;
-             int nNewKerfId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nId, Release( pCrv)) ;
-             if ( nNewKerfId == GDB_ID_NULL)
-                return GDB_ID_NULL ;
-             m_pGeomDB->CopyMaterial( nKerfId, nNewKerfId) ;
-             m_pGeomDB->SetName( nNewKerfId, MACH_RAW_KERF) ;
-          }
-       }
-    }
-       
-  // cancello le regioni usate per i conti
-   m_pGeomDB->Erase( nSfrUpId) ;
-   m_pGeomDB->Erase( nSfrDownId) ;
+   // creo i nuovi grezzi
+   INTVECTOR vNewIds ;
+   int nCount ;
+   int nChunk = 0 ;
+   int nFirstLoopId = ExeExtractSurfFrChunkLoops( nSfrId, nChunk, nRawId, &nCount) ;
+   while ( nFirstLoopId != GDB_ID_NULL) {
+     // !!! in attesa di gestire i grezzi con i buchi !!!
+     // cancello le eventuali curve successive (sono i loop interni ovvero i buchi)
+      for ( int i = 1 ; i < nCount ; ++ i) {
+         m_pGeomDB->Erase( nFirstLoopId + i) ;
+      }
+     // dichiaro temporanea la curva
+      m_pGeomDB->SetLevel( nFirstLoopId, GDB_LV_TEMP) ;
+     // creo il grezzo
+      int nId = AddRawPart( nFirstLoopId, 0, dZmin, dHeight, cCol) ;
+      if ( nId == GDB_ID_NULL)
+         return GDB_ID_NULL ;
+      vNewIds.emplace_back( nId) ;
+     // imposto lo stato del contorno di questo grezzo come quello del grezzo di partenza
+      int nStat = GDB_ST_ON ;
+      if ( m_pGeomDB->GetStatus( nOutCrvId, nStat)  &&  nStat == GDB_ST_OFF)
+         m_pGeomDB->SetStatus( m_pGeomDB->GetFirstNameInGroup( nId, MACH_RAW_OUTLINE), nStat) ;
+     // assegno la fase al gruppo
+      m_pGeomDB->SetInfo( nId, MACH_RAW_PHASE, m_nCurrPhase) ;
+     // se esiste il kerf uso questa curva per creare il kerf del nuovo grezzo
+      if ( ! IsNull( pSfrKerf)) {
+        // creo la regione con la curva
+         SurfFlatRegionByContours SfrCntr ;
+         SfrCntr.AddCurve( GetCurve( m_pGeomDB->RemoveGeoObjAndErase( nFirstLoopId))) ;
+         PtrOwner<ISurfFlatRegion> pSfrNewKerf( SfrCntr.GetSurf()) ;
+         if ( IsNull( pSfrNewKerf))
+            return GDB_ID_NULL ;
+        // la limito con la regione di kerf precedente (va bene anche se fallisce)
+         pSfrNewKerf->Intersect( *pSfrKerf) ;
+        // se risultato non vuoto
+         if ( pSfrNewKerf->IsValid()) {
+            // riferimento del nuovo grezzo
+            Frame3d frNewRaw ;
+            if ( ! m_pGeomDB->GetGroupGlobFrame( nId, frNewRaw))
+               return GDB_ID_NULL ;
+           // la porto dal riferimento del grezzo originale al riferimento di questo grezzo
+            pSfrNewKerf->LocToLoc( frRaw, frNewRaw) ;
+           // la porto sulla faccia sopra del grezzo
+            pSfrNewKerf->Translate( Vector3d( 0, 0, dHeight)) ;
+           // recupero il contorno e lo inserisco come kerf del nuovo grezzo
+            PtrOwner<ICurve> pCrv( pSfrNewKerf->GetLoop( 0, 0)) ;
+            int nNewKerfId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nId, Release( pCrv)) ;
+            if ( nNewKerfId == GDB_ID_NULL)
+               return GDB_ID_NULL ;
+            m_pGeomDB->CopyMaterial( nKerfId, nNewKerfId) ;
+            m_pGeomDB->SetName( nNewKerfId, MACH_RAW_KERF) ;
+         }
+      }
+     // altrimenti la cancello
+      else
+         m_pGeomDB->Erase( nFirstLoopId) ;
+     // passo alla prossima curva
+      ++ nChunk ;
+      nFirstLoopId = ExeExtractSurfFrChunkLoops( nSfrId, nChunk, nRawId, &nCount) ;
+   }
+  // cancello la regione
+   m_pGeomDB->Erase( nSfrId) ;
   // verifico esista almeno un nuovo grezzo
-    if ( vNewIds.empty())
-       return GDB_ID_NULL ;
-   
+   if ( vNewIds.empty())
+      return GDB_ID_NULL ;
+
   // inserisco i pezzi del grezzo originale nei nuovi grezzi
    int nGroupId = m_pGeomDB->GetFirstGroupInGroup( nRawId) ;
    while ( nGroupId != GDB_ID_NULL) {
@@ -1289,31 +1013,32 @@ MachMgr::SplitFlatRawPartWithMachinings( int nRawId, const INTVECTOR& vMchId)
         // scambio con pezzo
          int nPartId = SwapRawPartPart( nNewGroupId, true) ;
         // verifico se il pezzo sta nel grezzo
-         int nLayerId = m_pGeomDB->GetFirstNameInGroup( nPartId, NST_PARTREG_LAYER) ;
+         int nLayerId = m_pGeomDB->GetFirstNameInGroup( nPartId, NST_EXT_LAYER) ;
          if ( nLayerId == GDB_ID_NULL  ||  m_pGeomDB->GetGdbType( nLayerId) != GDB_TY_GROUP)
             nLayerId = m_pGeomDB->GetFirstGroupInGroup( nPartId) ;
-        // cerco la regione del pezzo
-         int nEntId = m_pGeomDB->GetFirstInGroup( nLayerId) ;          
-         while ( nEntId != GDB_ID_NULL) {
-            int nEntGeoType = m_pGeomDB->GetGeoType( nEntId) ;
-            if ( nEntGeoType == SRF_FLATRGN)
-               break ;
-            nEntId = m_pGeomDB->GetNext( nEntId) ;
-         }
-         if ( nEntId != GDB_ID_NULL) {
-           // verifico se è interna al grezzo
+         int nEntId = m_pGeomDB->GetFirstInGroup( nLayerId) ;
+         int nEntGeoType = m_pGeomDB->GetGeoType( nEntId) ;
+         Point3d ptTest ;
+         if ( ( ( nEntGeoType & GEO_CURVE) != 0  &&  ExeMidPoint( nEntId, nNewId, ptTest))  ||
+              ( ( nEntGeoType & GEO_CURVE) == 0  &&  ExeCenterPoint( nEntId, nNewId, ptTest))) {
             int nOutCrvId = m_pGeomDB->GetFirstNameInGroup( nNewId, MACH_RAW_OUTLINE) ;
             BBox3d b3Raw ; m_pGeomDB->GetGlobalBBox( nOutCrvId, b3Raw) ;
             double dRawDiam = 0 ; b3Raw.GetDiameter( dRawDiam) ;
             BBox3d b3Part ; m_pGeomDB->GetGlobalBBox( nEntId, b3Part) ;
             double dPartDiam = 0 ; b3Part.GetDiameter( dPartDiam) ;
             if ( dRawDiam > 0.9 * dPartDiam) {
-               int nSfrUp = m_pGeomDB->GetFirstNameInGroup( nNewId, MACH_RAW_UP_REG) ;
-               if ( ! ExeSurfFrTestExternal( nSfrUp, nEntId, EPS_SMALL))
-                  break ;
-            }          
-         }         
-
+               ICurve* pCurve = GetCurve( m_pGeomDB->GetGeoObj( nOutCrvId)) ;
+               if ( pCurve != nullptr) {
+                  int nSide ;
+                  double dDist ;
+                  DistPointCurve distPC( ptTest, *pCurve) ;
+                  if ( distPC.GetDist( dDist) &&
+                       ( dDist < 100 * EPS_SMALL  ||  
+                         ( distPC.GetSideAtMinDistPoint( 0, Z_AX, nSide)  &&  nSide != MDS_RIGHT)))
+                     break ;
+               }
+            }
+         }
         // altrimenti scambio pezzo ed elimino gruppo
          nNewGroupId = SwapRawPartPart( nPartId, false) ;
          m_pGeomDB->Erase( nNewGroupId) ;
@@ -1321,5 +1046,5 @@ MachMgr::SplitFlatRawPartWithMachinings( int nRawId, const INTVECTOR& vMchId)
       nGroupId = m_pGeomDB->GetNextGroup( nGroupId) ;
    }
 
-   return vNewIds[0] ; 
+   return vNewIds[0] ;
 }

MachMgrSimulation.cpp

@@ -16,8 +16,7 @@
 #include "DllMain.h"
 #include "MachMgr.h"
 #include "MachConst.h"
-#include "SimulatorSP.h"
-#include "SimulatorMP.h"
+#include "Simulator.h"
 
 using namespace std ;
 
@@ -28,12 +27,7 @@ MachMgr::SimInit( void)
   // alloco o rialloco il simulatore
    if ( m_pSimul != nullptr)
       delete m_pSimul ;
-   if ( GetCurrMachine() == nullptr)
-      return false ;
-   if ( GetCurrMachine()->GetMultiProcess( 2))
-      m_pSimul = CreateSimulatorMP() ;
-   else
-      m_pSimul = CreateSimulatorSP() ;
+   m_pSimul = new( nothrow) Simulator ;
    if ( m_pSimul == nullptr)
       return false ;
   // lo inizializzo
@@ -189,25 +183,13 @@ MachMgr::SimOnCollision(  int nCdInd, int nObjInd, int& nErr)
 
 //----------------------------------------------------------------------------
 bool
-MachMgr::SimSetToolForVmill( const string& sTool, const string& sHead, int nExit, int nFlag, double dPar1, double dPar2,
-                             const INTVECTOR& vVmill, bool bFirst)
+MachMgr::SimSetToolForVmill( const string& sTool, const string& sHead, int nExit, const INTVECTOR& vVmill, bool bFirst)
 {
   // verifico simulatore
    if ( m_pSimul == nullptr)
       return false ;
   // imposto utensile per Vmill
-   return m_pSimul->SetToolForVmill( sTool, sHead, nExit, nFlag, dPar1, dPar2, vVmill, bFirst) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-MachMgr::SimEnableToolsForVmill( bool bEnable)
-{
-  // verifico simulatore
-   if ( m_pSimul == nullptr)
-      return false ;
-  // imposto abilitazione Vmill
-   return m_pSimul->EnableToolsForVmill( bEnable) ;
+   return m_pSimul->SetToolForVmill( sTool, sHead, nExit, vVmill, bFirst) ;
 }
 
 //----------------------------------------------------------------------------
@@ -216,18 +198,7 @@ MachMgr::SimMoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt)
 {
   // verifico simulatore
    if ( m_pSimul == nullptr)
-      return SIM_AXMV_RES_ERR ;
+      return false ;
   // lancio movimento assi
    return m_pSimul->MoveAxes( nMoveType, vAxNaEpSt) ;
 }
-
-//----------------------------------------------------------------------------
-bool
-MachMgr::SimSaveCmd( int nType, int nPar, const string& sPar)
-{
-  // verifico simulatore
-   if ( m_pSimul == nullptr)
-      return false ;
-  // salvo il comando
-   return m_pSimul->SaveCmd( nType, nPar, sPar) ;
-}

Machine.cpp

@@ -41,7 +41,6 @@ Machine::Machine( void)
    m_dExitMaxAdjust = EPS_SMALL ;
    m_dExitMaxRotAdj = 10 * EPS_ANG_SMALL ;
    m_dAngDeltaMinForHome = INFINITO ;
-   m_nMultiProcess = 0 ;
    m_nCalcTabId = GDB_ID_NULL ;
    m_nCalcHeadId = GDB_ID_NULL ;
    m_nCalcExitId = GDB_ID_NULL ;
@@ -59,8 +58,6 @@ Machine::Machine( void)
    m_nHeadRotAxes = 0 ;
    m_nHeadSpecRotAxis = -1 ;
    m_frLinAx.Reset( false) ;
-   m_frRobot.Reset( false) ;
-   m_nCalcChainType = KIN_CHAIN_NONE ;
    m_nMachineLook = MCH_LOOK_NONE ;
 }
 
@@ -144,8 +141,6 @@ Machine::Init( const string& sMachineName, const string& sMachineDir, MachMgr* p
    m_nMachineLook = ( bOk ? MCH_LOOK_ALL : MCH_LOOK_NONE) ;
   // metto tutti gli assi in posizione home
    bOk = bOk && ResetAllAxesPos() ;
-  // reset catena cinematica corrente
-   m_nCalcChainType = KIN_CHAIN_NONE ;
    return bOk ;
 }
 
@@ -214,7 +209,7 @@ Machine::AdjustAuxGeometry( const STRVECTOR& vsAux, int nLay)
 bool
 Machine::LoadMachineTable( const string& sName, const string& sParent, int nType,
                            const Point3d& ptRef1, double dCoeffX, double dCoeffY, double dCoeffZ,
-                           const STRVECTOR& vsColl, const string& sGeo, const STRVECTOR& vsAux)
+                           const string& sGeo, const STRVECTOR& vsAux)
 {
   // recupero pezzo e layer della geometria originale della tavola
    string sPart, sLay ;
@@ -253,7 +248,7 @@ Machine::LoadMachineTable( const string& sName, const string& sParent, int nType
    Table* pTab = new(nothrow) Table ;
    if ( pTab == nullptr)
       return false ;
-   pTab->Set( sName, nType, ptRef1, b3Area1, vsColl) ;
+   pTab->Set( sName, nType, ptRef1, b3Area1) ;
    m_pGeomDB->SetUserObj( nLay, pTab) ;
   // lo inserisco nel dizionario dei gruppi della macchina
    return m_mapGroups.emplace( sName, nLay).second ;
@@ -549,7 +544,7 @@ Machine::LoadMachineStdHead( const string& sName, const string& sParent, const s
    Head* pHead = new(nothrow) Head ;
    if ( pHead == nullptr)
       return false ;
-   pHead->Set( sName, MCH_HT_STD, 1, sHSet, 0, vtADir, dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl) ;
+   pHead->Set( sName, MCH_HT_STD, 1, sHSet, vtADir, dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl) ;
    m_pGeomDB->SetUserObj( nLay, pHead) ;
   // aggiorno la testa capostipite
    if ( ! AddHeadToSet( sHSet, sName))
@@ -569,7 +564,7 @@ Machine::LoadMachineStdHead( const string& sName, const string& sParent, const s
 //----------------------------------------------------------------------------
 bool
 Machine::LoadMachineMultiHead( const string& sName, const string& sParent, const string& sHSet,
-                               int nSelectType, const MUEXITVECTOR& vMuExit, const Vector3d& vtADir,
+                               const MUEXITVECTOR& vMuExit, const Vector3d& vtADir,
                                double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
                                const string& sGeo, const STRVECTOR& vsAux)
 {
@@ -598,8 +593,7 @@ Machine::LoadMachineMultiHead( const string& sName, const string& sParent, const
    Head* pHead = new(nothrow) Head ;
    if ( pHead == nullptr)
       return false ;
-   pHead->Set( sName, MCH_HT_MULTI, int( vMuExit.size()), sHSet, nSelectType,
-               vtADir, dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl) ;
+   pHead->Set( sName, MCH_HT_MULTI, int( vMuExit.size()), sHSet, vtADir, dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl) ;
    m_pGeomDB->SetUserObj( nLay, pHead) ;
   // aggiorno la testa capostipite
    if ( ! AddHeadToSet( sHSet, sName))
@@ -646,7 +640,7 @@ Machine::LoadMachineSpecialHead( const string& sName, const string& sParent, con
    Head* pHead = new(nothrow) Head ;
    if ( pHead == nullptr)
       return false ;
-   pHead->Set( sName, MCH_HT_SPECIAL, 1, sHSet, 0, vtADir, dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl) ;
+   pHead->Set( sName, MCH_HT_SPECIAL, 1, sHSet, vtADir, dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl) ;
    m_pGeomDB->SetUserObj( nLay, pHead) ;
   // aggiorno la testa capostipite
    if ( ! AddHeadToSet( sHSet, sName))
@@ -1068,8 +1062,6 @@ Machine::SetLook( int nFlag)
       nTabId = GetFirstTable() ;
    if ( nTabId == GDB_ID_NULL)
       return false ;
-  // il gruppo tavola corrente deve essere sempre visibile
-   m_pGeomDB->SetStatus( nTabId, GDB_ST_ON) ;
   // nascondo o visualizzo i fratelli e tutti i fratelli degli ascendenti della tavola
    bool bTabOnly = ( nFlag != MCH_LOOK_ALL) ;
    int nTabCurrId = nTabId ;

Machine.h

@@ -53,7 +53,7 @@ class Machine
       int  GetHeadId( const std::string& sHead) const
              { int nId = GetGroup( sHead) ;
                return ( IsHeadGroup( nId) ? nId : GDB_ID_NULL) ; }
-      int  GetExitId( const std::string& sHead, int nExit) const
+      int GetExitId( const std::string& sHead, int nExit) const
              { int nHeadId = GetHeadId( sHead) ;
                int nId = ( m_pGeomDB != nullptr ? m_pGeomDB->GetFirstNameInGroup( nHeadId, MCH_EXIT + ToString( nExit)) : GDB_ID_NULL) ;
                return ( IsExitGroup( nId) ? nId : GDB_ID_NULL) ; }
@@ -61,18 +61,14 @@ class Machine
              { int nId = GetGroup( sTcPos) ;
                return ( IsTcPosGroup( nId) ? nId : GDB_ID_NULL) ; }
       bool GetAllTablesNames( STRVECTOR& vNames) const ;
-      bool GetAllAxesNames( STRVECTOR& vNames) const ;
       bool GetAllHeadsNames( STRVECTOR& vNames) const ;
       bool GetAllTcPosNames( STRVECTOR& vNames) const ;
       int  GetFirstTable( void) const ;
       int  GetHeadExitCount( const std::string& sHead) const ;
       int  GetHeadExitPosDirAux( const std::string& sHead, int nExit, Point3d& ptPos, Vector3d& vtDir, Vector3d& vtAux) const ;
       int  GetHeadSolCh( const std::string& sHead) const ;
-      int  GetHeadSelectType(const std::string& sHead) const ;
       double GetAngDeltaMinForHome( void) const
                { return m_dAngDeltaMinForHome ; }
-      bool GetMultiProcess( int nOpt = 1) const
-               { return ( m_nMultiProcess >= nOpt) ; }
       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) ;
@@ -100,7 +96,6 @@ class Machine
       bool GetCurrTableArea1( BBox3d& b3Area1) const ;
       bool GetCurrTableDeltaRef1( Vector3d& vtDelta1) const ;
       bool GetCurrTableIsTilting( bool& bTilting, Vector3d& vtTiltingAx) const ;
-      bool GetCurrTableCollGroups( INTVECTOR& vIds) const ;
       bool SetCurrTool( const std::string& sTool, const std::string& sHead, int nExit) ;
       bool ResetCurrTool( void) ;
       int  GetCurrTool( void) const ;
@@ -125,10 +120,9 @@ class Machine
       int  GetCurrLinAxes( void) const ;
       int  GetCurrRotAxes( void) const ;
       bool GetCurrAxisName( int nInd, std::string& sAxName) const ;
-      bool GetAllCurrAxesNames( STRVECTOR& vAxName) const ;
+      bool GetAllCurrAxesName( STRVECTOR& vAxName) const ;
       bool GetCurrAxisToken( int nInd, std::string& sAxToken) const ;
-      bool GetAllCurrAxesTokens( STRVECTOR& vAxToken) const ;
-      bool GetCurrAxisType( int nInd, bool& bLinear, bool& bHead) const ;
+      bool GetAllCurrAxesToken( STRVECTOR& vAxToken) const ;
       bool GetCurrAxisMin( int nInd, double& dMin) const ;
       bool GetCurrAxisMax( int nInd, double& dMax) const ;
       bool GetCurrAxisOffset( int nInd, double& dOffset) const ;
@@ -137,20 +131,16 @@ class Machine
       bool GetAllCurrAxesHomePos( DBLVECTOR& vAxHomeVal) const ;
       const Frame3d& GetCurrLinAxesFrame( void) const
                         { return m_frLinAx ; }
-      int  GetCurrKinematicChainType( void) const
-               { return m_nCalcChainType ; }         
       bool GetAngles( const Vector3d& vtDirT, const Vector3d& vtDirA,
                       int& nStat, double& dAngA1, double& dAngB1, double& dAngA2, double& dAngB2) const ;
       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 ;
-      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,
                                  Point3d& ptNose) const ;
       bool GetTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR& vAng,
-                                bool bOverall, bool bBottom, bool bBack, Point3d& ptTip) const ;
+                                bool bBottom, bool bOverall, Point3d& ptTip) const ;
       bool GetToolDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) const ;
       bool GetAuxDirFromAngles( const DBLVECTOR& vAng, Vector3d& vtDir) const ;
       bool GetPartDirFromAngles( const Vector3d& vtPart, const DBLVECTOR& vAng, Vector3d& vtDir) const ;
@@ -202,7 +192,7 @@ class Machine
       bool AdjustAuxGeometry( const STRVECTOR& vsAux, int nLay) ;
       bool LoadMachineTable( const std::string& sName, const std::string& sParent, int nType,
                              const Point3d& ptRef1, double dCoeffX, double dCoeffY, double dCoeffZ,
-                             const STRVECTOR& vsColl, const std::string& sGeo, const STRVECTOR& vsAux) ;
+                             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,
@@ -218,7 +208,7 @@ class Machine
                                double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
                                const std::string& sGeo, const STRVECTOR& vsAux) ;
       bool LoadMachineMultiHead( const std::string& sName, const std::string& sParent, const std::string& sHSet,
-                                 int nSelectType, const MUEXITVECTOR& vMuExit, const Vector3d& vtADir,
+                                 const MUEXITVECTOR& vMuExit, const Vector3d& vtADir,
                                  double dRot1W, bool bMaxDeltaR2On1, const STROKE& Rot2Stroke, int nSolCh, const STRVECTOR& vsOthColl,
                                  const std::string& sGeo, const STRVECTOR& vsAux) ;
       bool LoadMachineSpecialHead( const std::string& sName, const std::string& sParent, const std::string& sHSet,
@@ -293,7 +283,6 @@ class Machine
       double        m_dExitMaxAdjust ;       // massimo aggiustamento uscita da geometria a descrizione cinematica
       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 ;        // flag di macchina multi-processo con stima speciale prima di generazione e simulazione ad hoc
       INTVECTOR     m_vLinkedRawParts ;      // elenco dei grezzi agganciati a gruppi della macchina
       INTVECTOR     m_vLinkedFixtures ;      // elenco dei bloccaggi agganciati a gruppi della macchina
       INTVECTOR     m_vLinkedParts ;         // elenco dei pezzi agganciati a gruppi della macchina
@@ -321,10 +310,6 @@ class Machine
       KINAXISVECTOR m_vCalcLinAx ;           // vettore assi lineari attivi per calcoli
       KINAXISVECTOR m_vCalcRotAx ;           // vettore assi rotanti attivi per calcoli
       Frame3d       m_frLinAx ;              // sistema di riferimento definito dagli assi lineari
-      Frame3d       m_frRobot ;              // sistema di riferimento canonico del robot
-      int           m_nCalcChainType ;       // tipologia testa attiva (nulla, centro di lavoro o robot)
-      Point3d       m_ptWristCen ;           // centro del polso sferico nel riferimento testa/uscita di calcolo
-      Vector3d      m_vtWristRef ;           // direzione del polso sferico nel riferimento testa/uscita di calcolo
       mutable OutStroke m_OutstrokeInfo ;    // informazioni su ultima extra corsa
       // stato di visualizzazione
       int           m_nMachineLook ;         // stato di visualizzazione della macchina
@@ -378,9 +363,8 @@ class Machine
       static int LuaEmtOnCollision( lua_State* L) ;
       static int LuaEmtSetToolForVmill( lua_State* L) ;
       static int LuaEmtAddToolForVmill( lua_State* L) ;
-      static int LuaEmtEnableToolsForVmill( lua_State* L) ;
       static int LuaEmtMoveAxes( lua_State* L) ;
-      static int LuaEmtSaveCmd( lua_State* L) ;
+
 } ;
 
 //----------------------------------------------------------------------------

MachineAxes.cpp

@@ -23,22 +23,6 @@
 
 using namespace std ;
 
-//----------------------------------------------------------------------------
-bool
-Machine::GetAllAxesNames( STRVECTOR& vNames) const
-{
-  // reset lista nomi
-   vNames.clear() ;
-  // ricerca degli assi
-   for ( const auto& snGro : m_mapGroups) {
-      if ( IsAxisGroup( snGro.second))
-         vNames.push_back( snGro.first) ;
-   }
-  // ordino alfabeticamente
-   sort( vNames.begin(), vNames.end()) ;
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 Machine::GetAxisToken( const string& sAxis, string& sToken) const

MachineCalc.cpp

@@ -71,8 +71,6 @@ Machine::SetCurrTable( const string& sTable)
       m_nCalcTabId = GDB_ID_NULL ;
       return false ;
    }
-  // il gruppo tavola corrente deve essere sempre visibile
-   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
@@ -214,31 +212,6 @@ Machine::GetCurrTableIsTilting( bool& bTilting, Vector3d& vtTiltingAx) const
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-Machine::GetCurrTableCollGroups( INTVECTOR& vIds) const
-{
-  // controllo GeomDB
-   if ( m_pGeomDB == nullptr)
-      return false ;
-  // recupero la tavola corrente
-   Table* pTab = GetTable( m_nCalcTabId) ;
-   if ( pTab == nullptr)
-      return false ;
-  // recupero stringhe con gruppi ausiliari di collisione
-   const STRVECTOR& vsColl = pTab->GetCollGroups() ;
-   for ( const auto& sColl : vsColl) {
-      string sGrp, sSub ;
-      Split( sColl, "/", true, sGrp, sSub) ;
-      int nId = GetGroup( sGrp) ;
-      if ( ! sSub.empty()  &&  nId != GDB_ID_NULL)
-        nId = m_pGeomDB->GetFirstNameInGroup( nId, sSub) ;
-      if ( nId != GDB_ID_NULL)
-         vIds.push_back( nId) ;
-   }
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 Machine::SetCurrTool( const string& sTool, const string& sHead, int nExit)
@@ -493,15 +466,14 @@ Machine::CalculateKinematicChain( void)
    m_nHeadSpecRotAxis = -1 ;
    m_vCalcLinAx.clear() ;
    m_vCalcRotAx.clear() ;
-   m_frLinAx.Reset( false) ;
-   m_frRobot.Reset( false) ;
-   m_nCalcChainType = KIN_CHAIN_NONE ;
   // recupero gli assi di tavola
    if ( m_nCalcTabId == GDB_ID_NULL)
       return false ;
    int nTParId = m_pGeomDB->GetParentId( m_nCalcTabId) ;
    if ( nTParId == GDB_ID_NULL)
       return false ;
+   m_nTabLinAxes = 0 ;
+   m_nTabRotAxes = 0 ;
    while ( IsAxisGroup( nTParId)) {
       if ( ! AddKinematicAxis( false, nTParId))
          return false ;
@@ -513,75 +485,14 @@ Machine::CalculateKinematicChain( void)
    int nHParId = m_pGeomDB->GetParentId( m_nCalcHeadId) ;
    if ( nHParId == GDB_ID_NULL)
       return false ;
+   m_nHeadLinAxes = 0 ;
+   m_nHeadRotAxes = 0 ;
    while ( IsAxisGroup( nHParId)) {
       if ( ! AddKinematicAxis( true, nHParId))
          return false ;
       nHParId = m_pGeomDB->GetParentId( nHParId) ;
    }
 
-  // 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)
-   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) {
-         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 :
    // aggiusto gli indici di ordine sulla sua catena cinematica (1-based)
    for ( int i = 0 ; i < int( m_vCalcLinAx.size()) ; ++ i) {
@@ -620,6 +531,7 @@ Machine::CalculateKinematicChain( void)
    }
 
   // verifiche sugli assi rotanti :
+   bool bOk = false ;
    // aggiusto gli indici di ordine sulla sua catena cinematica (1-based)
    for ( int i = 0 ; i < int( m_vCalcRotAx.size()) ; ++ i) {
       if ( m_vCalcRotAx[i].bHead)
@@ -629,7 +541,7 @@ Machine::CalculateKinematicChain( void)
    }
    // se 0 o 1 va bene
    if ( m_vCalcRotAx.size() <= 1)
-      ;
+      bOk = true ;
    // se 2 va bene
    else if ( m_vCalcRotAx.size() == 2) {
      // se entrambi di testa devo invertirne l'ordine
@@ -643,6 +555,7 @@ Machine::CalculateKinematicChain( void)
             m_vCalcRotAx[1].stroke.Max = min( m_vCalcRotAx[1].stroke.Max, pHead->GetRot2Stroke().Max) ;
          }
       }
+      bOk = true ;
    }
    // se 3 va bene ( uno dovrà poi avere valore assegnato)
    else if ( m_vCalcRotAx.size() == 3) {
@@ -665,13 +578,10 @@ Machine::CalculateKinematicChain( void)
             m_vCalcRotAx[n2ndHeadRotAx].stroke.Max = min( m_vCalcRotAx[n2ndHeadRotAx].stroke.Max, pHead->GetRot2Stroke().Max) ;
          }
       }
+      bOk = true ;
    }
-   // se più di 3
-   else {
-     // altrimenti non ancora gestito, quindi errore
-      LOG_ERROR( GetEMkLogger(), "Rotary Axes not manageable")
+   if ( ! bOk)
       return false ;
-   }
    // verifico esistenza eventuale asse rotante speciale di testa
    if ( m_nHeadRotAxes > 0  &&  m_nHeadLinAxes > 0) {
      // indice di posizione primo asse di testa
@@ -707,9 +617,11 @@ Machine::CalculateKinematicChain( void)
          }
       }
    }
-  // dichiaro tipo centro di lavoro
-   m_nCalcChainType = KIN_CHAIN_CENTER ;
    return true ;
+
+  // altrimenti non ancora gestito, quindi errore
+   LOG_ERROR( GetEMkLogger(), "Rotary Axes not manageable")
+   return false ;
 }
 
 //----------------------------------------------------------------------------
@@ -1281,10 +1193,6 @@ Machine::GetDirection( const Vector3d& vtDir, const DBLVECTOR& vAng, Vector3d& v
          vtNew.Rotate( m_vCalcRotAx[i-1].vtDir, vAng[i-1]) ;
    }
 
-  // nel caso di robot devo passare dal riferimento canonico robot a quello di macchina
-   if ( m_nCalcChainType == KIN_CHAIN_ROBOT)
-      vtNew.ToGlob( m_frRobot) ;
-
    return true ;
 }
 
@@ -1322,46 +1230,26 @@ Machine::GetNoseFromPositions( double dX, double dY, double dZ, const DBLVECTOR&
   // la posizione deve essere espressa rispetto allo ZERO MACCHINA
   // è 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) {
-     // 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) {
-        // se asse di testa non speciale
-         if ( m_vCalcRotAx[i].bHead  &&  i != m_nHeadSpecRotAxis)
-            ptNose.Rotate( m_vCalcRotAx[i].ptPos, m_vCalcRotAx[i].vtDir, vAng[i]) ;
-      }
-     // aggiorno posizione testa con assi lineari di testa
-      DBLVECTOR vMov( {dX, dY, dZ}) ;
-      for ( int i = 0 ; i < int( m_vCalcLinAx.size()) ; ++ i) {
-         if ( m_vCalcLinAx[i].bHead)
-            ptNose += m_vCalcLinAx[i].vtDir * vMov[i] ;
-      }
-     // eseguo rotazione eventuale asse rotante speciale di testa
-      if ( m_nHeadSpecRotAxis != -1) {
-         if ( m_nHeadSpecRotAxis < 0  ||  m_nHeadSpecRotAxis >= int( m_vCalcRotAx.size()))
-            return false ;
-         int i = m_nHeadSpecRotAxis ;
-         ptNose.Rotate( m_vCalcRotAx[i].ptPos, m_vCalcRotAx[i].vtDir, vAng[i]) ; 
-      }
+  // 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) {
+     // se asse di testa non speciale
+      if ( m_vCalcRotAx[i].bHead  &&  i != m_nHeadSpecRotAxis)
+         ptNose.Rotate( m_vCalcRotAx[i].ptPos, m_vCalcRotAx[i].vtDir, vAng[i]) ;
    }
-  // se robot
-   else if ( m_nCalcChainType == KIN_CHAIN_ROBOT) {
-     // 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) {
-        // se asse di testa
-         if ( m_vCalcRotAx[i].bHead)
-            ptNose.Rotate( m_vCalcRotAx[i].ptPos, m_vCalcRotAx[i].vtDir, vAng[i]) ;
-      }
+  // aggiorno posizione testa con assi lineari di testa
+   DBLVECTOR vMov( {dX, dY, dZ}) ;
+   for ( int i = 0 ; i < int( m_vCalcLinAx.size()) ; ++ i) {
+      if ( m_vCalcLinAx[i].bHead)
+         ptNose += m_vCalcLinAx[i].vtDir * vMov[i] ;
+   }
+  // eseguo rotazione eventuale asse rotante speciale di testa
+   if ( m_nHeadSpecRotAxis != -1) {
+      if ( m_nHeadSpecRotAxis < 0  ||  m_nHeadSpecRotAxis >= int( m_vCalcRotAx.size()))
+         return false ;
+      int i = m_nHeadSpecRotAxis ;
+      ptNose.Rotate( m_vCalcRotAx[i].ptPos, m_vCalcRotAx[i].vtDir, vAng[i]) ; 
    }
-  // altrimenti errore
-   else
-      return false ;
 
    return true ;
 }
@@ -1369,84 +1257,38 @@ Machine::GetNoseFromPositions( double dX, double dY, double dZ, const DBLVECTOR&
 //----------------------------------------------------------------------------
 bool
 Machine::GetTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR& vAng,
-                              bool bOverall, bool bBottom, bool bBack, Point3d& ptTip) const
+                              bool bOverall, bool bBottom, Point3d& ptTip) const
 {
   // la posizione deve essere espressa rispetto allo ZERO MACCHINA
   // è espressa nel riferimento di macchina (tiene conto delle sole rotazioni di testa)
-  // se bBack vero, allora è nel riferimento pezzo
 
-  // verifico dimensione vettore angoli rispetto al numero di assi rotanti
-   if ( vAng.size() < m_vCalcRotAx.size())
-      return false ;
-
-  // se centro di lavoro
-   if ( m_nCalcChainType == KIN_CHAIN_CENTER) {
-     // 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) {
-        // se asse di testa non speciale
-         if ( m_vCalcRotAx[i].bHead  &&  i != m_nHeadSpecRotAxis)
-            ptTip.Rotate( m_vCalcRotAx[i].ptPos, m_vCalcRotAx[i].vtDir, vAng[i]) ;
-      }
-     // aggiorno posizione tip utensile  con assi lineari di testa
-      DBLVECTOR vMov( {dX, dY, dZ}) ;
-      for ( int i = 0 ; i < int( m_vCalcLinAx.size()) ; ++ i) {
-         if ( m_vCalcLinAx[i].bHead)
-            ptTip += m_vCalcLinAx[i].vtDir * vMov[i] ;
-      }
-     // eseguo rotazione eventuale asse rotante speciale di testa
-      if ( m_nHeadSpecRotAxis != -1) {
-         if ( m_nHeadSpecRotAxis < 0  ||  m_nHeadSpecRotAxis >= int( m_vCalcRotAx.size()))
-            return false ;
-         int i = m_nHeadSpecRotAxis ;
-         ptTip.Rotate( m_vCalcRotAx[i].ptPos, m_vCalcRotAx[i].vtDir, vAng[i]) ; 
-      }
+  // 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) {
+     // se asse di testa non speciale
+      if ( m_vCalcRotAx[i].bHead  &&  i != m_nHeadSpecRotAxis)
+         ptTip.Rotate( m_vCalcRotAx[i].ptPos, m_vCalcRotAx[i].vtDir, vAng[i]) ;
    }
-  // se robot
-   else if ( m_nCalcChainType == KIN_CHAIN_ROBOT) {
-     // 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) {
-        // se asse di testa
-         if ( m_vCalcRotAx[i].bHead)
-            ptTip.Rotate( m_vCalcRotAx[i].ptPos, m_vCalcRotAx[i].vtDir, vAng[i]) ;
-      }
+  // aggiorno posizione tip utensile  con assi lineari di testa
+   DBLVECTOR vMov( {dX, dY, dZ}) ;
+   for ( int i = 0 ; i < int( m_vCalcLinAx.size()) ; ++ i) {
+      if ( m_vCalcLinAx[i].bHead)
+         ptTip += m_vCalcLinAx[i].vtDir * vMov[i] ;
    }
-  // altrimenti errore
-   else
-      return false ;
-
-  // nel caso di robot devo passare dal riferimento canonico robot a quello di macchina
-   if ( m_nCalcChainType == KIN_CHAIN_ROBOT)
-      ptTip.ToGlob( m_frRobot) ;
-
-  // Se richiesto nel riferimento pezzo
-   if ( bBack) {
-     // ciclo sugli assi lineari di tavola all'indietro
-      DBLVECTOR vMov( {dX, dY, dZ}) ;
-      for ( int i = int( m_vCalcLinAx.size()) ; i > 0 ; -- i) {
-         if ( ! m_vCalcLinAx[i-1].bHead)
-            ptTip += m_vCalcLinAx[i-1].vtDir * ( vMov[i-1] - m_vCalcLinAx[i-1].dHomeVal) ;
-      }
-     // ciclo sugli assi rotanti di tavola all'indietro !!! NON VERIFICATO !!!
-      for ( int i = int( m_vCalcRotAx.size()) ; i > 0 ; -- i) {
-         if ( ! m_vCalcRotAx[i-1].bHead)
-            ptTip.Rotate( m_vCalcRotAx[i-1].ptPos, m_vCalcRotAx[i-1].vtDir, -vAng[i-1]) ;
-      }
+  // eseguo rotazione eventuale asse rotante speciale di testa
+   if ( m_nHeadSpecRotAxis != -1) {
+      if ( m_nHeadSpecRotAxis < 0  ||  m_nHeadSpecRotAxis >= int( m_vCalcRotAx.size()))
+         return false ;
+      int i = m_nHeadSpecRotAxis ;
+      ptTip.Rotate( m_vCalcRotAx[i].ptPos, m_vCalcRotAx[i].vtDir, vAng[i]) ; 
    }
 
   // Se richiesto ingombro totale o punto sotto del tip utensile
    if ( bOverall  ||  bBottom) {
      // calcolo la direzione fresa
       Vector3d vtDirT ;
-      if ( bBack) {
-         if ( ! GetBackDirection( m_vtCalcDir, vAng, vtDirT))
-            return false ;
-      }
-      else {
-         if ( ! GetDirection( m_vtCalcDir, vAng, vtDirT))
-            return false ;
-      }
+      if ( ! GetDirection( m_vtCalcDir, vAng, vtDirT))
+         return false ;
      // se richiesto ingombro totale
       if ( bOverall)
          ptTip -= vtDirT * max( m_dCalcTOvLen - m_dCalcTLen, 0.) ;
@@ -1875,7 +1717,7 @@ Machine::GetCurrAxisName( int nInd, string& sAxName) const
 
 //----------------------------------------------------------------------------
 bool
-Machine::GetAllCurrAxesNames( STRVECTOR& vAxName) const
+Machine::GetAllCurrAxesName( STRVECTOR& vAxName) const
 {
    vAxName.clear() ;
    bool bOk = true ;
@@ -1924,7 +1766,7 @@ Machine::GetCurrAxisToken( int nInd, string& sAxToken) const
 
 //----------------------------------------------------------------------------
 bool
-Machine::GetAllCurrAxesTokens( STRVECTOR& vAxToken) const
+Machine::GetAllCurrAxesToken( STRVECTOR& vAxToken) const
 {
    vAxToken.clear() ;
    bool bOk = true ;
@@ -1947,25 +1789,6 @@ Machine::GetAllCurrAxesTokens( STRVECTOR& vAxToken) const
    return bOk ;
 }
 
-//----------------------------------------------------------------------------
-bool
-Machine::GetCurrAxisType( int nInd, bool& bLinear, bool& bHead) const
-{
-   int nLinAxes = int( m_vCalcLinAx.size()) ; 
-   int nRotAxes = int( m_vCalcRotAx.size()) ; 
-   if ( nInd >= 0  &&  nInd < nLinAxes) {
-      bLinear = true ;
-      bHead = m_vCalcLinAx[nInd].bHead ;
-      return true ;
-   }
-   else if ( nInd >= nLinAxes  &&  nInd < nLinAxes + nRotAxes) {
-      bLinear = false ;
-      bHead = m_vCalcRotAx[nInd-nLinAxes].bHead ;
-      return true ;
-   }
-   return false ;
-}
-
 //----------------------------------------------------------------------------
 bool
 Machine::GetCurrAxisMin( int nInd, double& dMin) const
@@ -2105,111 +1928,3 @@ Machine::GetAllCurrAxesHomePos( DBLVECTOR& vAxHomeVal) const
    }
    return bOk ;
 }
-
-//----------------------------------------------------------------------------
-bool
-Machine::GetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vector3d& vtDirA,
-                         DBLVECTOR& vAng1, DBLVECTOR& vAng2) const
-{
-  // pulisco il risultato
-   vAng1.clear() ;
-   vAng2.clear() ;
-  // porto i dati nel riferimento robot
-   Point3d ptPL = GetToLoc( ptP, m_frRobot) ;
-   Vector3d vtDirTL = GetToLoc( vtDirT, m_frRobot) ;
-   Vector3d vtDirAL = GetToLoc( vtDirA, m_frRobot) ;
-  // riferimento utensile
-   Frame3d frTool ;
-   frTool.Set( ORIG, vtDirTL, vtDirAL) ;
-  // deduco la posizione richiesta del centro del polso
-   Point3d ptCen = ptPL + m_ptWristCen.x * frTool.VersX() +
-                          m_ptWristCen.y * frTool.VersY() +
-                          ( m_dCalcTLen + m_ptWristCen.z) * frTool.VersZ() ;
-  // deduco la direzione richiesta del centro del polso
-   Vector3d vtCen = m_vtWristRef.x * frTool.VersX() +
-                    m_vtWristRef.y * frTool.VersY() +
-                    m_vtWristRef.z * frTool.VersZ() ;
-  // calcolo il primo asse rotante
-   Vector3d vtArm = ptCen - m_vCalcRotAx[0].ptPos ;
-   double dAng1 ; bool bDet1 ;
-   if ( ! X_AX.GetRotation( vtArm, m_vCalcRotAx[0].vtDir, EPS_SMALL, dAng1, bDet1)  ||  ! bDet1) {
-      LOG_ERROR( GetEMkLogger(), "Error : direction unreachable (robot)")
-      return false ;
-   }
-   vAng1.push_back( dAng1) ;
-   vAng2.push_back( dAng1) ;
-  // calcolo secondo e terzo asse rotante
-   Point3d ptR2 = m_vCalcRotAx[1].ptPos ;
-   ptR2.Rotate( m_vCalcRotAx[0].ptPos, m_vCalcRotAx[0].vtDir, dAng1) ;
-   Vector3d vtR2 = m_vCalcRotAx[1].vtDir ;
-   vtR2.Rotate( m_vCalcRotAx[0].vtDir, dAng1) ;
-   Vector3d vtR2Cen = ptCen - ( ptR2 + ( ptCen - ptR2) * vtR2 * vtR2) ; 
-   double dDistR2Cen = vtR2Cen.Len() ;
-   double dDistR2R3 = m_vCalcRotAx[2].ptPos.z - m_vCalcRotAx[1].ptPos.z ;
-   Vector3d vtR3R5 = m_vCalcRotAx[4].ptPos - m_vCalcRotAx[2].ptPos ; vtR3R5.y = 0 ;
-   double dDistR3R5 = vtR3R5.Len() ;
-   double dAngR3R5 = atan2( vtR3R5.z, vtR3R5.x) * RADTODEG ;
-   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)")
-      return false ;
-   }
-   double dAngB = acos( dCosB) * RADTODEG ;
-   double dAng2 ; bool bDet2 ;
-   if ( ! Z_AX.GetRotation( vtR2Cen, vtR2, EPS_SMALL, dAng2, bDet2)  ||  ! bDet2) {
-      LOG_ERROR( GetEMkLogger(), "Error : R2 not calculable (robot)")
-      return false ;
-   }
-   dAng2 -= dAngB ;
-   vAng1.push_back( dAng2) ;
-   vAng2.push_back( dAng2) ;
-   double dAngC = acos( dCosC) * RADTODEG ;
-   double dAng3 = dAngB + dAngC + dAngR3R5 - ANG_RIGHT ;
-   vAng1.push_back( dAng3) ;
-   vAng2.push_back( dAng3) ;
-  // calcolo i primi due assi rotanti del polso
-   Frame3d frWrist ;
-   frWrist.Set( m_vCalcRotAx[3].ptPos, m_vCalcRotAx[3].vtDir, m_vCalcRotAx[4].vtDir ^ m_vCalcRotAx[3].vtDir) ;
-   frWrist.Rotate( m_vCalcRotAx[2].ptPos, m_vCalcRotAx[2].vtDir, dAng3) ;
-   frWrist.Rotate( m_vCalcRotAx[1].ptPos, m_vCalcRotAx[1].vtDir, dAng2) ;
-   frWrist.Rotate( m_vCalcRotAx[0].ptPos, m_vCalcRotAx[0].vtDir, dAng1) ;
-   Vector3d vtCenL = GetToLoc( vtCen, frWrist) ;
-   double dAng4, dAng5 ;
-   vtCenL.ToSpherical( nullptr, &dAng5, &dAng4) ;
-   if ( dAng4 > ANG_STRAIGHT)
-      dAng4 -= ANG_FULL ;
-   if ( dAng4 > ANG_RIGHT) {
-      dAng4 -= ANG_STRAIGHT ;
-      dAng5 = -dAng5 ;
-   }
-   else if ( dAng4 < -ANG_RIGHT) {
-      dAng4 += ANG_STRAIGHT ;
-      dAng5 = -dAng5 ;
-   }
-   vAng1.push_back( dAng4) ;
-   vAng1.push_back( dAng5) ;
-   vAng2.push_back( dAng4 + ( dAng4 > EPS_ANG_ZERO ? -ANG_STRAIGHT : ANG_STRAIGHT)) ;
-   vAng2.push_back( -dAng5) ;
-  // calcolo il terzo asse rotante del polso
-   Vector3d vtR6 = m_vCalcRotAx[5].vtDir ;
-   for ( int i = 4; i >= 0 ; --i)
-      vtR6.Rotate( m_vCalcRotAx[i].vtDir, vAng1[i]) ;
-   Vector3d vtTool = m_vtCalcDir ;
-   for ( int i = 4; i >= 0 ; --i)
-      vtTool.Rotate( m_vCalcRotAx[i].vtDir, vAng1[i]) ;
-   double dAng6 ; bool bDet6 ;
-   if ( ! vtTool.GetRotation( vtDirTL, vtR6, EPS_SMALL, dAng6, bDet6)  ||  ! bDet6) {
-      Vector3d vtAux = m_vtCalcADir ;
-      for ( int i = 4; i >= 0 ; --i)
-         vtAux.Rotate( m_vCalcRotAx[i].vtDir, vAng1[i]) ;
-      if ( ! vtAux.GetRotation( vtDirAL, vtR6, EPS_SMALL, dAng6, bDet6)  ||  ! bDet6) {
-         LOG_ERROR( GetEMkLogger(), "Error : R6 not calculable (robot)")
-         return false ;      
-      }
-   }
-   vAng1.push_back( dAng6) ;
-   vAng2.push_back( dAng6 + ( dAng6 > EPS_ANG_ZERO ? -ANG_STRAIGHT : ANG_STRAIGHT)) ;
-
-   return true ;
-}

MachineHeads.cpp

@@ -98,18 +98,6 @@ Machine::GetHeadSolCh( const string& sHead) const
    return pHead->GetSolCh() ;
 }
 
-//----------------------------------------------------------------------------
-int
-Machine::GetHeadSelectType( const string& sHead) const
-{
-  // recupero testa
-   Head* pHead = GetHead( GetGroup( sHead)) ;
-   if ( pHead == nullptr)
-      return MCH_SCC_NONE ;
-  // recupero tipo di selezione delle uscite della testa
-   return pHead->GetSelectType() ;
-}
-
 //----------------------------------------------------------------------------
 bool
 Machine::LoadTool( const string& sHead, int nExit, const string& sTool)

MachineLua.cpp

@@ -1,15 +1,13 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2021
 //----------------------------------------------------------------------------
-// File : MachineLua.cpp       Data : 01.09.24          Versione : 2.6i1
+// File : MachineLua.cpp       Data : 14.10.21          Versione : 2.3j5
 // Contenuto : Implementazione gestione macchina : funzioni Lua.
 //
 //
 //
 // Modifiche : 06.05.15 DS Creazione modulo.
 //             26.04.20 DS Aggiunta gestione TcPos.
-//             05.08.24 DS Aggiunta gestione SpecialEstimate.
-//             01.09.24 DS SpecialEstimate è diventato MultiProcess.
 //
 //----------------------------------------------------------------------------
 
@@ -36,7 +34,6 @@ static const string FLD_AXISMAXROTADJ = "AxisMaxRotAdj" ;
 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_NAME = "Name" ;
 static const string FLD_PARENT = "Parent" ;
 static const string FLD_GEO = "Geo" ;
@@ -54,7 +51,6 @@ static const string FLD_STROKE = "Stroke" ;
 static const string FLD_HOME = "Home" ;
 static const string FLD_ADJUSTAUX = "AdjustAux" ;
 static const string FLD_HSET = "HSet" ;
-static const string FLD_SEL_TYPE = "SelType" ;
 static const string FLD_TDIR = "TDir" ;
 static const string FLD_ADIR = "ADir" ;
 static const string FLD_ROT1W = "Rot1W" ;
@@ -62,7 +58,6 @@ static const string FLD_MAXDELTAR2ON1 = "MaxDeltaR2OnFirst" ;
 static const string FLD_ROT2STROKE = "Rot2Stroke" ;
 static const string FLD_SOLCH = "SolCh" ;
 static const string FLD_OTHCOLL = "OthColl" ;
-static const string FLD_COLL = "Coll" ;
 
 //----------------------------------------------------------------------------
 Machine* Machine::m_pMchLua = nullptr ;
@@ -142,12 +137,8 @@ Machine::LuaInit( const string& sMachineName)
    m_LuaMgr.RegisterFunction( "EmtSetToolForVmill", Machine::LuaEmtSetToolForVmill) ;
   // registro la funzione di impostazione di utensile aggiuntivo per virtual milling in simulazione
    m_LuaMgr.RegisterFunction( "EmtAddToolForVmill", Machine::LuaEmtAddToolForVmill) ;
-  // registro la funzione per abilitare/disabilitare l'esecuzione del virtual milling
-   m_LuaMgr.RegisterFunction( "EmtEnableToolsForVmill", Machine::LuaEmtEnableToolsForVmill) ;
   // registro la funzione di movimento assi in simulazione
    m_LuaMgr.RegisterFunction( "EmtMoveAxes", Machine::LuaEmtMoveAxes) ;
-  // registro la funzione di salvataggio comandi in simulazione MP
-   m_LuaMgr.RegisterFunction( "EmtSaveCmd", Machine::LuaEmtSaveCmd) ;
 
    return true ;
 }
@@ -347,9 +338,6 @@ Machine::LuaEmtGeneral( lua_State* L)
   // lettura eventuale campo 'AngDeltaForHome' dalla tabella (default INFINITO)
    double dAngDeltaMinForHome = INFINITO ;
    LuaGetTabFieldParam( L, 1, FLD_ANGDELTAMINFORHOME, dAngDeltaMinForHome) ;
-  // lettura eventuale campo 'MultiProcess' dalla tabella (0=no, 1=si, 2=si con simulazione MP)
-   int nMultiProcess = 0 ;
-   LuaGetTabFieldParam( L, 1, FLD_MULTIPROCESS, nMultiProcess) ;
    LuaClearStack( L) ;
 
   // info
@@ -399,9 +387,6 @@ Machine::LuaEmtGeneral( lua_State* L)
   // imposto minima differenza angolare da posizione precedente per stare vivino a posizione home
    m_pMchLua->m_dAngDeltaMinForHome = dAngDeltaMinForHome ;
 
-  // imposto flag per macchina multiprocesso
-   m_pMchLua->m_nMultiProcess = nMultiProcess ;
-
    return 0 ;
 }
 
@@ -466,9 +451,6 @@ Machine::LuaEmtTable( lua_State* L)
   // lettura eventuale campo 'Scale' dalla tabella
    double vScale[3] = {1.0, 1.0, 1.0} ;
    LuaGetTabFieldParam( L, 1, FLD_SCALE, vScale) ;
-  // lettura eventuale campo 'Coll' dalla tabella
-   STRVECTOR vsColl ;
-   LuaGetTabFieldParam( L, 1, FLD_COLL, vsColl) ;
   // lettura campo 'Geo' dalla tabella
    string sGeo ;
    LuaCheckTabFieldParam( L, 1, FLD_GEO, sGeo)
@@ -486,7 +468,7 @@ Machine::LuaEmtTable( lua_State* L)
       return luaL_error( L, " Unknown Machine") ;
 
   // carico i dati della tavola
-   if ( ! m_pMchLua->LoadMachineTable( sName, sParent, nType, Ref1, vScale[0], vScale[1], vScale[2], vsColl, sGeo, vsAux))
+   if ( ! m_pMchLua->LoadMachineTable( sName, sParent, nType, Ref1, vScale[0], vScale[1], vScale[2], sGeo, vsAux))
       return luaL_error( L, " Load Machine Table failed") ;
 
   // restituisco l'indice della tavola
@@ -678,9 +660,6 @@ Machine::LuaEmtMultiHead( lua_State* L)
   // lettura campo 'HSet' dalla tabella
    string sHSet ;
    LuaCheckTabFieldParam( L, 1, FLD_HSET, sHSet)
-  // lettura eventuale campo tipo di selezione ammessa per le uscite
-   int nSelectType = MCH_SLT_FIXEDEXITS ;
-   LuaGetTabFieldParam( L, 1, FLD_SEL_TYPE, nSelectType) ;
   // lettura campo 'ExitNbr' dalla tabella
    int nExitNbr ;
    LuaCheckTabFieldParam( L, 1, FLD_EXIT_NBR, nExitNbr)
@@ -733,7 +712,7 @@ Machine::LuaEmtMultiHead( lua_State* L)
       return luaL_error( L, " Unknown Machine") ;
 
   // carico i dati della testa multipla
-   if ( ! m_pMchLua->LoadMachineMultiHead( sName, sParent, sHSet, nSelectType, vMuExit, vtADir,
+   if ( ! m_pMchLua->LoadMachineMultiHead( sName, sParent, sHSet, vMuExit, vtADir,
                                            dRot1W, bMaxDeltaR2On1, Rot2Stroke, nSolCh, vsOthColl, sGeo, vsAux))
       return luaL_error( L, " Load Machine Multi Head failed") ;
 
@@ -1451,7 +1430,7 @@ Machine::LuaEmtOnCollision( lua_State* L)
 int
 Machine::LuaEmtSetToolForVmill( lua_State* L)
 {
-  // 4 o 7 parametri : sTool, sHead, nExit, vVmill [, nFlag , dPar1, dPar2]
+  // 4 parametri : sTool, sHead, nExit, vVmill
    string sTool ;
    LuaGetParam( L, 1, sTool) ;
    string sHead ;
@@ -1460,19 +1439,12 @@ Machine::LuaEmtSetToolForVmill( lua_State* L)
    LuaGetParam( L, 3, nExit) ;
    INTVECTOR vVmill ;
    LuaGetParam( L, 4, vVmill) ;
-   int nFlag = 0 ;
-   LuaGetParam( L, 5, nFlag) ;
-   double dPar1 = 0 ;
-   LuaGetParam( L, 6, dPar1) ;
-   double dPar2 = 0 ;
-   LuaGetParam( L, 7, dPar2) ;
    LuaClearStack( L) ;
   // verifico ci sia una macchina attiva
    if ( m_pMchLua == nullptr)
       return luaL_error( L, " Unknown Machine") ;
   // imposto dati primo utensile per virtual milling in simulazione
-   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr &&
-                m_pMchLua->m_pMchMgr->SimSetToolForVmill( sTool, sHead, nExit, nFlag, dPar1, dPar2, vVmill, true)) ;
+   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimSetToolForVmill( sTool, sHead, nExit, vVmill, true)) ;
   // assegno risultato
    LuaSetParam( L, bOk) ;
    return 1 ;
@@ -1482,7 +1454,7 @@ Machine::LuaEmtSetToolForVmill( lua_State* L)
 int
 Machine::LuaEmtAddToolForVmill( lua_State* L)
 {
-  // 4 o 7 parametri : sTool, sHead, nExit, vVmill [, nFlag, dPar1, dPar2]
+  // 4 parametri : sTool, sHead, nExit, vVmill
    string sTool ;
    LuaGetParam( L, 1, sTool) ;
    string sHead ;
@@ -1491,37 +1463,12 @@ Machine::LuaEmtAddToolForVmill( lua_State* L)
    LuaGetParam( L, 3, nExit) ;
    INTVECTOR vVmill ;
    LuaGetParam( L, 4, vVmill) ;
-   int nFlag = 0 ;
-   LuaGetParam( L, 5, nFlag) ;
-   double dPar1 = 0 ;
-   LuaGetParam( L, 6, dPar1) ;
-   double dPar2 = 0 ;
-   LuaGetParam( L, 7, dPar2) ;
    LuaClearStack( L) ;
   // verifico ci sia una macchina attiva
    if ( m_pMchLua == nullptr)
       return luaL_error( L, " Unknown Machine") ;
   // imposto dati utensile aggiuntivo per virtual milling in simulazione
-   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr &&
-                m_pMchLua->m_pMchMgr->SimSetToolForVmill( sTool, sHead, nExit, nFlag, dPar1, dPar2, vVmill, false)) ;
-  // assegno risultato
-   LuaSetParam( L, bOk) ;
-   return 1 ;
-}
-
-//----------------------------------------------------------------------------
-int
-Machine::LuaEmtEnableToolsForVmill( lua_State* L)
-{
-  // 1 parametro : bEnable
-   bool bEnable = false ;
-   LuaGetParam( L, 1, bEnable) ;
-   LuaClearStack( L) ;
-  // verifico ci sia una macchina attiva
-   if ( m_pMchLua == nullptr)
-      return luaL_error( L, " Unknown Machine") ;
-  // imposto abilitazione utensili per virtual milling in simulazione
-   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimEnableToolsForVmill( bEnable)) ;
+   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimSetToolForVmill( sTool, sHead, nExit, vVmill, false)) ;
   // assegno risultato
    LuaSetParam( L, bOk) ;
    return 1 ;
@@ -1532,11 +1479,18 @@ int
 Machine::LuaEmtMoveAxes( lua_State* L)
 {
   // 4, ..., 31 parametri : nMoveType, sAx1, dPos1, dStep1 [, sAx2, dPos2, dStep2] ... [, sAx10, dPos10, dStep10]
-   int nMoveType = 0 ;
-   LuaGetParam( L, 1, nMoveType) ;
+   int nMoveType ;
+   LuaCheckParam( L, 1, nMoveType)
+   string sAx1 ;
+   LuaCheckParam( L, 2, sAx1) ;
+   double dEnd1 ;
+   LuaCheckParam( L, 3, dEnd1) ;
+   double dStep1 ;
+   LuaCheckParam( L, 4, dStep1) ;
    SAMVECTOR vAxNaEpSt ;
-   for ( int i = 0 ; i < 10 ; ++ i) {
-      int nInd = 2 + 3 * i ;
+   vAxNaEpSt.emplace_back( sAx1, dEnd1, dStep1) ;
+   for ( int i = 0 ; i < 9 ; ++ i) {
+      int nInd = 5 + 3 * i ;
       string sAxN ;
       double dEndN ;
       double dStepN ;
@@ -1556,31 +1510,7 @@ Machine::LuaEmtMoveAxes( lua_State* L)
   // assegno risultato
    if ( nRes == SIM_AXMV_RES_STOP)
       return luaL_error( L, "STOP") ;
-   else {
+   else
       LuaSetParam( L, ( nRes == SIM_AXMV_RES_OK)) ;
-      LuaSetParam( L, m_pMchLua->GetMultiProcess()) ;
-   }
-   return 2 ;
-}
-
-//----------------------------------------------------------------------------
-int
-Machine::LuaEmtSaveCmd( lua_State* L)
-{
-  //  parametri : nType, 
-   int nType = 0 ;
-   LuaGetParam( L, 1, nType) ;
-   int nPar = 0 ;
-   LuaGetParam( L, 2, nPar) ;
-   string sPar ;
-   LuaGetParam( L, 3, sPar) ;
-   LuaClearStack( L) ;
-  // verifico ci sia una macchina attiva
-   if ( m_pMchLua == nullptr)
-      return luaL_error( L, " Unknown Machine") ;
-  // salvo il comando
-   bool bOk = ( m_pMchLua->m_pMchMgr != nullptr && m_pMchLua->m_pMchMgr->SimSaveCmd( nType, nPar, sPar)) ;
-  // assegno risultato
-   LuaSetParam( L, bOk) ;
    return 1 ;
 }

MachineLuaCL.cpp

@@ -15,7 +15,6 @@
 #include "stdafx.h"
 #include "MachMgr.h"
 #include "DllMain.h"
-#include "CamData.h"
 #include "/EgtDev/Include/EXeExecutor.h"
 #include "/EgtDev/Include/EGkGeoPoint3d.h"
 #include "/EgtDev/Include/EGkCurveLine.h"

MachineStruConst.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : MachineStruConst.h      Data : 15.01.24        Versione : 2.5l6
+// File : MachineStruConst.h      Data : 25.05.15        Versione : 1.6e7
 // Contenuto : Strutture e costanti di macchina.      
 //
 //
@@ -88,18 +88,6 @@ enum MchHeadType { MCH_HT_NONE = 0,
                    MCH_HT_MULTI = 2,
                    MCH_HT_SPECIAL = 3} ;
 
-//----------------------------------------------------------------------------
-// Tipo di selezione ammessa per le uscite
-enum MchSelType { MCH_SLT_FIXEDEXITS = 0,
-                  MCH_SLT_ONEEXIT = 1,
-                  MCH_SLT_MULTIEXITS = 2} ;
-
-//----------------------------------------------------------------------------
-// Tipo della catena cinematica
-enum KinChainType { KIN_CHAIN_NONE = 0,
-                    KIN_CHAIN_CENTER = 1,
-                    KIN_CHAIN_ROBOT = 2} ;
-
 //----------------------------------------------------------------------------
 // Identificativo iniziale riferimenti di tavola
 const std::string MCH_TREF = "R" ;

Machining.cpp

@@ -148,15 +148,6 @@ Machining::PrepareToolPreview( void) const
    int nId = m_pGeomDB->CopyGlob( nHeadId, GDB_ID_NULL, nStId) ;
    m_pGeomDB->SetMode( nId, GDB_MD_STD) ;
    m_pGeomDB->SetStatus( nId, GDB_ST_OFF) ;
-  // elimino eventuali gruppi opportunamente indicati
-   int nSubId = m_pGeomDB->GetFirstGroupInGroup( nId) ;
-   while ( nSubId != GDB_ID_NULL) {
-      int nNextSubId = m_pGeomDB->GetNextGroup( nSubId) ;
-      bool bShow = true ;
-      if ( m_pGeomDB->GetInfo( nSubId, KEY_PREVIEWSHOW, bShow)  &&  ! bShow)
-         m_pGeomDB->Erase( nSubId) ;
-      nSubId = nNextSubId ;
-   }
    return ( nId != GDB_ID_NULL) ;
 }
 
@@ -176,42 +167,6 @@ Machining::RemoveToolPreview( void) const
 
 //----------------------------------------------------------------------------
 int
-Machining::GetToolPreviewStepCount( void) const
-{
-  // verifico validità gestori DB geometrico e CAM
-   if ( m_pGeomDB == nullptr  ||  m_pMchMgr == nullptr)
-      return 0 ;
-  // recupero gruppo per geometria di lavorazione (Cutter Location)
-   int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
-   if ( nClId == GDB_ID_NULL)
-      return 0 ;
-  // determino il numero di entità di tutti i sottogruppi, escludendo CLIMB e RISE
-   int nCount = 0 ;
-   int nPxId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
-   while ( nPxId != GDB_ID_NULL) {
-     // aggiungo tutte le entità del truppo
-      nCount += m_pGeomDB->GetGroupObjs( nPxId) ;
-     // tolgo le entità CLIMB
-      int nClimbId = m_pGeomDB->GetFirstNameInGroup( nPxId, MCH_CL_CLIMB) ;
-      while ( nClimbId != GDB_ID_NULL) {
-         -- nCount ;
-         nClimbId = m_pGeomDB->GetNextName( nClimbId, MCH_CL_CLIMB) ;
-      }
-     // tolgo le entità RISE
-      int nRiseId = m_pGeomDB->GetFirstNameInGroup( nPxId, MCH_CL_RISE) ;
-      while ( nRiseId != GDB_ID_NULL) {
-         -- nCount ;
-         nRiseId = m_pGeomDB->GetNextName( nRiseId, MCH_CL_RISE) ;
-      }
-     // passo al successivo sottogruppo
-      nPxId = m_pGeomDB->GetNextGroup( nPxId) ;
-   }
-
-   return nCount ;
-}
-
-//----------------------------------------------------------------------------
-static int
 GetToolPreviewNext( IGeomDB* pGeomDB, int nEntId, int nParentId)
 {
   // recupero la successiva
@@ -237,7 +192,7 @@ GetToolPreviewNext( IGeomDB* pGeomDB, int nEntId, int nParentId)
 }
 
 //----------------------------------------------------------------------------
-static int
+int
 GetToolPreviewPrev( IGeomDB* pGeomDB, int nEntId, int nParentId)
 {
   // recupero la precedente
@@ -264,7 +219,7 @@ GetToolPreviewPrev( IGeomDB* pGeomDB, int nEntId, int nParentId)
 
 //----------------------------------------------------------------------------
 int
-Machining::ToolPreview( int nEntId, int nStep) const
+Machining::ToolPreview( int nEntId, int nFlag) const
 {
   // verifico validità gestori DB geometrico e CAM
    if ( m_pGeomDB == nullptr  ||  m_pMchMgr == nullptr)
@@ -284,10 +239,10 @@ Machining::ToolPreview( int nEntId, int nStep) const
      // recupero il gruppo di appartenenza
       nParentId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
      // se richiesta successiva
-      if ( nStep > 0)
+      if ( nFlag == MCH_TPM_AFTER)
          nEntId = GetToolPreviewNext( m_pGeomDB, nEntId, nParentId) ;
      // se richiesta precedente
-      else if ( nStep < 0)
+      else if ( nFlag == MCH_TPM_BEFORE)
          nEntId = GetToolPreviewPrev( m_pGeomDB, nEntId, nParentId) ;
      // altrimenti richiesta corrente
       else
@@ -299,29 +254,11 @@ Machining::ToolPreview( int nEntId, int nStep) const
       nParentId =  m_pGeomDB->GetParentId( nEntId) ;
       if ( m_pGeomDB->GetParentId( nParentId) == nClId) {
         // se richiesta successiva
-         if ( nStep > 0) {
-            while ( nStep > 0) {
-               int nOldId = nEntId ;
-               nEntId = GetToolPreviewNext( m_pGeomDB, nEntId, nParentId) ;
-               -- nStep ;
-               if ( nEntId == GDB_ID_NULL) {
-                  nEntId = nOldId ;
-                  break ;
-               }
-            }
-         }
+         if ( nFlag == MCH_TPM_AFTER)
+            nEntId = GetToolPreviewNext( m_pGeomDB, nEntId, nParentId) ;
         // se richiesta precedente
-         else if ( nStep < 0) {
-            while ( nStep < 0) {
-               int nOldId = nEntId ;
-               nEntId = GetToolPreviewPrev( m_pGeomDB, nEntId, nParentId) ;
-               ++ nStep ;
-               if ( nEntId == GDB_ID_NULL) {
-                  nEntId = nOldId ;
-                  break ;
-               }
-            }
-         }
+         else if ( nFlag == MCH_TPM_BEFORE)
+            nEntId = GetToolPreviewPrev( m_pGeomDB, nEntId, nParentId) ;
       }
       else
          nEntId = GDB_ID_NULL ;

Machining.h

@@ -48,9 +48,8 @@ class Machining : public Operation
       bool GetStartPoint( Point3d& ptStart) const ;
       bool GetEndPoint( Point3d& ptEnd) const ;
       bool PrepareToolPreview( void) const ;
+      int  ToolPreview( int nEntId, int nFlag) const ;
       bool RemoveToolPreview( void) const ;
-      int  GetToolPreviewStepCount( void) const ;
-      int  ToolPreview( int nEntId, int nStep) const ;
 
    protected :
       Machining( void) ;

MachiningConst.h

@@ -107,7 +107,7 @@ GetMachiningTitle( int nMchType)
                                     "SurfRoughing",
                                     "SurfFinishing",
                                     "Waterjetting",
-                                    "5AxisMilling"} ;
+                                    "5axMachining"} ;
    switch ( nMchType) {
    case MT_DRILLING : return MchTitle[1] ;
    case MT_SAWING : return MchTitle[2] ;
@@ -121,7 +121,7 @@ GetMachiningTitle( int nMchType)
    case MT_SURFROUGHING : return MchTitle[10] ;
    case MT_SURFFINISHING : return MchTitle[11] ;
    case MT_WATERJETTING : return MchTitle[12] ;
-   case MT_FIVEAXISMILLING : return MchTitle[13] ;
+   case MT_5AXMACHINING : return MchTitle[13] ;
 
    }
    return MchTitle[0] ;

MachiningsMgr.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2022
 //----------------------------------------------------------------------------
-// File : MachiningsMgr.cpp       Data : 29.03.24          Versione : 2.6d1
+// File : MachiningsMgr.cpp       Data : 04.02.22          Versione : 2.4b1
 // Contenuto : Implementazione gestore database lavorazioni.
 //
 //
@@ -16,7 +16,6 @@
 //             22.06.20 DS Agg. per nuovi parametri attacco tagli di lama (MF_CURR_VER = 1010).
 //             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).
 //
 //----------------------------------------------------------------------------
 
@@ -43,7 +42,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 = 1012 ;
 const string MF_GENERAL = "[GENERAL]" ;
 const string MF_3AXCOMP = "3AXCOMP" ;
 const bool   MF_CURR_3AXCOMP = false ;
@@ -65,8 +64,6 @@ const string MF_INTSAWARCMAXSIDEANG = "INTSAWARCMAXSIDEANG" ;
 const double MF_CURR_INTSAWARCMAXSIDEANG = 45 ;
 const string MF_SPLITARCS = "SPLITARCS" ;
 const int    MF_CURR_SPLITARCS = SPLAR_NEVER ;
-const string MF_APPROX_LINTOL = "APPROX_LINTOL" ;
-const double MF_CURR_APPROX_LINTOL = 0.05 ;
 const string MF_MAXDEPTHSAFE = "MAXDEPTHSAFE" ;
 const double MF_CURR_MAXDEPTHSAFE = 2.0 ;
 
@@ -88,7 +85,6 @@ MachiningsMgr::MachiningsMgr( void)
    m_dExtSawArcMinRad = MF_CURR_EXTSAWARCMINRAD ;
    m_dIntSawArcMaxSideAng = MF_CURR_INTSAWARCMAXSIDEANG ;
    m_nSplitArcs = MF_CURR_SPLITARCS ;
-   m_dApproxLinTol = MF_CURR_APPROX_LINTOL ;
    m_dMaxDepthSafe = MF_CURR_MAXDEPTHSAFE ;
 }
 
@@ -316,8 +312,6 @@ MachiningsMgr::LoadGeneral( Scanner& TheScanner, bool& bEnd)
          bOk = FromString( sVal, m_dIntSawArcMaxSideAng) ;
       else if ( ToUpper( sKey) == MF_SPLITARCS)
          bOk = FromString( sVal, m_nSplitArcs) ;
-      else if ( ToUpper( sKey) == MF_APPROX_LINTOL)
-         bOk = FromString( sVal, m_dApproxLinTol) ;
       else if ( ToUpper( sKey) == MF_MAXDEPTHSAFE)
          bOk = FromString( sVal, m_dMaxDepthSafe) ;
       else
@@ -505,10 +499,6 @@ MachiningsMgr::SaveGeneral( Writer& TheWriter) const
       sOut = MF_MAXDEPTHSAFE + "=" + ToString( m_dMaxDepthSafe) ;
       bOk = bOk && TheWriter.OutText( sOut) ;
    }
-   if ( m_nDbVer >= 1013) {
-      sOut = MF_APPROX_LINTOL + "=" + ToString( m_dApproxLinTol) ;
-      bOk = bOk && TheWriter.OutText( sOut) ;
-   }
 
    return bOk ;
 }
@@ -1185,20 +1175,6 @@ MachiningsMgr::SetSplitArcs( int nFlag)
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-MachiningsMgr::SetApproxLinTol( double dLinTol)
-{
-  // verifico non sia inferiore al minimo
-   dLinTol = max( dLinTol, EPS_SMALL) ;
-  // se cambiato, salvo e setto modifica
-   if ( abs( dLinTol - m_dApproxLinTol) > EPS_SMALL) {
-      m_dApproxLinTol = dLinTol ;
-      m_bModified = true ;
-   }
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 MachiningsMgr::SetMaxDepthSafe( double dSafe)

MachiningsMgr.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : MachiningsMgr.h         Data : 29.03.24          Versione : 2.6d1
+// File : MachiningsMgr.h         Data : 02.06.15          Versione : 1.6f1
 // Contenuto : Dichiarazione della classe MachiningsMgr.
 //
 //
@@ -79,9 +79,6 @@ class MachiningsMgr
       bool SetSplitArcs( int nFlag) ;
       int GetSplitArcs( void) const
                 { return m_nSplitArcs ; }
-      bool SetApproxLinTol( double dLinTol) ;
-      double GetApproxLinTol( void) const
-                { return m_dApproxLinTol ; }
       bool SetMaxDepthSafe( double dSafe) ;
       double GetMaxDepthSafe( void) const
                 { return m_dMaxDepthSafe ; }
@@ -134,6 +131,5 @@ class MachiningsMgr
       double           m_dExtSawArcMinRad ;
       double           m_dIntSawArcMaxSideAng ;
       int              m_nSplitArcs ;
-      double           m_dApproxLinTol ;
       double           m_dMaxDepthSafe ;
 } ;

Milling.h

@@ -85,7 +85,7 @@ class Milling : public Machining
       bool AdjustPathDrawForSaw( int nClPathId) ;
       bool CalcPathElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double& dElev) const ;
       bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ;
-      bool GenerateMillingPv( int nPathId, const ICurveComposite* pCompo, double dRbDist, double dDepth) ;
+      bool GenerateMillingPv( int nPathId, const ICurveComposite* pCompo) ;
       bool AddStandardMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
                                double dDepth, double dElev, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable) ;
       bool AddZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dElev,
@@ -96,18 +96,15 @@ class Milling : public Machining
                              double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bPathTabsEnable, bool bPathOscEnable) ;
       bool AddSawZigZagMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
                                 double dDepth, double dElev, double dOkStep, bool bSplitArcs) ;
-      bool AddSawOneWayMilling( const ICurveComposite* pCompo, const Vector3d& vtTool,
-                                double dDepth, double dElev, double dOkStep, bool bSplitArcs) ;
       bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
-                        double dElev, double dAppr, bool bOutStart, bool bAboveStart, bool bFirst, bool bSplitArcs) ;
+                        double dElev, double dAppr, bool bOutStart, bool bAboveStart) ;
       bool AddSawBladeSideApproach( const Point3d& ptP, const Vector3d& vtAppr, const Vector3d& vtTool,
-                                    double dSafeZ, double dSawStElev, double dStElev, double dAppr,
-                                    bool bFirst, bool bSplitArcs, bool bAddInsert = false) ;
-      bool AddDirectApproach( const Point3d& ptP, bool bSplitArcs) ;
+                                    double dSafeZ, double dSawStElev, double dStElev, double dAppr) ;
+      bool AddDirectApproach( const Point3d& ptP) ;
       bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
-                       double dElev, double dAppr, bool bAboveEnd, bool bSplitArcs) ;
+                       double dElev, double dAppr, bool bAboveEnd) ;
       bool AddSawBladeSideRetract( const Point3d& ptP, const Vector3d& vtRetr, const Vector3d& vtTool,
-                                   double dSafeZ, double dSawEndElev, double dEndElev, double dAppr, bool bAddExtract = false) ;
+                                   double dSafeZ, double dSawEndElev, double dEndElev, double dAppr) ;
       bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool,
                             double dStElev, bool bInvert, const ICurveComposite* pCompo, Point3d& ptP1, Vector3d& vtDir1) const ;
       bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
@@ -124,14 +121,11 @@ class Milling : public Machining
       bool AddTabsLine( const ICurveLine* pLine, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs) ;
       bool AddTabsArc( const ICurveArc* pArc, const Vector3d& vtTool, const DBLVECTOR& vdTabs, const TabData& tdTabs) ;
       double GetRadiusForStartEndElevation( bool bExtra = true) const ;
-      bool GetSimplePointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtRetr) const ;
-      bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtRetr, double dSafeZ) const ;
+      bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, double dSafeZ) const ;
       bool GetPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool) const ;
-      bool GetPointBelowRaw( const Point3d& ptP, const Vector3d& vtTool) const ;
-      bool CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU, bool bInvertSide = false, bool bSawSpecial = false) ;
-      Vector3d CalcCorrDir( const ICurveComposite* pCompo, double dU, bool bInvertSide = false, bool bSawSpecial = false) ;
+      bool CalcAndSetCorrAuxDir( const ICurveComposite* pCompo, double dU) ;
+      Vector3d CalcCorrDir( const ICurveComposite* pCompo, double dU) ;
       bool CalcOffset( ICurveComposite* pCompo, double dSignOffs) ;
-      bool TrimExtendCurveToClosedStm( ICurveComposite* pCompo, int nCstmId, bool bInvert) ;
 
    private :
       double GetSpeed() const
@@ -187,6 +181,4 @@ class Milling : public Machining
       double        m_dCurrTabsLen ;    // lunghezza corrente lungo il percorso per tabs
       bool          m_bStartOutRaw ;    // flag forzatura inizio fuori dal grezzo
       bool          m_bEndOutRaw ;      // flag forzatura fine fuori dal grezzo
-      Vector3d      m_vtStartDir ;      // direzione iniziale del percorso in elaborazione
-      Vector3d      m_vtEndDir ;        // direzione finale del percorso in elaborazione
 } ;

Mortising.cpp

@@ -1016,7 +1016,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, m_TParams.m_dThick, 2) ;
      // la restituisco
       return Release( pCrvCompo) ;
    }
@@ -1557,7 +1557,7 @@ Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, co
    double dDelta = dElev - dDepth ;
 
   // determino se l'inizio dell'attacco è esattamente sotto il grezzo, nel qual caso ricalcolo l'elevazione
-   double dSafeZ = GetSafeZ() + GetDeltaSafeZ( vtTool) ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() + m_pMchMgr->GetDeltaSafeZ( m_TParams.m_sHead) ;
    double dStartElev = 0 ;
    Point3d ptLi = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * dDelta ;
    bool bUnderStart = GetAhPointUnderRaw( ptLi, vtTool, 0,
@@ -1570,7 +1570,7 @@ Mortising::GenerateOnePlungeCl( const Point3d& ptStart, const Point3d& ptEnd, co
    int nFirstFlag = ( bFirst ? 1 : 0) ; 
    SetFlag( nFirstFlag) ;
    Point3d ptP1 = ( nPlunge != MORTISE_PLUNGE_END ? ptStart : ptEnd) + vtTool * ( dDelta + dStartElev + dSafeZ) ;
-   int nStart = AddRapidStartOrMove( ptP1, bFirst) ;
+   int nStart = ( bFirst ? AddRapidStart( ptP1) : AddRapidMove( ptP1)) ;
    if ( nStart == GDB_ID_NULL)
       return false ;
    SetFlag( 0) ;

Operation.h

@@ -14,15 +14,15 @@
 
 #pragma once
 
-#include "MachMgr.h"
 #include "MachConst.h"
 #include "MachineStruConst.h"
-#include "CamData.h"
 #include "/EgtDev/Include/EGkPoint3d.h"
 #include "/EgtDev/Include/EGkUserObj.h"
 #include "/EgtDev/Include/EGkSelection.h"
 #include "/EgtDev/Include/EgtNumCollection.h"
+#include "/EgtDev/Include/EGkStmStandard.h"
 
+class MachMgr ;
 class CamData ;
 class ICurve ;
 class ICurveComposite ;
@@ -44,7 +44,7 @@ class Operation : public IUserObj
       virtual int  GetPhase( void) const
                       { return m_nPhase ; }
       virtual bool RemoveHome( void) ;
-      std::string  GetName( void) const ;
+      std::string GetName( void) const ;
 
    public :
       virtual int  GetType( void) const = 0 ;
@@ -62,54 +62,6 @@ class Operation : public IUserObj
                                     { return true ; }
       virtual bool               AdjustArcCenterForAxesCalc( const CamData* pCamData, Point3d& ptCen) const
                                     { return true ; }
-      virtual bool               NeedSplit( bool bSplit = true, bool bFeed = true) const
-                                    { return ( bSplit && ( m_pMchMgr == nullptr || m_pMchMgr->GetCurrIsRobot())) ; }
-      virtual double             GetMaxSplitLen( bool bSplit = true, bool bFeed = true) const
-                                    { return ( bSplit && ( m_pMchMgr == nullptr || m_pMchMgr->GetCurrIsRobot()) ? ( bFeed ? 5 : 50) : 0) ; }
-      virtual double             GetSafeZ( void) const
-                                    { if ( m_pMchMgr == nullptr  ||  m_pMchMgr->GetCurrMachiningsMgr() == nullptr)
-                                         return 100 ;               // MF_CURR_SAFEZ in MachiningsMgr
-                                      return m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ; }
-      virtual double             GetSafeAggrBottZ( void) const
-                                    { if ( m_pMchMgr == nullptr  ||  m_pMchMgr->GetCurrMachiningsMgr() == nullptr)
-                                         return 10 ;                // MF_CURR_SAFEAGGRBOTTZ in MachiningsMgr
-                                      return m_pMchMgr->GetCurrMachiningsMgr()->GetSafeAggrBottZ() ; }
-      virtual double             GetExtraLOnCutRegion( void) const
-                                    { if ( m_pMchMgr == nullptr  ||  m_pMchMgr->GetCurrMachiningsMgr() == nullptr)
-                                         return 0 ;                 // MF_CURR_EXTRALCR in MachiningsMgr
-                                      return m_pMchMgr->GetCurrMachiningsMgr()->GetExtraLOnCutRegion() ; }
-      virtual double             GetExtraROnDrillRegion( void) const
-                                    { if ( m_pMchMgr == nullptr  ||  m_pMchMgr->GetCurrMachiningsMgr() == nullptr)
-                                         return 0 ;                 // MF_CURR_EXTRARDR in MachiningsMgr
-                                      return m_pMchMgr->GetCurrMachiningsMgr()->GetExtraROnDrillRegion() ; }
-      virtual double             GetHoleDiamToler( void) const
-                                    { if ( m_pMchMgr == nullptr  ||  m_pMchMgr->GetCurrMachiningsMgr() == nullptr)
-                                         return 10 * EPS_SMALL ;    // MF_CURR_HOLEDTOL in MachiningsMgr
-                                      return m_pMchMgr->GetCurrMachiningsMgr()->GetHoleDiamToler() ; }
-      virtual double             GetExtSawArcMinRad( void) const
-                                    { if ( m_pMchMgr == nullptr  ||  m_pMchMgr->GetCurrMachiningsMgr() == nullptr)
-                                         return 200 ;               // MF_CURR_EXTSAWARCMINRAD in MachiningsMgr
-                                      return m_pMchMgr->GetCurrMachiningsMgr()->GetExtSawArcMinRad() ; }
-      virtual double             GetIntSawArcMaxSideAng( void) const
-                                    { if ( m_pMchMgr == nullptr  ||  m_pMchMgr->GetCurrMachiningsMgr() == nullptr)
-                                         return 45 ;                // MF_CURR_INTSAWARCMAXSIDEANG in MachiningsMgr
-                                      return m_pMchMgr->GetCurrMachiningsMgr()->GetIntSawArcMaxSideAng() ; }
-      virtual bool               GetSplitArcs( const Vector3d& vtTool) const
-                                    { if ( m_pMchMgr == nullptr  ||  m_pMchMgr->GetCurrIsRobot()  ||
-                                           m_pMchMgr->GetCurrMachiningsMgr() == nullptr)
-                                         return true ;
-                                      int nSplitArcs = m_pMchMgr->GetCurrMachiningsMgr()->GetSplitArcs() ;
-                                      return ( nSplitArcs == SPLAR_ALWAYS  ||
-                                               ( nSplitArcs == SPLAR_NO_XY_PLANE  &&  ! vtTool.IsZplus())  ||
-                                               ( nSplitArcs == SPLAR_GEN_PLANE  &&  vtTool.IsGeneric())) ; }
-      virtual double             GetApproxLinTol( void) const
-                                    { if ( m_pMchMgr == nullptr  ||  m_pMchMgr->GetCurrMachiningsMgr() == nullptr)
-                                         return 50 * EPS_SMALL ;    // MF_APPROX_LINTOL in MachiningsMgr
-                                      return m_pMchMgr->GetCurrMachiningsMgr()->GetApproxLinTol() ; }
-      virtual double             GetMaxDepthSafe( void) const
-                                    { if ( m_pMchMgr == nullptr  ||  m_pMchMgr->GetCurrMachiningsMgr() == nullptr)
-                                         return 2 ;                 // MF_CURR_MAXDEPTHSAFE in MachiningsMgr
-                                      return m_pMchMgr->GetCurrMachiningsMgr()->GetMaxDepthSafe() ; }
 
    protected :
       Operation( void) ;
@@ -132,16 +84,15 @@ class Operation : public IUserObj
                            const Vector3d& vtDir, double& dElev) const ;
       bool   GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad, double dLen,
                            const Vector3d& vtDir, double& dElev) const ;
-      bool   GetElevation( int nPhase, const Point3d& ptP, const Vector3d& vtTool, double dRad, double dLen, double dSafeDist,
-                           const Vector3d& vtDir, double& dElev) const ;
       bool   GetElevation( int nPhase, const Point3d& ptS, const Point3d& ptE, const Vector3d& vtTool, double dRad, double dLen,
                            const Vector3d& vtDir, double& dElev) const ;
       bool   GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
                                  double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const ;
       bool   GetUhPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
                                  double dToolLen, bool bIsSaw, double dSafeZ, const Vector3d& vtDir, double& dElev) const ;
+      bool   GetSignedDistFromStmRaw( int nPhase, const Point3d ptP, const Vector3d vtDir,
+                                      double& dDist, Vector3d& vtNorm) const ;
       bool   GetDistanceFromRawSide( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist) const ;
-      bool   GetAggrBottDistanceFromRawSide( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double dEncSafeH, double& dDist) const ;
       bool   GetMinDistanceFromRawSide( int nPhase, const Point3d& ptP, double dExpand,
                                         double& dDist, Vector3d& vtDir) const ;
       bool   GetMinDistanceFromRawSide( int nPhase, const Point3d& ptP, double dExpand,
@@ -151,14 +102,14 @@ class Operation : public IUserObj
                   { double dDummy ;
                     return GetDistanceFromRawBottom( nPhase, nPathId, dToler, dRbDist, dDummy) ; }
       bool   GetDistanceFromRawBottom( int nPhase, int nPathId, double dToler, double& dRbDist, double& dAllRbDist) const ;
+      bool   GetDistanceFromRawBottom( int nPhase, BBox3d& b3Test, double dToler, double& dRbDist, double& dAllRbDist) const ;
       bool   GetRawGlobBox( int nPhase, int nPathId, double dToler, BBox3d& b3Raw) const ;
       bool   GetRawGlobBox( int nPhase, const BBox3d& b3Test, double dToler, BBox3d& b3Raw) const ;
       bool   GetCurrRawsGlobBox( BBox3d& b3Raw) const ;
 
-      bool   AdjustCurveFromSurf( ICurveComposite* pCrvCompo, int nToolDir, int nFaceUse, const Vector3d& vtFaceUse,
-                                  double dToolThick, int nGrade = 3) ;
+      bool   AdjustCurveFromSurf( ICurveComposite* pCrvCompo, int nToolDir, int nFaceUse, double dToolThick, int nGrade = 3) ;
       bool   ApproxWithArcsIfUseful( ICurveComposite* pCompo, bool bCareTempProp = false) const ;
-      bool   ApproxWithLines( ICurveComposite* pCompo, bool bFeed = true) const ;
+      bool   ApproxWithLines( ICurveComposite* pCompo) const ;
       bool   VerifyArcs( ICurveComposite* pCompo, double dMaxAngCen = MAX_ANG_CEN) const ;
      
       bool   CalcAndSetBBox( int nClId) ;
@@ -182,21 +133,9 @@ class Operation : public IUserObj
       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   AdjustOneStartMovement( int nClPathId, int nPrevClPathId, Operation* pPrevOp, const DBLVECTOR& vAxPrev, bool bMaxZ) ;
       bool   ToolChangeNeeded( const Operation& Op1, const Operation& Op2) const ;
@@ -206,9 +145,6 @@ class Operation : public IUserObj
       bool   RemoveRise( int nClPathId = GDB_ID_NULL) ;
       bool   AddHome( void) ;
       bool   RemoveClimbRiseHome( void) ;
-      bool   AddRobotClimb( int nEntId, double dDeltaZ) ;
-      bool   CalcRobotAxesAbovePos( const Point3d& ptP, const Vector3d& vtT, const Vector3d& vtA, double dDeltaZ,
-                                    DBLVECTOR& vAx, double* pdNewDeltaZ = nullptr) const ;
       bool   CalcDeltaZForHeadRotation( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, double& dDeltaZ) const ;
       bool   GetExtraZ( const DBLVECTOR& vAx1, const Vector3d& vtTool1,
                         const DBLVECTOR& vAx2, const Vector3d& vtTool2,
@@ -219,21 +155,12 @@ 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   SpecialMoveZup( DBLVECTOR& vAx, Vector3d& vtTool, int& nFlag, int& nFlag2,  bool& bModif) ;
       bool   SpecialMoveRapid(  const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd, DBLVECTOR& vAxNew, bool& bModif) ;
 
       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 ;
 
    protected :
       int      m_nOwnerId ;       // identificativo dell'oggetto geometrico possessore
@@ -249,7 +176,6 @@ class Operation : public IUserObj
       bool SetCorrAuxDir( const Vector3d& vtDir) ;
       bool SetFeed( double dFeed) ;
       bool SetFlag( int nFlag) ;
-      bool SetFlagOnLastMove( int nFlag) ;
       bool SetFlag2( int nFlag2) ;
       bool SetIndex( int nIndex) ;
       bool GetCurrPos( Point3d& ptCurr) const
@@ -264,26 +190,12 @@ class Operation : public IUserObj
       int  AddRapidStart( const Point3d& ptP, const std::string& sName) ;
       int  AddRapidMove( const Point3d& ptP) ;
       int  AddRapidMove( const Point3d& ptP, const std::string& sName) ;
-      int  AddRapidMove( const Point3d& ptP, bool bSplit) ;
-      int  AddRapidMove( const Point3d& ptP, bool bSplit, const std::string& sName) ;
-      int  AddRapidStartOrMove( const Point3d& ptP, bool bFirst)
-               { return ( bFirst ? AddRapidStart( ptP) : AddRapidMove( ptP)) ; }
-      int  AddRapidStartOrMove( const Point3d& ptP, bool bFirst, const std::string& sName)
-               { return ( bFirst ? AddRapidStart( ptP, sName) : AddRapidMove( ptP, sName)) ; }
-      int  AddRapidStartOrMove( const Point3d& ptP, bool bFirst, bool bSplit)
-               { return ( bFirst ? AddRapidStart( ptP) : AddRapidMove( ptP, bSplit)) ; }
-      int  AddRapidStartOrMove( const Point3d& ptP, bool bFirst, bool bSplit, const std::string& sName)
-               { return ( bFirst ? AddRapidStart( ptP, sName) : AddRapidMove( ptP, bSplit, sName)) ; }
       int  AddLinearMove( const Point3d& ptP) ;
       int  AddLinearMove( const Point3d& ptP, const std::string& sName) ;
-      int  AddLinearMove( const Point3d& ptP, bool bSplit) ;
-      int  AddLinearMove( const Point3d& ptP, bool bSplit, const std::string& sName) ;
       int  AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen, const Vector3d& vtN) ;
       int  AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen, const Vector3d& vtN, const std::string& sName) ;
-      int  AddCurveMove( const ICurve* pCrv) ;
-      int  AddCurveMove( const ICurve* pCrv, const std::string& sName) ;
-      int  AddCurveMove( const ICurve* pCrv, bool bSplit) ;
-      int  AddCurveMove( const ICurve* pCrv, bool bSplit, const std::string& sName) ;
+      int  AddCurveMove( const ICurve* pCrv, bool bOnlySimple = false) ;
+      int  AddCurveMove( const ICurve* pCrv, const std::string& sName, bool bOnlySimple = false) ;
       bool ResetMoveData( void) ;
 
    protected :
@@ -309,8 +221,4 @@ inline Operation* GetOperation( IUserObj* pUserObj)
 // 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} ;
-// 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 { FACE_DOWN = 1, FACE_TOP = 2, FACE_FRONT = 3, FACE_BACK = 4, FACE_LEFT = 5, FACE_RIGHT = 6, FACE_CONT = 7} ;

OperationCL.cpp

@@ -82,18 +82,6 @@ Operation::SetFlag( int nFlag)
    return true ;
 }
 
-//----------------------------------------------------------------------------
-bool
-Operation::SetFlagOnLastMove( int nFlag)
-{
-   int nLastEntId = m_pGeomDB->GetLastInGroup( m_nPathId) ;
-   CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nLastEntId)) ;
-   if ( pCamData == nullptr)
-      return false ;
-   pCamData->SetFlag( nFlag) ;
-   return true ;
-}
-
 //----------------------------------------------------------------------------
 bool
 Operation::SetFlag2( int nFlag2)
@@ -212,46 +200,6 @@ Operation::AddRapidMove( const Point3d& ptP, const string& sName)
    return nId ;
 }
 
-//----------------------------------------------------------------------------
-int
-Operation::AddRapidMove( const Point3d& ptP, bool bSplit)
-{
-  // se non richiesta spezzatura con massima lunghezza, emissione normale
-   if ( ! NeedSplit( bSplit))
-      return AddRapidMove( ptP) ;
-  // altrimenti opportuna spezzatura
-   Point3d ptS ;
-   if ( ! GetCurrPos( ptS))
-      return GDB_ID_NULL ;
-   double dLen = Dist( ptS, ptP) ;
-   double dStep = GetMaxSplitLen( true, false) ;
-   int nStep = int( dLen / dStep + 0.999) ;
-   int nFirstId = GDB_ID_NULL ;
-   for ( int i = 1 ; i <= nStep ; ++ i) {
-      int nId = AddRapidMove( Media( ptS, ptP, i * 1.0 / nStep)) ;
-      if ( nId == GDB_ID_NULL)
-         return GDB_ID_NULL ;
-      if ( nFirstId == GDB_ID_NULL)
-         nFirstId = nId ;
-      SetFlag( 0) ;
-      SetFlag2( 0) ;
-   }
-   return nFirstId ;
-}
-
-//----------------------------------------------------------------------------
-int
-Operation::AddRapidMove( const Point3d& ptP, bool bSplit, const string& sName)
-{
-   int nFirstId = AddRapidMove( ptP, bSplit) ;
-   int nId = nFirstId ;
-   while ( nId != GDB_ID_NULL) {
-      m_pGeomDB->SetName( nId, sName) ;
-      nId = m_pGeomDB->GetNext( nId) ;
-   }
-   return nFirstId ;
-}
-
 //----------------------------------------------------------------------------
 int
 Operation::AddLinearMove( const Point3d& ptP)
@@ -310,44 +258,6 @@ Operation::AddLinearMove( const Point3d& ptP, const string& sName)
    return nId ;
 }
 
-//----------------------------------------------------------------------------
-int
-Operation::AddLinearMove( const Point3d& ptP, bool bSplit)
-{
-  // se non richiesta spezzatura con massima lunghezza, emissione normale
-   if ( ! NeedSplit( bSplit))
-      return AddLinearMove( ptP) ;
-  // altrimenti opportuna spezzatura
-   Point3d ptS ;
-   if ( ! GetCurrPos( ptS))
-      return GDB_ID_NULL ;
-   double dLen = Dist( ptS, ptP) ;
-   double dStep = GetMaxSplitLen( true, true) ;
-   int nStep = int( dLen / dStep + 0.999) ;
-   int nFirstId = GDB_ID_NULL ;
-   for ( int i = 1 ; i <= nStep ; ++ i) {
-      int nId = AddLinearMove( Media( ptS, ptP, i * 1.0 / nStep)) ;
-      if ( nId == GDB_ID_NULL)
-         return GDB_ID_NULL ;
-      if ( nFirstId == GDB_ID_NULL)
-         nFirstId = nId ;
-   }
-   return nFirstId ;
-}
-
-//----------------------------------------------------------------------------
-int
-Operation::AddLinearMove( const Point3d& ptP, bool bSplit, const string& sName)
-{
-   int nFirstId = AddLinearMove( ptP, bSplit) ;
-   int nId = nFirstId ;
-   while ( nId != GDB_ID_NULL) {
-      m_pGeomDB->SetName( nId, sName) ;
-      nId = m_pGeomDB->GetNext( nId) ;
-   }
-   return nFirstId ;
-}
-
 //----------------------------------------------------------------------------
 int
 Operation::AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen, const Vector3d& vtN)
@@ -424,7 +334,7 @@ Operation::AddArcMove( const Point3d& ptP, const Point3d& ptCen, double dAngCen,
 
 //----------------------------------------------------------------------------
 int
-Operation::AddCurveMove( const ICurve* pCrv)
+Operation::AddCurveMove( const ICurve* pCrv, bool bOnlySimple)
 {
   // verifico che la curva esista
    if ( pCrv == nullptr)
@@ -445,8 +355,8 @@ Operation::AddCurveMove( const ICurve* pCrv)
       pArc->GetEndPoint( ptP3) ;
       return AddArcMove( ptP3, ptCen, dAngCen, vtN) ;
    }
-  // se arco o curva composita
-   else if ( pCrv->GetType() == CRV_ARC  ||  pCrv->GetType() == CRV_COMPO) {
+  // se ammesse curve composite
+   else if ( ! bOnlySimple) {
      // in ogni caso, converto in archi e rette
       PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
       if ( ! pCompo->AddCurve( *pCrv))
@@ -485,43 +395,16 @@ Operation::AddCurveMove( const ICurve* pCrv)
       }
       return nFirstId ;
    }
-  // altre curve non ammesse
+  // altrimenti
    else
       return GDB_ID_NULL ;
 }
 
 //----------------------------------------------------------------------------
 int
-Operation::AddCurveMove( const ICurve* pCrv, const string& sName)
+Operation::AddCurveMove( const ICurve* pCrv, const string& sName, bool bOnlySimple)
 {
-   int nFirstId = AddCurveMove( pCrv) ;
-   int nId = nFirstId ;
-   while ( nId != GDB_ID_NULL) {
-      m_pGeomDB->SetName( nId, sName) ;
-      nId = m_pGeomDB->GetNext( nId) ;
-   }
-   return nFirstId ;
-}
-
-//----------------------------------------------------------------------------
-int
-Operation::AddCurveMove( const ICurve* pCrv, bool bSplit)
-{
-  // se non richiesta spezzatura, emissione normale
-   if ( ! bSplit)
-      return AddCurveMove( pCrv) ;
-  // altrimenti opportuna spezzatura
-   PtrOwner<ICurveComposite> pCompo ;
-   if ( ! pCompo.Set( ConvertCurveToComposite( pCrv->Clone()))  ||  ! ApproxWithLines( pCompo))
-      return false ;
-   return AddCurveMove( pCompo) ;          
-}
-
-//----------------------------------------------------------------------------
-int
-Operation::AddCurveMove( const ICurve* pCrv, bool bSplit, const string& sName)
-{
-   int nFirstId = AddCurveMove( pCrv, bSplit) ;
+   int nFirstId = AddCurveMove( pCrv, bOnlySimple) ;
    int nId = nFirstId ;
    while ( nId != GDB_ID_NULL) {
       m_pGeomDB->SetName( nId, sName) ;

OperationConst.h

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2017-2024
+//  EgalTech 2017-2019
 //----------------------------------------------------------------------------
-// File : OperationConst.h           Data : 22.05.24        Versione : 2.6e5
+// File : OperationConst.h           Data : 08.07.19        Versione : 2.1g2
 // Contenuto : Costanti per le operazioni.      
 //
 //
@@ -9,7 +9,6 @@
 // Modifiche : 17.08.17 DS Creazione modulo.
 //             25.05.19 DS Aggiunte SurfRoughing e SurfFinishing.
 //             25.05.19 DS Aggiunta WaterJetting.
-//             22.05.24 DS Aggiunta FiveAxisMilling.
 //
 //----------------------------------------------------------------------------
 
@@ -33,8 +32,7 @@ static const std::string s_OpeClass[] = {"",
                                          "EMkChiseling",
                                          "EMkSurfRoughing",
                                          "EMkSurfFinishing",
-                                         "EMkWaterJetting",
-                                         "EMkFiveAxisMilling"} ;
+                                         "EMkWaterJetting"} ;
 
 //----------------------------------------------------------------------------
 // Dal tipo numerico restituisce la classe della operazione
@@ -55,7 +53,6 @@ GetOperationClass( int nOpeType)
    case OPER_SURFROUGHING : return s_OpeClass[11] ;
    case OPER_SURFFINISHING : return s_OpeClass[12] ;
    case OPER_WATERJETTING : return s_OpeClass[13] ;
-   case OPER_FIVEAXISMILLING : return s_OpeClass[14] ;
    }
    return s_OpeClass[0] ;
 }
@@ -91,8 +88,6 @@ GetOperationType( const std::string& sOpeClass)
       return OPER_SURFFINISHING ;
    else if ( sOpeClass == s_OpeClass[13])
       return OPER_WATERJETTING ;
-   else if ( sOpeClass == s_OpeClass[14])
-      return OPER_FIVEAXISMILLING ;
    else
       return OPER_NULL ;
-}
+}

OutputConst.h

@@ -103,9 +103,6 @@ static const std::string GVAR_R1 = ".R1" ;               // (num)      valore de
 static const std::string GVAR_R2 = ".R2" ;               // (num)      valore del secondo asse rotante
 static const std::string GVAR_R3 = ".R3" ;               // (num)      valore del terzo asse rotante
 static const std::string GVAR_R4 = ".R4" ;               // (num)      valore del quarto asse rotante
-static const std::string GVAR_R5 = ".R5" ;               // (num)      valore del quinto asse rotante
-static const std::string GVAR_R6 = ".R6" ;               // (num)      valore del sesto asse rotante
-static const std::string GVAR_R7 = ".R7" ;               // (num)      valore del settimo asse rotante
 static const std::string GVAR_C1 = ".C1" ;               // (num)      valore del primo asse lineare per centro arco
 static const std::string GVAR_C2 = ".C2" ;               // (num)      valore del secondo asse lineare per centro arco
 static const std::string GVAR_C3 = ".C3" ;               // (num)      valore del terzo asse lineare per centro arco
@@ -121,20 +118,6 @@ static const std::string GVAR_R1P = ".R1p" ;             // (num)      valore pr
 static const std::string GVAR_R2P = ".R2p" ;             // (num)      valore precedente del secondo asse rotante
 static const std::string GVAR_R3P = ".R3p" ;             // (num)      valore precedente del terzo asse rotante
 static const std::string GVAR_R4P = ".R4p" ;             // (num)      valore precedente del quarto asse rotante
-static const std::string GVAR_R5P = ".R5p" ;             // (num)      valore precedente del quinto asse rotante
-static const std::string GVAR_R6P = ".R6p" ;             // (num)      valore precedente del sesto asse rotante
-static const std::string GVAR_R7P = ".R7p" ;             // (num)      valore precedente del settimo asse rotante
-static const std::string GVAR_MOVESUCC = ".MOVESUCC" ;   // (int)      tipo del movimento successivo (0,1,2,3)
-static const std::string GVAR_L1S = ".L1s" ;             // (num)      valore successivo del primo asse lineare
-static const std::string GVAR_L2S = ".L2s" ;             // (num)      valore successivo del secondo asse lineare
-static const std::string GVAR_L3S = ".L3s" ;             // (num)      valore successivo del terzo asse lineare
-static const std::string GVAR_R1S = ".R1s" ;             // (num)      valore successivo del primo asse rotante
-static const std::string GVAR_R2S = ".R2s" ;             // (num)      valore successivo del secondo asse rotante
-static const std::string GVAR_R3S = ".R3s" ;             // (num)      valore successivo del terzo asse rotante
-static const std::string GVAR_R4S = ".R4s" ;             // (num)      valore successivo del quarto asse rotante
-static const std::string GVAR_R5S = ".R5s" ;             // (num)      valore successivo del quinto asse rotante
-static const std::string GVAR_R6S = ".R6s" ;             // (num)      valore successivo del sesto asse rotante
-static const std::string GVAR_R7S = ".R7s" ;             // (num)      valore successivo del settimo asse rotante
 static const std::string GVAR_L1T = ".L1t" ;             // (string)   token del primo asse lineare
 static const std::string GVAR_L2T = ".L2t" ;             // (string)   token del secondo asse lineare
 static const std::string GVAR_L3T = ".L3t" ;             // (string)   token del terzo asse lineare
@@ -142,9 +125,6 @@ static const std::string GVAR_R1T = ".R1t" ;             // (string)   token del
 static const std::string GVAR_R2T = ".R2t" ;             // (string)   token del secondo asse rotante
 static const std::string GVAR_R3T = ".R3t" ;             // (string)   token del terzo asse rotante
 static const std::string GVAR_R4T = ".R4t" ;             // (string)   token del quarto asse rotante
-static const std::string GVAR_R5T = ".R5t" ;             // (string)   token del quinto asse rotante
-static const std::string GVAR_R6T = ".R6t" ;             // (string)   token del sesto asse rotante
-static const std::string GVAR_R7T = ".R7t" ;             // (string)   token del settimo asse rotante
 static const std::string GVAR_C1T = ".C1t" ;             // (string)   token del primo asse lineare per centro arco
 static const std::string GVAR_C2T = ".C2t" ;             // (string)   token del secondo asse lineare per centro arco
 static const std::string GVAR_C3T = ".C3t" ;             // (string)   token del terzo asse lineare per centro arco
@@ -159,9 +139,6 @@ static const std::string GVAR_R1N = ".R1n" ;             // (string)   nome del
 static const std::string GVAR_R2N = ".R2n" ;             // (string)   nome del secondo asse rotante
 static const std::string GVAR_R3N = ".R3n" ;             // (string)   nome del terzo asse rotante
 static const std::string GVAR_R4N = ".R4n" ;             // (string)   nome del quarto asse rotante
-static const std::string GVAR_R5N = ".R5n" ;             // (string)   nome del quinto asse rotante
-static const std::string GVAR_R6N = ".R6n" ;             // (string)   nome del sesto asse rotante
-static const std::string GVAR_R7N = ".R7n" ;             // (string)   nome del settimo asse rotante
 static const std::string GVAR_MASK = ".MASK" ;           // (int)      mask associato ai movimenti in rapido
 static const std::string GVAR_FLAG = ".FLAG" ;           // (int)      flag associato ad ogni movimento
 static const std::string GVAR_FLAG2 = ".FLAG2" ;         // (int)      secondo flag associato ad ogni movimento
@@ -184,7 +161,6 @@ 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_MPSIM = ".MPSIM" ;         // (bool)     flag simulazione multiprocesso
 // Funzioni generazione
 static const std::string ON_START = "OnStart" ;
 static const std::string ON_END = "OnEnd" ;
@@ -230,8 +206,6 @@ static const std::string ON_ESTIM_RAPID = "OnEstimRapid" ;
 static const std::string ON_ESTIM_LINEAR = "OnEstimLinear" ;
 static const std::string ON_ESTIM_ARC = "OnEstimArc" ;
 // Funzioni simulazione
-static const std::string ON_SIMUL_INIT = "OnSimulInit" ;
-static const std::string ON_SIMUL_EXIT = "OnSimulExit" ;
 static const std::string ON_SIMUL_START = "OnSimulStart" ;
 static const std::string ON_SIMUL_END = "OnSimulEnd" ;
 static const std::string ON_SIMUL_DISPOSITION_STARTING = "OnSimulDispositionStarting" ;
@@ -253,150 +227,64 @@ static const std::string ON_RESET_MACHINE = "OnResetMachine" ;
 
 //----------------------------------------------------------------------------
 inline std::string
-GetGlobVarAxisValue( int nAx, const std::string& sVar = GLOB_VAR, bool bIsRobot = false)
+GetGlobVarAxisValue( int nAx, const std::string& sVar = GLOB_VAR)
 {
-   if ( ! bIsRobot) {
-      switch ( nAx) {
-      case 1 : return ( sVar + GVAR_L1) ;
-      case 2 : return ( sVar + GVAR_L2) ;
-      case 3 : return ( sVar + GVAR_L3) ;
-      case 4 : return ( sVar + GVAR_R1) ;
-      case 5 : return ( sVar + GVAR_R2) ;
-      case 6 : return ( sVar + GVAR_R3) ;
-      case 7 : return ( sVar + GVAR_R4) ;
-      default : return "" ;
-      }  
-   }
-   else {
-      switch ( nAx) {
-      case 1 : return ( sVar + GVAR_R1) ;
-      case 2 : return ( sVar + GVAR_R2) ;
-      case 3 : return ( sVar + GVAR_R3) ;
-      case 4 : return ( sVar + GVAR_R4) ;
-      case 5 : return ( sVar + GVAR_R5) ;
-      case 6 : return ( sVar + GVAR_R6) ;
-      case 7 : return ( sVar + GVAR_R7) ;
-      default : return "" ;
-      }  
-   }
+   switch ( nAx) {
+   case 1 : return ( sVar + GVAR_L1) ;
+   case 2 : return ( sVar + GVAR_L2) ;
+   case 3 : return ( sVar + GVAR_L3) ;
+   case 4 : return ( sVar + GVAR_R1) ;
+   case 5 : return ( sVar + GVAR_R2) ;
+   case 6 : return ( sVar + GVAR_R3) ;
+   case 7 : return ( sVar + GVAR_R4) ;
+   default : return "" ;
+   }  
 }
 
 //----------------------------------------------------------------------------
 inline std::string
-GetGlobVarAxisPrev( int nAx, const std::string& sVar = GLOB_VAR, bool bIsRobot = false)
+GetGlobVarAxisPrev( int nAx, const std::string& sVar = GLOB_VAR)
 {
-   if ( ! bIsRobot) {
-      switch ( nAx) {
-      case 1 : return ( sVar + GVAR_L1P) ;
-      case 2 : return ( sVar + GVAR_L2P) ;
-      case 3 : return ( sVar + GVAR_L3P) ;
-      case 4 : return ( sVar + GVAR_R1P) ;
-      case 5 : return ( sVar + GVAR_R2P) ;
-      case 6 : return ( sVar + GVAR_R3P) ;
-      case 7 : return ( sVar + GVAR_R4P) ;
-      default : return "" ;
-      }  
-   }
-   else {
-      switch ( nAx) {
-      case 1 : return ( sVar + GVAR_R1P) ;
-      case 2 : return ( sVar + GVAR_R2P) ;
-      case 3 : return ( sVar + GVAR_R3P) ;
-      case 4 : return ( sVar + GVAR_R4P) ;
-      case 5 : return ( sVar + GVAR_R5P) ;
-      case 6 : return ( sVar + GVAR_R6P) ;
-      case 7 : return ( sVar + GVAR_R7P) ;
-      default : return "" ;
-      }  
-   }
+   switch ( nAx) {
+   case 1 : return ( sVar + GVAR_L1P) ;
+   case 2 : return ( sVar + GVAR_L2P) ;
+   case 3 : return ( sVar + GVAR_L3P) ;
+   case 4 : return ( sVar + GVAR_R1P) ;
+   case 5 : return ( sVar + GVAR_R2P) ;
+   case 6 : return ( sVar + GVAR_R3P) ;
+   case 7 : return ( sVar + GVAR_R4P) ;
+   default : return "" ;
+   }  
 }
 
 //----------------------------------------------------------------------------
 inline std::string
-GetGlobVarAxisNext( int nAx, const std::string& sVar = GLOB_VAR, bool bIsRobot = false)
+GetGlobVarAxisToken( int nAx)
 {
-   if ( ! bIsRobot) {
-      switch ( nAx) {
-      case 1 : return ( sVar + GVAR_L1S) ;
-      case 2 : return ( sVar + GVAR_L2S) ;
-      case 3 : return ( sVar + GVAR_L3S) ;
-      case 4 : return ( sVar + GVAR_R1S) ;
-      case 5 : return ( sVar + GVAR_R2S) ;
-      case 6 : return ( sVar + GVAR_R3S) ;
-      case 7 : return ( sVar + GVAR_R4S) ;
-      default : return "" ;
-      }  
-   }
-   else {
-      switch ( nAx) {
-      case 1 : return ( sVar + GVAR_R1S) ;
-      case 2 : return ( sVar + GVAR_R2S) ;
-      case 3 : return ( sVar + GVAR_R3S) ;
-      case 4 : return ( sVar + GVAR_R4S) ;
-      case 5 : return ( sVar + GVAR_R5S) ;
-      case 6 : return ( sVar + GVAR_R6S) ;
-      case 7 : return ( sVar + GVAR_R7S) ;
-      default : return "" ;
-      }  
-   }
+   switch ( nAx) {
+   case 1 : return ( GLOB_VAR + GVAR_L1T) ;
+   case 2 : return ( GLOB_VAR + GVAR_L2T) ;
+   case 3 : return ( GLOB_VAR + GVAR_L3T) ;
+   case 4 : return ( GLOB_VAR + GVAR_R1T) ;
+   case 5 : return ( GLOB_VAR + GVAR_R2T) ;
+   case 6 : return ( GLOB_VAR + GVAR_R3T) ;
+   case 7 : return ( GLOB_VAR + GVAR_R4T) ;
+   default : return "" ;
+   }  
 }
 
 //----------------------------------------------------------------------------
 inline std::string
-GetGlobVarAxisToken( int nAx, bool bIsRobot = false)
+GetGlobVarAxisName( int nAx)
 {
-   if ( ! bIsRobot) {
-      switch ( nAx) {
-      case 1 : return ( GLOB_VAR + GVAR_L1T) ;
-      case 2 : return ( GLOB_VAR + GVAR_L2T) ;
-      case 3 : return ( GLOB_VAR + GVAR_L3T) ;
-      case 4 : return ( GLOB_VAR + GVAR_R1T) ;
-      case 5 : return ( GLOB_VAR + GVAR_R2T) ;
-      case 6 : return ( GLOB_VAR + GVAR_R3T) ;
-      case 7 : return ( GLOB_VAR + GVAR_R4T) ;
-      default : return "" ;
-      }
-   }
-   else {
-      switch ( nAx) {
-      case 1 : return ( GLOB_VAR + GVAR_R1T) ;
-      case 2 : return ( GLOB_VAR + GVAR_R2T) ;
-      case 3 : return ( GLOB_VAR + GVAR_R3T) ;
-      case 4 : return ( GLOB_VAR + GVAR_R4T) ;
-      case 5 : return ( GLOB_VAR + GVAR_R5T) ;
-      case 6 : return ( GLOB_VAR + GVAR_R6T) ;
-      case 7 : return ( GLOB_VAR + GVAR_R7T) ;
-      default : return "" ;
-      }
-   }
-}
-
-//----------------------------------------------------------------------------
-inline std::string
-GetGlobVarAxisName( int nAx, bool bIsRobot = false)
-{
-   if ( ! bIsRobot) {
-      switch ( nAx) {
-      case 1 : return ( GLOB_VAR + GVAR_L1N) ;
-      case 2 : return ( GLOB_VAR + GVAR_L2N) ;
-      case 3 : return ( GLOB_VAR + GVAR_L3N) ;
-      case 4 : return ( GLOB_VAR + GVAR_R1N) ;
-      case 5 : return ( GLOB_VAR + GVAR_R2N) ;
-      case 6 : return ( GLOB_VAR + GVAR_R3N) ;
-      case 7 : return ( GLOB_VAR + GVAR_R4N) ;
-      default : return "" ;
-      } 
-   }
-   else {
-      switch ( nAx) {
-      case 1 : return ( GLOB_VAR + GVAR_R1N) ;
-      case 2 : return ( GLOB_VAR + GVAR_R2N) ;
-      case 3 : return ( GLOB_VAR + GVAR_R3N) ;
-      case 4 : return ( GLOB_VAR + GVAR_R4N) ;
-      case 5 : return ( GLOB_VAR + GVAR_R5N) ;
-      case 6 : return ( GLOB_VAR + GVAR_R6N) ;
-      case 7 : return ( GLOB_VAR + GVAR_R7N) ;
-      default : return "" ;
-      } 
-   }
+   switch ( nAx) {
+   case 1 : return ( GLOB_VAR + GVAR_L1N) ;
+   case 2 : return ( GLOB_VAR + GVAR_L2N) ;
+   case 3 : return ( GLOB_VAR + GVAR_L3N) ;
+   case 4 : return ( GLOB_VAR + GVAR_R1N) ;
+   case 5 : return ( GLOB_VAR + GVAR_R2N) ;
+   case 6 : return ( GLOB_VAR + GVAR_R3N) ;
+   case 7 : return ( GLOB_VAR + GVAR_R4N) ;
+   default : return "" ;
+   }  
 }

Pocketing.h

@@ -19,6 +19,9 @@
 #include "/EgtDev/Include/EGkCurveComposite.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
+#include "/EgtDev/Include/EGkSurfFlatRegion.h"
+#include "/EgtDev/Include/EGkSurfTriMesh.h"
+#include "/EgtDev/Include/EGkCurveArc.h"
 
 //----------------------------------------------------------------------------
 class Pocketing : public Machining
@@ -67,81 +70,195 @@ class Pocketing : public Machining
 
    private :
       bool VerifyGeometry( SelData Id, int& nSubs, int& nType) ;
-      bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
+      bool GetCurvesAndPartialVolume( SelData Id, ICURVEPLIST& lstPC, ISurfTriMesh* pStmTmp, Vector3d& vtN) ;
+      bool GetForcedClosed( void) ;
       bool SetCurveAllTempProp( int nCrvId, bool bForcedClose, ICurve* pCurve, bool* pbSomeOpen = nullptr) ;
       bool ResetCurveAllTempProp( ICurve* pCurve) ;
       bool Chain( int nGrpDestId) ;
       bool ProcessPath( int nPathId, int nPvId, int nClId) ;
       bool CalcRegionElevation( const ICurveComposite* pCompo, const Vector3d& vtTool, double dDepth, double dRad, double dLen, double& dElev) const ;
       bool VerifyPathFromBottom( const ICurveComposite* pCompo, const Vector3d& vtTool) ;
-      bool GeneratePocketingPv( int nPathId, const ICurveComposite* pCompo) ;
-      bool AddZigZag( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
-                      double dDepth, double dElev, double dOkStep, bool bSplitArcs, int nPathId) ;
-      bool CalcZigZag( const ICurveComposite* pOffs, ICRVCOMPOPOVECTOR& vpCrvs) ;
-      bool OptimizedZigZag( int nPathId, const Vector3d& vtTool, double dDepth, double dSafeZ,
-                            Frame3d& frPocket, bool& bOptimizedZigZag, ICRVCOMPOPOVECTOR& vpCrvs, double& dOffs) ;
+      bool GeneratePocketingPv( int nPathId, const ISurfTriMesh* pStm_PartVolume) ;
+      bool CheckSimpleOverlap( const ICurve* pCrv, const ICurveComposite* pCrvOri, int& nStat, double dToll) ;
+      bool CalcDepth( const int nId, const Vector3d& vtExtr, double dThick, double& dDepth) ;
+      bool ChainCurveArray( const SELVECTOR vInds, ICURVEPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvCompo) ;
+      bool CreateStmForIntersection( ISurfTriMesh* pStm, ICRVCOMPOPOVECTOR& vCrvCompo, const Vector3d& vtN) ;
+      bool CalcOffsExtensionsForCurves( const ICurveComposite* pCrvCompo, const Vector3d& vtN, double& dExt) ;
+      bool GetExtendedLoopToFitStmVolume( ICurveComposite* pCrvLoop, const double& dExt, const Vector3d& vtN) ;
+      bool GetCurrentPart( const Point3d& ptInside, ISurfTriMesh* pStmPart) ;
+      bool SetPocketingVolume( const Point3d& ptInside, ISurfTriMesh* pStm) ;
+      bool AdjustPocketingSideForVolumePart( ISurfTriMesh* pStmVolPart, const Vector3d& vtTool) ;
+      bool SewingMissingFacesOnPlanes( ISurfTriMesh* pStm, const Plane3d& plPlane) ;
+      bool SliceVolume( const ISurfTriMesh* pStmVol, const ISurfTriMesh* pStm_Part, ISURFFRPOVECTOR& vSrfSliced,
+                        std::vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags, BOOLVECTOR& vbChangedPrec,
+                        VCT3DVECTOR& vVtTrasl, int& nStep, const Vector3d vtTool,
+                        const double dElev, const double dDepth, const double dStep) ;
+      bool CalcExtraSteps( const ISurfTriMesh* pStmVol, VCT3DVECTOR& vVtTrasl, int& nStep, const double dElev,
+                           const double dDepth, const double dStep, INTVECTOR& vIndExtraSteps,
+                           ISURFTMPOVECTOR& vStmES_Edges_OC) ;
+      bool CutVolumeByPlane( const ISurfTriMesh* pStmVol, const ISurfTriMesh* pStm_Part, const Vector3d& vtTrasl,
+                             const bool bIsExtraStep, ISurfFlatRegion* pSfrResult) ;
+      bool ProjectVolume( const ISurfTriMesh* pStmVol, const ISurfTriMesh* pStm_Part, const Vector3d& vtTrasl,
+                          const Vector3d& vtTraslPrec, ISurfFlatRegion* pSfrOpenProjPrec, ISurfFlatRegion* pSfr) ;
+      bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm, const bool bOnIsClosed = false) ;
+      bool GetCurvesForOptimizedPocketing( ISurfFlatRegion* pSfr, ICRVCOMPOPOVECTOR& vCrvOEWithFlags) ;
+      bool ModifySurfByOpenEdges( ISurfFlatRegion* pSfr, const ISurfFlatRegion* pSfrLimit) ;
+      bool AdjustContourWithOpenEdges( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vCrvIsl, const double dDiam,
+                                       const double dOffR, const double dStep, const ISurfFlatRegion* pSfrLimit) ;
+      bool AdjustOpenEdge( const ICurveComposite* pCrvCompo, const ICRVCOMPOPOVECTOR& vCrvIsland,
+                           const double dParS, const double dParE, const double dRad, const double dDiamJ,
+                           const ISurfFlatRegion* pSfrLimit, ICurveComposite* pCrvBorder) ;
+      bool GetProjectionOfStmToNotPocket( const ISurfTriMesh* pStmPart, const ISurfTriMesh* pStmVol,
+                                          const Vector3d& vtTrasl, ISurfFlatRegion* pSfrProj) ;
+      bool CreateSurfFrIncidence( const ICurveComposite* pCrv, const double dRad, ISurfFlatRegion* pSfrInc) ;
+      bool GetNewSfrByAnotherPocketing( ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrNoExtendedByOpenEdges,
+                                        const ISurfTriMesh* pStmVol, const ISurfTriMesh* pStm_Part,
+                                        const ISurfFlatRegion* pSfrLimit) ;
+      bool CalcAdaptedElevation( const Point3d& pt1, const Point3d& pt2) ;
+      bool GetHomogeneousParts( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCrvs) ;
+      bool ModifyCurveToSmoothed( ICurveComposite* pCrv, double dRightLen, double dLeftLen, bool bAsParam) ;
+      bool OrderCurvesByLastPntOfPath( ICRVCOMPOPOVECTOR& vCrv, Point3d ptEnd, PNTVECTOR& vPtStart,
+                                       VCT3DVECTOR& vVtOut, BOOLVECTOR& vbMidOut) ;
+      bool SetBetterPtStartForSubChunks( ICurveComposite* pCrv0, const ISurfFlatRegion* pSrfToWork, Point3d& ptStart,
+                                         Vector3d& vtMidOut, bool& bMidOut) ;
+      bool GetOptCrvIndex( const std::vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags, int nStep, ISurfFlatRegion* pSrfChunkFinal,
+                           int& nIndex) ;
+      bool GetTrapezoidFromShape( const ICurveComposite* pCrvCompo, ICurveComposite* pCrvTrap, Frame3d& frTrap,
+                                  double& dPocketSize, int& nBase, int& nSecondBase) ;
+      bool CheckTrapezoidClosedEdgePosition( const ICurveComposite* pCrvCompo, const int nCrvInd, const double dDimBoxY,
+                                             INTVECTOR& vIndClosedSides, bool& bOk,
+                                             ICurveComposite* pCrvTrap) ;
+      bool CheckSecondBaseTrapezoid( const ICurveComposite* pCrvCompo, const int nCrvInd, int& nSecondBase) ;
+      bool PreparareTrapezoidTwoBases( const ICurveComposite* pCrvCompo, BBox3d BBox, const int nBase, int& nSecondBase,
+                                       bool& bOk, ICurveComposite* pCrvTrap) ;
+      bool GetSfrByStm( const ISurfTriMesh* pStm, ISurfFlatRegion* pSfr, const Plane3d plPock, const Vector3d& vtExtr,
+                        const double dThick, double dToll = 5 * EPS_SMALL) ;
+      bool ProjectStmOnPlane( const ISurfTriMesh* pStmAbove, const Plane3d plPock, ISurfFlatRegion* pSfrProj) ;
+      bool GetCoeffLinArc( const ICurveArc* pArc, double dDiam, double& dSubArc) ;
+      bool GetParamOnOpenSide( const ICurveComposite* pCompo,const ICRVCOMPOPOVECTOR& vCrvIsl, Point3d& ptMid, Vector3d& vtMidOut) ;
+      bool AdjustContourStart( ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvIsl, bool bOrder = false) ;
+      bool GetParamForPtStartOnEdge( const ICurve* pCrv, const ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvIsl,
+                               double& dPar) ;
+      bool CheckForRemovingIsland( const ICurveComposite* pCrvIslandBorder, double dOffs, bool bRemove) ;
+      bool AddZigZag( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVECTOR>& vCrvOrig, BOOLVECTOR& vbChangedPrec,
+                      VCT3DVECTOR& vVtTrasl, const Vector3d& vtTool, const Vector3d& vtExtr,
+                      double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) ;
+      bool CalcZigZag( const ISurfFlatRegion* pSrfZigZag, ICRVCOMPOPOVECTOR& vpCrvs) ;
+      bool CalcZigZagLink( ICurveComposite* pCrv1, ICurveComposite* pCrv2, ICurveComposite* pCrvLink) ;
+      bool OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d & vtTool, double dDepth, double dSafeZ,
+                            Frame3d& frPocket, ICurveComposite* pCrvOrig, bool& bOptimizedZigZag, 
+                            ICRVCOMPOPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvIslMergeBorders, double& dOffs,
+                            int& nClosedSides, bool& bTwoOpposite) ;
       bool ZigZagOptimizedNoClosedEdges( ICurveComposite* pCrvPocket, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ;
-      bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag, Vector3d& vtDir, double& dOffs) ;
-      bool ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, 
-                                          bool& bOpposite, Vector3d& vtDir, double& dOffs) ;
+      bool ZigZagOptimizedOneClosedEdge( ICurveComposite* pCrvPocket, int nClosedId, bool& bOptimizedZigZag,
+                                         Vector3d& vtDir,  double& dOffs) ;
+      bool ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds,
+                                          bool& bOptimizedZigZag, bool& bOpposite, Vector3d& vtDir,  double& dOffs) ;
       bool ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag, 
-                                            bool& bOpposite, Vector3d& vtDir, double& dOffs) ;
-      bool ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY, 
-                                         const INTVECTOR& vnClosedIds, double& dOffs) ;
+                                            bool& bOpposite, Vector3d& vtDir,  double& dOffs) ;
+      bool ZigZagOptimizedComputeOffset( ICurveComposite* pCrvPocket, const Vector3d& vtMainDir, int nOffsettedEdgesOnY,
+                                         const INTVECTOR& vnClosedIds,  double& dOffs) ;
       bool CutCurveWithLine( ICurveComposite* pCrvA, const ICurveLine* pCrvB) ;
-      bool AddOneWay( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
-                      double dDepth, double dElev, double dOkStep, bool bSplitArcs) ;
-      bool AddSpiralIn( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
-                        double dDepth, double dElev, double dOkStep, bool bSplitArcs, bool bMidOpen,
-                        const Point3d& ptMidOpen, const Vector3d& vtMidOut, int nPathId) ;
-      bool AddSpiralOut( const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
-                         double dDepth, double dElev, double dOkStep, bool bSplitArcs, int nPathId) ;
-      bool CalcSpiral( const ICurveComposite* pCompo, int nReg, bool bSplitArcs, 
-                       ICurveComposite* pMCrv, ICurveComposite* pRCrv, int nPathId, bool& bOptimizedTrap) ;
-      bool CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, const ICurve* pCrvBound,
+      bool AddOneWay( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVECTOR>& vCrvOrig, BOOLVECTOR& vbChangedPrec,
+                      VCT3DVECTOR& vVtTrasl, const Vector3d& vtTool, const Vector3d& vtExtr,
+                      double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) ;
+      bool AddSpiralIn( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVECTOR>& vCrvOrig, BOOLVECTOR& vbChangedPrec,
+                        VCT3DVECTOR& vVtTrasl, const Vector3d& vtTool, const Vector3d& vtExtr,
+                        double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) ;
+      bool AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVECTOR>& vCrvOrig, BOOLVECTOR& vbChangedPrec,
+                         VCT3DVECTOR& vVtTrasl, const Vector3d& vtTool, const Vector3d& vtExtr,
+                         double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs) ;
+      bool CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptStart, Vector3d& vtMidOut , bool& bMidOut,
+                       bool bSplitArcs,ICurveComposite* pMCrv, ICurveComposite* pRCrv, ICurveComposite* pCrvOEWithFlags,
+                       bool vbChangedPrec, bool& bOptimizedTrap) ;
+      bool CheckIfOffsetIsNecessary( const ICurveComposite* pCrvOffs, const double dOffs, const int nIter,
+                                     const int nOffsCount, const Vector3d& vtN, bool& bInsert) ;
+      bool GetUnclearedRegion( ICRVCOMPOPOVECTOR& vFirstOffs, ICRVCOMPOPOVECTOR& vCrvs, ICURVEPOVECTOR& vLinks,
+                               const ICurveComposite* pCrv_orig, ISurfFlatRegion* pSrfToCut) ;
+      bool GetDynamicClearedRegion( ISurfFlatRegion* pSrfPrec, const ICurveComposite* pCrv) ;
+      bool RemoveFirstLoopFromSfr( ISurfFlatRegion* pSrfOrig ) ;
+      bool RemoveExtraParts( ISurfFlatRegion* pSrfToCut, ICRVCOMPOPOVECTOR& vOffs, ICRVCOMPOPOVECTOR& vOffsClosedCurves,
+                             ICRVCOMPOPOVECTOR& vOffsFirstCurve, ICURVEPOVECTOR& vLinks) ;
+      bool RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRVCOMPOPOVECTOR& vOffsFirstCurve,
+                                        int& nOptFlag, Point3d& ptCentroid, ICurveComposite* pCrvPath) ;
+      bool CutOffsetToClosestPoint( ICRVCOMPOPOVECTOR& vCurves, const Point3d& ptFocus, ICurveComposite* pCrv1,
+                                    ICurveComposite* pCrv2, int& nIndex) ;
+      bool CutLinkToClosestPoint( ICURVEPOVECTOR& vCurves, ICRVCOMPOPOVECTOR& vOffs, const Point3d& ptFocus,
+                                  ICurveComposite* pCrv1, ICurveComposite* pCrv2, bool& bFound, int& nIndex) ;
+      bool GetNewCurvetWithCentroid( const ICurveComposite* pCrvH1, const ICurveComposite* pCrvH2, Point3d& ptC, bool bCir,
+                                     ICRVCOMPOPOVECTOR& VFirstOff, ICurveComposite* pCrvNewCurve) ;
+      bool GetNewCurvetWithPath( const ICurveComposite* pCrvH1, const ICurveComposite* pCrvH2, ICurveComposite* pCrvPath,
+                                 ICRVCOMPOPOVECTOR& VFirstOff, ICRVCOMPOPOVECTOR& VoffsCl, ICurveComposite* pCrvNewCurve) ;
+      bool ManageSmoothAndAutoInters( ICurveComposite* pCrv, ICurveComposite* pCrvPath, ICurveComposite* pPath1,
+                                      ICurveComposite* pPath2, ICRVCOMPOPOVECTOR& vOffsCL) ;
+      bool GetCurveWeightInfo( const ICurveComposite* pCrvCompo, double dMaxLen, double& dToTRot, int& nSmallArcs, int& nSmallLines) ;
+      bool ChoosePath( const ICurveComposite* pCrv1, const ICurveComposite* pCrv2, int nP, double dPerP, double dMaxLen, int& nC) ;
+      bool CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCOMPOPOVECTOR& vOffIslands,
                             ICurveComposite* pCrvLink) ;
+      bool CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const Point3d& ptEnd, const Vector3d& vtEnd, double dParMeet, 
+                                   ICRVCOMPOPOVECTOR& vOffIslands, ICurveComposite* pCrvLink) ;
+      bool ModifyBiArc( ICurve* pCrvBiArc, double dCutToll, ICurveComposite* pNewCrv) ;
+      bool CutCurveByOffsets( ICurveComposite* pCurve, ICRVCOMPOPOVECTOR& vOffs) ;
+      bool CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, ICRVCOMPOPOVECTOR& vOffs, ICRVCOMPOPOVECTOR& vOffIslands,
+                              ICurveComposite* pCrvLink, double dLenPercS = 0.01, double dLenPercE = 0.01, int nMaxIter = 2) ;
       bool CalcBoundedLinkWithBiArcs( const Point3d& ptStart, const Vector3d& vtStart, const Point3d& ptEnd, const Vector3d& vtEnd,
                                       const ICurve* pCrvBound, ICurveComposite* pCrvLink) ;
       bool CalcCircleSpiral( const Point3d& ptCen, const Vector3d& vtN, double dOutRad, double dIntRad,
                              bool bSplitArcs, ICurveComposite* pMCrv, ICurveComposite* pRCrv) ;
-      bool CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Vector3d& vtDir, double dPocketSize,  
-                                ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool& bOptimizedTrap) ;
+      bool CalcTrapezoidSpiral( ICurveComposite* pCrvPocket, const Frame3d& frTrap, double dPocketSize, int nBase,
+                                int nSecondBase, ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool& bOptimizedTrap) ;
       bool CalcTrapezoidSpiralLocalFrame( ICurveComposite * pCrvPocket, const Vector3d& vtDir, Frame3d& frLoc) ;
-      bool CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, bool bStart, double dYCoord, double& dXCoord, double dPocketSize) ;      
-      bool AdjustTrapezoidSpiralForAngles( ICurveComposite * pMCrv, const ICurveComposite * pCrvPocket, bool bStart) ;
-      bool SpecialAdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const ICurveComposite* pCrvPocket) ;
+      bool CalcTrapezoidSpiralXCoord( const ICurveComposite * pCrvPocket, int nBase,int nSecondBase,
+                                      bool bStart, double dYCoord, double& dXCoord, double dPocketSize) ;
+      bool AdjustTrapezoidSpiralForAngles( ICurveComposite * pMCrv, const ICurveComposite * pCrvPocket, 
+                                           bool bStart) ;
+      bool SpecialAdjustTrapezoidSpiralForAngles( ICurveComposite* pMCrv, const bool bEven, const ICurveComposite* pCrvPocket) ;
       bool AdjustTrapezoidSpiralForLeadInLeadOut( ICurveComposite * pCompo, ICurveComposite * pRCrv, const Vector3d& vtTool, 
                                                   double dDepth, int& nOutsideRaw) ;
-      bool ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, const Vector3d& vtMainDir, bool bLeadIn, const Vector3d& vtTool, double dDepth, bool& bIsOutsideRaw) ;
+      bool ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite * pCompo, const Vector3d& vtMainDir, bool bLeadIn, const Vector3d& vtTool, double dDepth, 
+                                                bool& bIsOutsideRaw) ;
+      bool GetSignedDistFromRealDirection( const Point3d ptP, const Vector3d vtDir, double& dDist, Vector3d& vtNorm) ;
+      double GetMinFeed( void ) const { return GetFeed() * GetSideStep() / m_TParams.m_dDiam ; }
+      double GetMaxFeed( void ) const { return GetFeed() ; }
+      bool GetFeedForParam( double& dPar, double& dFeed) ;
+      bool AssignDefaultFeed( ICurveComposite* pCrv) ;
+      bool DrawColoredCrvForFeedTest( ICurve* pCurve, double dFeed) ;
+      bool AssignFeedForOpenEdge( ICurveComposite* pCrv, const ICurveComposite* pCrvOF_ori) ;
+      bool AssignFeedForLineInOut( ICurveComposite* pCrv, const bool bIsIn) ;
+      bool AssignFeedOnCorners( ICurveComposite* pCrv, const ICurveComposite* pCrv_orig, const double dLenToll) ;
+      bool AssignFeedForEdgeCleaning( ICurveComposite *pCrv, const ICRVCOMPOPOVECTOR& vCrvOF_orig, int nInd = -1) ;
+      bool AssignFeedZigZagOneWay( ICurveComposite* pCompoLine, const bool bIsLink, const ICURVEPOVECTOR& vLAbove,
+                                   const ICURVEPOVECTOR& vLUnder, const ICRVCOMPOPOVECTOR& vAddedLinks) ;
+      bool AssignFeedSpiral( ICurveComposite* pCrv, const ISurfFlatRegion* pSrfRemoved_offs, const bool bIsLink,
+                             const ICRVCOMPOPOVECTOR& vLinks_done, const ICurveComposite* pCrv_orig, double dToll) ;
+      bool AssignFeedSpiralOpt( const int nOptType, ICurveComposite* pCrv) ;
+      bool AssignFeedCrvOnUnclearedRegions( ICurveComposite* pCrv) ;
+      bool AssignFeedForReturnPath( ICurveComposite* pCrv) ;
+      bool VerifyLeadInHelix( ISurfFlatRegion* pSrfChunk, const Point3d& ptCen, double dRad) const ;
+      bool VerifyLeadInZigZag( ISurfFlatRegion* pSrfChunk, const Point3d& ptPa, const Point3d& ptPb) const ;
       bool ComputePolishingPath( ICurveComposite* pMCrv, ICurveComposite* pRCrv, bool bSplitArcs) ; 
       bool AddEpicycles( ICurveComposite * pCompo, ICurveComposite * pCrv, ICurveComposite * pCrvBound = nullptr) ;
       bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
-                        double dElev, double dAppr, bool bSplitArcs, bool bOutStart) ;
+                        double dElev, double dAppr, bool bOutStart) ;
       bool AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
-                            double dElev, double dAppr, bool bSplitArcs, bool bOutStart = false) ;
+                            double dElev, double dAppr, bool bOutStart = false) ;
       bool AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
-                           double dElev, double dAppr, bool bSplitArcs) ;
+                           double dElev, double dAppr) ;
       bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dSafeAggrBottZ,
-                       double dElev, double dAppr, bool bSplitArcs) ;
+                       double dElev, double dAppr) ;
       bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
                             const ICurveComposite* pRCrv, Point3d& ptP1) const ;
-      bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
-                      const ICurveComposite* pCompo, const ICurveComposite* pRCrv, bool bAtLeft, bool bSplitArcs,
+      bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, 
+                      ISurfFlatRegion* pSrfChunk, const ICurveComposite* pRCrv, bool bAtLeft, bool bSplitArcs,
                       bool bNoneForced = false, bool bSkipControl = false) ;
       bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
-                       const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced,
-                       Point3d& ptP1, double& dElev) ;
+                       const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, Point3d& ptP1,
+                       double& dElev, bool bRecalcElev = true) ;
       bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
                        const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced,
-                       Point3d& ptP1, double& dElev, bool& bOppositeHome) ;
+                       Point3d& ptP1, double& dElev, bool& bOppositeHome, bool bRecalcElev = true) ;
       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 VerifyLeadInHelix( const ICurveComposite* pCompo, const Point3d& ptCen, double dRad) const ;
-      bool VerifyLeadInZigZag( const ICurveComposite* pCompo, const Point3d& ptPa, const Point3d& ptPb) const ;
-      bool CalcDistanceFromRawSurface( int nPhase, const Point3d& ptP, const Vector3d& vtDir, double& dDist, Vector3d& vtNorm) ; 
+     // ===================================================================
 
    private :
       double GetSpeed( void) const
@@ -177,21 +294,31 @@ class Pocketing : 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
+      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_bOptOffset = true ;     // flag per ottimizzazione numero di Offset necessari
+      bool          m_bOptOffsetCM = false ;  // flag per ottimizzazione numero di Offset necessari con centroidi e medial Axis
+      bool          m_bAssignFeed = false ;   // flag per controllo della Feed
+      double        m_dDiam_Prec = 0.0 ;      // diametro utensile per precedente svuotatura
+      double        m_dOffsetR_Prec = 0.0 ;   // offset radiale della svuotatura precedente
+      double        m_dSideStep_Prec = 0.0 ;  // side Step della svuotatura precedente
+      double        m_dLen_Prec = 0.0 ;       // Lunghezza del tool precedente
+      bool          m_bOrderStepZ = true ;    // parametro per ordinare gli step Extra per Z decrescente o meno
+      bool          m_bPocketPlane = false ;  // flag per svuotare solo la rimanenza sullo Step Extra
+
 } ;

PocketingData.cpp

@@ -397,8 +397,7 @@ bool
 PocketingData::VerifySubType( int nVal) const
 {
    return ( nVal == POCKET_SUB_ZIGZAG  ||  nVal == POCKET_SUB_ONEWAY  ||
-            nVal == POCKET_SUB_SPIRALIN  ||  nVal == POCKET_SUB_SPIRALOUT  ||
-            nVal == POCKET_SUB_CONFORMAL_ZIGZAG  ||  nVal == POCKET_SUB_CONFORMAL_ONEWAY) ;
+            nVal == POCKET_SUB_SPIRALIN  ||  nVal == POCKET_SUB_SPIRALOUT) ;
 }
 
 //----------------------------------------------------------------------------

Processor.cpp

@@ -414,7 +414,7 @@ Processor::ProcessClPath( int nClPathId, int nClPathInd, int nOpId, int nOpInd)
      // processo l'entità
       if ( ! ProcessClEnt( nEntId, nEntInd, nClPathId, nClPathInd, nOpId, nOpInd))
          bOk = false ;
-     // passo all'entità successiva
+     // passo all'entità successivo
       nEntId = m_pGeomDB->GetNext( nEntId) ;
    }
 
@@ -449,24 +449,19 @@ Processor::ProcessClEnt( int nEntId, int nEntInd, int nClPathId, int nClPathInd,
    if ( pCamData == nullptr  ||  pCamData->GetAxesStatus() != CamData::AS_OK)
       return false ;
    const DBLVECTOR& AxesEnd = pCamData->GetAxesVal() ;
-   int nMove = pCamData->GetMoveType() ;
-  //  Recupero i dati Cam del movimento successivo del percorso (se esiste)
-   CamData* pNextCamData = GetCamData( m_pGeomDB->GetUserObj( m_pGeomDB->GetNext( nEntId))) ;
-   int nMoveNext = ( pNextCamData != nullptr ? pNextCamData->GetMoveType() : -1) ;
-   DBLVECTOR AxesNull ;
-   const DBLVECTOR& AxesNext = ( pNextCamData != nullptr ? pNextCamData->GetAxesVal() : AxesNull) ;
   // Emetto movimento
+   int nMove = pCamData->GetMoveType() ;
    switch ( nMove) {
    case 0 :      // rapido
       if ( ! OnRapid( nEntId, nEntInd, nMove, AxesEnd, pCamData->GetAxesMask(),
                       pCamData->GetToolDir(), pCamData->GetCorrDir(), pCamData->GetBackAuxDir(),
-                      pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex(), nMoveNext, AxesNext))
+                      pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex()))
          return false ;
       break ;
    case 1 :      // linea
       if ( ! OnLinear( nEntId, nEntInd, nMove, AxesEnd,
                        pCamData->GetToolDir(), pCamData->GetCorrDir(), pCamData->GetBackAuxDir(),
-                       pCamData->GetFeed(), pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex(), nMoveNext, AxesNext))
+                       pCamData->GetFeed(), pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex()))
          return false ;
       break ;
    case 2 :      // arco CW
@@ -476,7 +471,7 @@ Processor::ProcessClEnt( int nEntId, int nEntInd, int nClPathId, int nClPathInd,
       if ( ! OnArc( nEntId, nEntInd, nMove, AxesEnd,
                     pCamData->GetAxesCen(), ptMid, pCamData->GetAxesRad(), pCamData->GetAxesAngCen(),
                     pCamData->GetToolDir(), pCamData->GetCorrDir(), pCamData->GetBackAuxDir(),
-                    pCamData->GetFeed(), pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex(), nMoveNext, AxesNext))
+                    pCamData->GetFeed(), pCamData->GetFlag(), pCamData->GetFlag2(), pCamData->GetIndex()))
          return false ;
       break ;
    }
@@ -526,8 +521,8 @@ bool
 Processor::UpdateAxes( void)
 {
   // Carico i nomi degli assi macchina attivi
-   return m_pMachine->GetAllCurrAxesNames( m_AxesName) &&
-          m_pMachine->GetAllCurrAxesTokens( m_AxesToken) ;
+   return m_pMachine->GetAllCurrAxesName( m_AxesName) &&
+          m_pMachine->GetAllCurrAxesToken( m_AxesToken) ;
 }
 
 //----------------------------------------------------------------------------
@@ -848,16 +843,15 @@ Processor::OnToolSelect( const string& sTool, const string& sHead, int nExit, co
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_EXIT, nExit) ;
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, sTcPos) ;
   // assegno il token e il nome degli assi
-   bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ;
    int nNumAxes = int( m_AxesName.size()) ;
    for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
       if ( i <= nNumAxes) {
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisToken( i, bIsRobot), m_AxesToken[i-1]) ;
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisName( i, bIsRobot), m_AxesName[i-1]) ;
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisToken(i), m_AxesToken[i-1]) ;
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisName(i), m_AxesName[i-1]) ;
       }
       else {
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisToken( i, bIsRobot)) ;
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisName( i, bIsRobot)) ;
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisToken(i)) ;
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisName(i)) ;
       }
    }
   // chiamo la funzione di selezione utensile
@@ -979,7 +973,7 @@ Processor::OnPathEndAux( int nInd, const string& sAE)
 bool
 Processor::OnRapid( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd, int nAxesMask,
                     const Vector3d& vtTool, const Vector3d& vtCorr, const Vector3d& vtAux,
-                    int nFlag, int nFlag2, int nIndex, int nMoveNext, const DBLVECTOR& AxesNext)
+                    int nFlag, int nFlag2, int nIndex)
 {
   // cancello variabili estranee
    ResetArcData() ;
@@ -989,13 +983,12 @@ Processor::OnRapid( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd
   // assegno il tipo di movimento
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ;
   // assegno il valore degli assi
-   bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ;
    int nNumAxes = int( AxesEnd.size()) ;
    for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
       if ( i <= nNumAxes)
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot), AxesEnd[i-1]) ;
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ;
       else
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot)) ;
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ;
    }
   // assegno la mascheratura degli assi
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MASK, nAxesMask) ;
@@ -1011,21 +1004,6 @@ Processor::OnRapid( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG2, nFlag2) ;
   // assegno il valore dell'indice
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_INDEX, nIndex) ;
-  // anticipazione di alcuni dati dell'eventuale movimento successivo dello stesso percorso
-   if ( nMoveNext != -1) {
-      bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVESUCC, nMoveNext) ;
-      for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
-         if ( i <= nNumAxes)
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot), AxesNext[i-1]) ;
-         else
-            bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ;
-      }
-   }
-   else {
-      bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_MOVESUCC) ;
-      for ( int i = 1 ; i <= MAX_AXES ; ++ i)
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ;
-   }
   // chiamo la funzione di movimento in rapido
    bOk = bOk && CallOnRapid() ;
    return bOk ;
@@ -1035,7 +1013,7 @@ Processor::OnRapid( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd
 bool
 Processor::OnLinear( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd,
                      const Vector3d& vtTool, const Vector3d& vtCorr, const Vector3d& vtAux,
-                     double dFeed, int nFlag, int nFlag2, int nIndex, int nMoveNext, const DBLVECTOR& AxesNext)
+                     double dFeed, int nFlag, int nFlag2, int nIndex)
 {
   // cancello variabili estranee
    ResetArcData() ;
@@ -1045,13 +1023,12 @@ Processor::OnLinear( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEn
   // assegno il tipo di movimento
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ;
   // assegno il valore degli assi
-   bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ;
    int nNumAxes = int( AxesEnd.size()) ;
    for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
       if ( i <= nNumAxes)
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot), AxesEnd[i-1]) ;
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ;
       else
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot)) ;
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ;
    }
   // assegno il valore del versore utensile
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TDIR, vtTool) ;
@@ -1067,21 +1044,6 @@ Processor::OnLinear( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEn
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG2, nFlag2) ;
   // assegno il valore dell'indice
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_INDEX, nIndex) ;
-  // anticipazione di alcuni dati dell'eventuale movimento successivo dello stesso percorso
-   if ( nMoveNext != -1) {
-      bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVESUCC, nMoveNext) ;
-      for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
-         if ( i <= nNumAxes)
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot), AxesNext[i-1]) ;
-         else
-            bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ;
-      }
-   }
-   else {
-      bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_MOVESUCC) ;
-      for ( int i = 1 ; i <= MAX_AXES ; ++ i)
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ;
-   }
   // chiamo la funzione di movimento in rapido
    bOk = bOk && CallOnLinear() ;
    return bOk ;
@@ -1092,7 +1054,7 @@ bool
 Processor::OnArc( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd,
                   const Point3d& ptCen, const Point3d& ptMid, double dRad, double dAngCen,
                   const Vector3d& vtTool, const Vector3d& vtCorr, const Vector3d& vtAux,
-                  double dFeed, int nFlag, int nFlag2, int nIndex, int nMoveNext, const DBLVECTOR& AxesNext)
+                  double dFeed, int nFlag, int nFlag2, int nIndex)
 {
   // assegno Id e indice entità di movimento
    bool bOk = m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVEID, nEntId) ;
@@ -1100,13 +1062,12 @@ Processor::OnArc( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd,
   // assegno il tipo di movimento
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVE, nMove) ;
   // assegno il valore degli assi
-   bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ;
    int nNumAxes = int( AxesEnd.size()) ;
    for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
       if ( i <= nNumAxes)
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot), AxesEnd[i-1]) ;
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue(i), AxesEnd[i-1]) ;
       else
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot)) ;
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue(i)) ;
    }
   // assegno le coordinate del centro
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_C1, ptCen.x) ;
@@ -1134,21 +1095,6 @@ Processor::OnArc( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd,
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_FLAG2, nFlag2) ;
   // assegno il valore dell'indice
    bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_INDEX, nIndex) ;
-  // anticipazione di alcuni dati dell'eventuale movimento successivo dello stesso percorso
-   if ( nMoveNext != -1) {
-      bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_MOVESUCC, nMoveNext) ;
-      for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
-         if ( i <= nNumAxes)
-            bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot), AxesNext[i-1]) ;
-         else
-            bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ;
-      }
-   }
-   else {
-      bOk = bOk && m_pMachine->LuaResetGlobVar( GLOB_VAR + GVAR_MOVESUCC) ;
-      for ( int i = 1 ; i <= MAX_AXES ; ++ i)
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisNext( i, GLOB_VAR, bIsRobot)) ;
-   }
   // chiamo la funzione di movimento in rapido
    bOk = bOk && CallOnArc() ;
    return bOk ;

Processor.h

@@ -61,14 +61,14 @@ class Processor
       bool OnPathEndAux( int nInd, const std::string& sAE) ;
       bool OnRapid( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd, int nAxesMask,
                     const Vector3d& vtTool, const Vector3d& vtCorr, const Vector3d& vtAux,
-                    int nFlag, int nFlag2, int nIndex, int nMoveNext, const DBLVECTOR& AxesNext) ;
+                    int nFlag, int nFlag2, int nIndex) ;
       bool OnLinear( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd,
                      const Vector3d& vtTool, const Vector3d& vtCorr, const Vector3d& vtAux,
-                     double dFeed, int nFlag, int nFlag2, int nIndex, int nMoveNext, const DBLVECTOR& AxesNext) ;
+                     double dFeed, int nFlag, int nFlag2, int nIndex) ;
       bool OnArc( int nEntId, int nEntInd, int nMove, const DBLVECTOR& AxesEnd,
                   const Point3d& ptCen, const Point3d& ptMid, double dRad, double dAngCen,
                   const Vector3d& vtTool, const Vector3d& vtCorr, const Vector3d& vtAux,
-                  double dFeed, int nFlag, int nFlag2, int nIndex, int nMoveNext, const DBLVECTOR& AxesNext) ;
+                  double dFeed, int nFlag, int nFlag2, int nIndex) ;
       bool ResetArcData( void) ;
 
    protected :

SawFinishing.cpp

@@ -1325,7 +1325,7 @@ SawFinishing::CalculateStraightAcrossToolPath( int nAuxId, int nClId)
   // se ZigZag aggiungo risalita
    if ( m_Params.m_nStepType == SAWFIN_ST_ZIGZAG) {
      // recupero distanza di sicurezza
-      double dSafeZ = GetSafeZ() ;
+      double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
      // lunghezza di approccio/retrazione
       double dAppr = m_Params.m_dStartPos ;
      // aggiungo retrazione
@@ -1646,7 +1646,7 @@ SawFinishing::CalculateCurvedAcrossToolPath( int nAuxId, int nClId)
             double dEndElev = 0 ;
             GetElevation( m_nPhase, ptPrev, vtPrev, dEndElev) ;
            // aggiungo retrazione
-            double dSafeZ = GetSafeZ() ;
+            double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
             double dAppr = m_Params.m_dStartPos ;
             if ( ! AddRetract( ptPrev, vtPrev, dSafeZ, dEndElev, dAppr))
                return false ;
@@ -1670,7 +1670,7 @@ SawFinishing::CalculateCurvedAcrossToolPath( int nAuxId, int nClId)
   // se ZigZag aggiungo risalita
    if ( m_Params.m_nStepType == SAWFIN_ST_ZIGZAG) {
      // recupero distanza di sicurezza
-      double dSafeZ = GetSafeZ() ;
+      double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
      // lunghezza di approccio/retrazione
       double dAppr = m_Params.m_dStartPos ;
      // recupero punto e versore correzione finali
@@ -1880,6 +1880,7 @@ SawFinishing::ClassifySection( ICurve* pCrv, INTVECTOR& vnClass)
 {
    const ICurveComposite* pCompo = GetCurveComposite( pCrv) ;
    if ( pCompo != nullptr) {
+      int Ind = 0 ;
       const ICurve* pSimpCrv = pCompo->GetFirstCurve() ;
       while ( pSimpCrv != nullptr) {
         // analizzo la curva
@@ -1897,6 +1898,7 @@ SawFinishing::ClassifySection( ICurve* pCrv, INTVECTOR& vnClass)
          else
             vnClass.push_back( CCL_FALL) ;
         // passo alla curva successiva
+         ++ Ind ;
          pSimpCrv = pCompo->GetNextCurve() ;
       }
    }
@@ -1989,7 +1991,7 @@ SawFinishing::CalcAlongVerticalCuts( ICurve* pSect, int nUmin, int nUmax, const
   // se ZigZag e non centrato aggiungo risalita
    if ( m_Params.m_nStepType == SAWFIN_ST_ZIGZAG  &&  m_Params.m_nLeadLinkType != SAWFIN_LL_CENT) {
      // recupero distanza di sicurezza
-      double dSafeZ = GetSafeZ() ;
+      double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
      // lunghezza di approccio/retrazione
       double dAppr = m_Params.m_dStartPos ;
      // aggiungo retrazione
@@ -2076,7 +2078,7 @@ SawFinishing::CalcAlongStdCuts( ICurve* pSect, double dUmin, double dUmax,
   // se ZigZag e non centrato aggiungo risalita
    if ( m_Params.m_nStepType == SAWFIN_ST_ZIGZAG  &&  m_Params.m_nLeadLinkType != SAWFIN_LL_CENT) {
      // recupero distanza di sicurezza
-      double dSafeZ = GetSafeZ() ;
+      double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
      // lunghezza di approccio/retrazione
       double dAppr = m_Params.m_dStartPos ;
      // aggiungo retrazione
@@ -2094,7 +2096,7 @@ SawFinishing::CalcAlongOneWayCut( const Point3d& ptStart, const Point3d& ptEnd,
                                   const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, bool bVert)
 {
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
 
@@ -2143,7 +2145,7 @@ SawFinishing::CalcAlongZigZagCut( const Point3d& ptStart, const Point3d& ptEnd,
                                   const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, bool bVert, bool bFirst)
 {
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
 
@@ -2260,7 +2262,7 @@ SawFinishing::CalcAcrossOneWayCut( const PolyLine& PL, const Vector3d& vtMove,
                                    const Vector3d& vtTool, const Vector3d& vtCorr, double dRawZ, double dDepth)
 {
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
 
@@ -2317,7 +2319,7 @@ SawFinishing::CalcAcrossZigZagCut( const PolyLine& PL, const Vector3d& vtMove,
                                    const Vector3d& vtTool, const Vector3d& vtCorr, double dRawZ, double dDepth, bool bFirst)
 {
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
 
@@ -2425,7 +2427,7 @@ SawFinishing::CalcCurvedAlongVerticalCuts( ICurve* pSect, int nUmin, int nUmax,
   // se ZigZag e non centrato aggiungo risalita
    if ( m_Params.m_nStepType == SAWFIN_ST_ZIGZAG  &&  m_Params.m_nLeadLinkType != SAWFIN_LL_CENT) {
      // recupero distanza di sicurezza
-      double dSafeZ = GetSafeZ() ;
+      double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
      // lunghezza di approccio/retrazione
       double dAppr = m_Params.m_dStartPos ;
      // aggiungo retrazione
@@ -2500,7 +2502,7 @@ SawFinishing::CalcCurvedAlongStdCuts( ICurve* pSect, double dUmin, double dUmax,
   // se ZigZag e non centrato aggiungo risalita
    if ( m_Params.m_nStepType == SAWFIN_ST_ZIGZAG  &&  m_Params.m_nLeadLinkType != SAWFIN_LL_CENT) {
      // recupero distanza di sicurezza
-      double dSafeZ = GetSafeZ() ;
+      double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
      // lunghezza di approccio/retrazione
       double dAppr = m_Params.m_dStartPos ;
      // aggiungo retrazione
@@ -2518,7 +2520,7 @@ bool
 SawFinishing::CalcCurvedAlongZigZagCut( const ICurve* pCut, const Vector3d& vtTool, bool bVert, bool bFirst, double& dEndElev)
 {
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
   // verifico se passata da invertire (indice dispari)
@@ -2694,7 +2696,7 @@ SawFinishing::CalcCurvedAcrossZigZagCut( const PolyLine& PL, const Vector3d& vtM
                                          bool bFirst, bool bCorner)
 {
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
 

SawRoughing.cpp

@@ -1560,7 +1560,7 @@ SawRoughing::CalculateOneWayCut( const Point3d& ptStart, const Point3d& ptEnd, c
                                  const Vector3d& vtTool, const Vector3d& vtCorr, double dElev, bool bFirst, bool bLast)
 {
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
 
@@ -1654,7 +1654,7 @@ SawRoughing::CalculateZigZagCut( const Point3d& ptStart, const Point3d& ptEnd, c
                                  int& nCount)
 {
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
 
@@ -1865,7 +1865,7 @@ SawRoughing::CalculateCurvedZigZagCut( const ICurve* pCut, const Vector3d& vtToo
                                        int& nCount)
 {
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
   // verifico se passata da invertire (indice dispari)

Sawing.cpp

@@ -4,7 +4,7 @@
 // File : Sawing.cpp         Data : 24.10.15          Versione : 1.6j3
 // Contenuto : Implementazione gestione tagli con lama.
 //
-// Note : Questa lavorazione è sempre espressa nel riferimento globale.
+// Note : Questa lavorazione è sempre espressa nel riferimento globale.
 //
 // Modifiche : 07.06.15 DS Creazione modulo.
 //
@@ -532,15 +532,15 @@ Sawing::SetParam( int nType, const string& sVal)
 bool
 Sawing::SetGeometry( const SELVECTOR& vIds)
 {
-  // verifico validità gestore DB geometrico
+  // verifico validità gestore DB geometrico
    if ( m_pGeomDB == nullptr)
       return false ;
   // reset della geometria corrente
    m_vId.clear() ;
-  // verifico che gli identificativi rappresentino delle entità ammissibili
+  // verifico che gli identificativi rappresentino delle entità ammissibili
    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 Sawing : Skipped entity " + ToString( Id) ;
@@ -563,14 +563,14 @@ Sawing::Preview( bool bRecalc)
   // reset numero tagli nella lavorazione
    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 ;
 
   // 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)
@@ -603,7 +603,7 @@ Sawing::Preview( bool bRecalc)
 
   // recupero gruppo per anteprima di lavorazione (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)
@@ -633,7 +633,7 @@ Sawing::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 ;
 
@@ -662,7 +662,7 @@ Sawing::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)
@@ -689,7 +689,7 @@ Sawing::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)
@@ -732,7 +732,7 @@ Sawing::Apply( bool bRecalc, bool bPostApply)
 bool
 Sawing::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 ;
 
@@ -742,7 +742,7 @@ Sawing::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
@@ -794,7 +794,7 @@ Sawing::Update( bool bPostApply)
 bool
 Sawing::AdjustFeeds( void)
 {
-  // controlli su GeomDB e simili non ripetuti perchè già fatti
+  // controlli su GeomDB e simili non ripetuti perchè già fatti
 
   // recupero gruppo della geometria di lavorazione (Cutter Location)
    int nClId = m_pGeomDB->GetFirstNameInGroup( GetOwner(), MCH_CL) ;
@@ -804,11 +804,11 @@ Sawing::AdjustFeeds( void)
   // ciclo sui gruppi CL
    int nClPathId = m_pGeomDB->GetFirstGroupInGroup( nClId) ;
    while ( nClPathId != GDB_ID_NULL) {
-     // ciclo su tutte le entità del percorso CL
+     // ciclo su tutte le entità del percorso CL
       for ( int nEntId = m_pGeomDB->GetFirstInGroup( nClPathId) ;
             nEntId != GDB_ID_NULL ;
             nEntId = m_pGeomDB->GetNext( nEntId)) {
-        // recupero i dati Cam dell'entità
+        // recupero i dati Cam dell'entità
          CamData* pCamData = GetCamData( m_pGeomDB->GetUserObj( nEntId)) ;
          if ( pCamData == nullptr)
             continue ;
@@ -1075,7 +1075,7 @@ Sawing::UpdateToolData( bool* pbChanged)
 bool
 Sawing::GetGeometry( SELVECTOR& vIds) const
 {
-  // restituisco l'elenco delle entità
+  // restituisco l'elenco delle entità
    vIds = m_vId ;
    return true ;
 }
@@ -1098,7 +1098,7 @@ Sawing::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_NONE  ||  nType == GEO_CURVE)  &&  ( pGObj->GetType() & GEO_CURVE) != 0) {
       nType = GEO_CURVE ;
       const ICurve* pCurve = nullptr ;
@@ -1122,7 +1122,7 @@ Sawing::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_NONE  ||  nType == GEO_SURF)  &&  pGObj->GetType() == SRF_TRIMESH) {
       nType = GEO_SURF ;
       const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
@@ -1142,7 +1142,7 @@ Sawing::VerifyGeometry( SelData Id, int& nSubs, int& nType)
       }
       return true ;
    }
-  // se altrimenti ammesse regioni ed è tale
+  // se altrimenti ammesse regioni ed è tale
    else if ( ( nType == GEO_NONE  ||  nType == GEO_SURF)  &&  pGObj->GetType() == SRF_FLATRGN) {
       nType = GEO_SURF ;
       const ISurfFlatRegion* pReg = ::GetSurfFlatRegion( pGObj) ;
@@ -1245,7 +1245,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, 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 ;
@@ -1294,7 +1294,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, 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 ;
@@ -1335,7 +1335,7 @@ Sawing::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 Sawing : Skipped entity " + ToString( Id) ;
          m_pMchMgr->SetWarning( 2251, sInfo) ;
@@ -1477,7 +1477,7 @@ Sawing::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)
@@ -1542,7 +1542,7 @@ Sawing::ProcessPath( int nPathId, int nPvId, int nClId)
   // elaboro la curva composita e la esplodo nelle curve componenti
    if ( m_Params.m_nCurveUse == SAW_CRV_APPROX  ||
         m_Params.m_nCurveUse == SAW_CRV_CONVEX) {
-     // calcolo l'approssimazione lineare con eventuale convessità
+     // calcolo l'approssimazione lineare con eventuale convessità
       PolyLine PL ;
       int nType = ICurve::APL_STD ;
       if ( m_Params.m_nWorkSide == SAW_WS_LEFT)
@@ -1631,7 +1631,7 @@ Sawing::ProcessPath( int nPathId, int nPvId, int nClId)
   // flag di curva chiusa
    bool bClosed = pCompo->IsClosed() ;
 
-  // calcolo gli eventuali punti di perdita di tangenza e di cambio di concavità
+  // calcolo gli eventuali punti di perdita di tangenza e di cambio di concavità
    DBLVECTOR vU ; 
    const double ANG_PERD_TG = 1.0 ;
    const ICurveArc* pArc = ( bClosed ? GetCurveArc( pCompo->GetLastCurve()) : nullptr) ;
@@ -1647,7 +1647,7 @@ Sawing::ProcessPath( int nPathId, int nPvId, int nClId)
          nCurrConv = 0 ;
          continue ;  
       }
-     // verifico cambio di concavità e/o lavorazione interna
+     // verifico cambio di concavità e/o lavorazione interna
       const ICurve* pCrv = pCompo->GetCurve( i) ;
       if ( pCrv->GetType() == CRV_ARC) {
          if ( GetCurveArc( pCrv)->GetAngCenter() > 0) {
@@ -1729,7 +1729,7 @@ Sawing::ProcessEntity( const ICurve* pCrvP, const ICurve* pCrvC, const ICurve* p
   // altrimenti
    else {
       if ( m_Params.m_nCurveUse == SAW_CRV_KEEP) {
-        // determino la convessità
+        // determino la convessità
          int nConv = 0 ;
          for ( int i = 0 ; i < pCompo->GetCurveCount() ; ++ i) {
             const ICurveArc* pArc = GetCurveArc( pCompo->GetCurve( i)) ;
@@ -1830,7 +1830,7 @@ Sawing::ProcessLine( const ICurve* pCrvP, const ICurveLine* pLineC, const ICurve
            ( m_Params.m_nWorkSide == SAW_WS_RIGHT  &&  dAngCN < - EPS_ANG_SMALL))
          bExtAngCN = false ;
    }
-  // verifico eventuale attacco speciale a step (se parametri validi e su entità linea singola)
+  // verifico eventuale attacco speciale a step (se parametri validi e su entità linea singola)
    double dLiStep = 0 ;
    double dLiElev = 0 ;
    if ( m_Params.m_dLiTang > 10 * EPS_SMALL  &&  m_Params.m_dLiElev > 10 * EPS_SMALL  &&
@@ -1851,7 +1851,7 @@ Sawing::ProcessLine( const ICurve* pCrvP, const ICurveLine* pLineC, const ICurve
       return true ;
    }
 
-  // Eventuale variazioni di velocità all'inizio e alla fine del percorso
+  // Eventuale variazioni di velocità all'inizio e alla fine del percorso
    FseVar FvVar ;
    if ( pCrvP == nullptr) {
       string sFsta = ExtractInfo( m_Params.m_sUserNotes, "Fsta=") ;
@@ -1962,7 +1962,7 @@ Sawing::GenerateLinePv( const ICurveLine* pLine, const Vector3d& vtTool, const V
    m_pGeomDB->SetMaterial( nId3, BLUE) ;
 
   // valore di allungamento
-   double dExtraL = GetExtraLOnCutRegion() ;
+   double dExtraL = m_pMchMgr->GetCurrMachiningsMgr()->GetExtraLOnCutRegion() ;
 
   // punti notevoli per regioni
    Point3d ptRIni = ptIni ;
@@ -1999,7 +1999,7 @@ Sawing::GenerateLinePv( const ICurveLine* pLine, const Vector3d& vtTool, const V
                                            ptREnd + vtDir * ( dDtEnd + dExtraL) , RTY_LOC) ;
    m_pGeomDB->SetName( nReId, MCH_PV_RLOCUT) ;
    m_pGeomDB->SetMaterial( nReId, INVISIBLE) ;
-  
+
   // eventuali ripetizioni in basso per tagli inclinati
    if ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) {
      // lunghezza movimento
@@ -2057,23 +2057,6 @@ Sawing::GenerateLinePv( const ICurveLine* pLine, const Vector3d& vtTool, const V
       }
    }
 
-  // creo regioni di lavorazione che interessano le superfici superiore e inferiore del grezzo considerando anche gli
-  // allungamenti dei baffi
-   int nSurfUpId = ExeCreateSurfFrRectangle3P( nPxId, ptIni - vtDir * ( dStartWhiskExt + 5 * EPS_SMALL), 
-                                               ptCross + vtDir * ( dEndWhiskExt + 5 * EPS_SMALL), 
-                                               ptEnd + vtDir * ( dEndWhiskExt + 5 * EPS_SMALL), RTY_LOC) ;
-   m_pGeomDB->SetName( nSurfUpId, MCH_PV_UP_RAWCUT) ;
-   m_pGeomDB->SetMaterial( nSurfUpId, INVISIBLE) ;
-  // solo se la lavorazione interessa il fondo del grezzo creo la superficie down
-   if ( dRbHeight < EPS_SMALL) {
-      int nSurfDownId = m_pGeomDB->CopyGlob( nSurfUpId, GDB_ID_NULL, nPxId) ;
-      double dMove = dElev + dRbHeight / cos( m_Params.m_dSideAngle * DEGTORAD) ;
-      Vector3d vtMove = - dMove * vtCorr ; vtMove.z = 0 ; 
-      ExeMove( {nSurfDownId}, vtMove, RTY_LOC) ;
-      m_pGeomDB->SetName( nSurfDownId, MCH_PV_DOWN_RAWCUT) ;
-      m_pGeomDB->SetMaterial( nSurfDownId, INVISIBLE) ;
-   }
-
   // salvo in info gruppo : larghezza XY del taglio, distanza XY tra centro e bordo taglio, extra taglio e quota minima della lama
    m_pGeomDB->SetInfo( nPxId, MCH_PV_KEY_WT, vtToolH.LenXY()) ;
    if ( dLiElev > EPS_SMALL)
@@ -2112,7 +2095,7 @@ Sawing::GenerateLineCl( const ICurveLine* pLine, const Vector3d& vtTool, const V
    SetToolDir( vtTool) ;
    SetCorrAuxDir( vtCorr) ;
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // distanza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
   // flag di taglio inclinato
@@ -2296,16 +2279,17 @@ Sawing::GenerateLineCl( const ICurveLine* pLine, const Vector3d& vtTool, const V
          Point3d ptP3 = pLine->GetEnd() + vtCorr * dDelta ;
          if ( AddLinearMove( ptP3) == GDB_ID_NULL)
             return false ;
-        // se non è ultimo passo
+        // se non è ultimo passo
          if ( i != 0) {
            // movimento di risalita sopra il punto finale
             SetFeed( GetEndFeed()) ;
             Point3d ptP4 = pLine->GetEnd() + vtCorr * ( dElev + dAppr / vtCorr.z) ;
             if ( AddLinearMove( ptP4) == GDB_ID_NULL)
                return false ;
-           // movimento di ritorno in rapido sopra il punto iniziale
+           // movimento di ritorno spora il punto iniziale
+            SetFeed( GetEndFeed()) ;
             Point3d ptP5 = pLine->GetStart() + vtCorr * ( dElev + dAppr / vtCorr.z) ;
-            if ( AddRapidMove( ptP5) == GDB_ID_NULL)
+            if ( AddLinearMove( ptP5) == GDB_ID_NULL)
                return false ;
          }
       }     
@@ -2338,7 +2322,7 @@ Sawing::ProcessExtCurve( const ICurve* pCrvP, const ICurveComposite* pCrvC, cons
             dMinRad = dRad ;
       }
    }
-   if ( dMinRad < GetExtSawArcMinRad()) {
+   if ( dMinRad < m_pMchMgr->GetCurrMachiningsMgr()->GetExtSawArcMinRad()) {
       m_pMchMgr->SetWarning( 2258, "Warning in Sawing : Radius too small in ExtSawArc") ;
       return true ;
    }
@@ -2491,8 +2475,8 @@ Sawing::GenerateExtCurvePv( const ICurveComposite* pCrv, double dOffs,
    if ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL)
       colCut = FUCHSIA ;
 
-  // dimensione da aggiungere alle regioni nelle parti in cui la lama è inclinata
-   double dExtraL = GetExtraLOnCutRegion() ;
+  // dimensione da aggiungere alle regioni nelle parti in cui la lama è inclinata
+   double dExtraL = m_pMchMgr->GetCurrMachiningsMgr()->GetExtraLOnCutRegion() ;
 
   // lunghezza taglio parziale
    double dDeltaT = (( dElev < 0.5 * m_TParams.m_dDiam) ? sqrt( dElev * m_TParams.m_dDiam - dElev * dElev) : 0) ;
@@ -2639,17 +2623,6 @@ Sawing::GenerateExtCurvePv( const ICurveComposite* pCrv, double dOffs,
             return false ;
          if ( ! ExeSurfFrAdd( nRId, nRsId)  ||  ! ExeSurfFrAdd( nRId, nReId))
             return false ;
-
-        // creo regioni di lavorazione che interessano le superfici superiore e inferiore del grezzo 
-         int nSurfUpId = m_pGeomDB->CopyGlob( nRrId, GDB_ID_NULL, nPxId) ;
-         m_pGeomDB->SetName( nSurfUpId, MCH_PV_UP_RAWCUT) ;
-         m_pGeomDB->SetMaterial( nSurfUpId, INVISIBLE) ;
-        // solo se lavorazione interessa il fondo del grezzo creo la superficie down
-         if ( dRbHeight < EPS_SMALL) {
-            int nSurfDownId = m_pGeomDB->CopyGlob( nSurfUpId, GDB_ID_NULL, nPxId) ;            
-            m_pGeomDB->SetName( nSurfDownId, MCH_PV_DOWN_RAWCUT) ;
-            m_pGeomDB->SetMaterial( nSurfDownId, INVISIBLE) ;
-         }
       }
 
      // altrimenti errore
@@ -2864,7 +2837,7 @@ Sawing::GenerateExtCurveCl( const ICurveComposite* pCrv,
    SetPathId( nPxId) ;
    SetCorrAuxDir( vtStaCorr) ;
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
 
@@ -2895,7 +2868,7 @@ Sawing::GenerateExtCurveCl( const ICurveComposite* pCrv,
          CalculateToolAndCorrVersors( vtCurrDir, m_Params.m_nHeadSide, m_Params.m_nWorkSide, m_Params.m_dSideAngle, vtCurrTool, vtCurrCorr) ;
          SetToolDir( vtCurrTool) ;
          SetCorrAuxDir( vtCurrCorr) ;
-         if ( AddCurveMove( pSmpCrv) == GDB_ID_NULL)
+         if ( AddCurveMove( pSmpCrv, true) == GDB_ID_NULL)
             return false ;
       }
      // 4 -> retrazione
@@ -2973,7 +2946,7 @@ Sawing::GenerateExtCurveCl( const ICurveComposite* pCrv,
                   pCopy->SimpleOffset( dOffs) ;
                }
               // emissione
-               if ( AddCurveMove( pCopy) == GDB_ID_NULL)
+               if ( AddCurveMove( pCopy, true) == GDB_ID_NULL)
                   return false ;
             }
          }
@@ -3006,7 +2979,7 @@ Sawing::GenerateExtCurveCl( const ICurveComposite* pCrv,
               // inversione
                pCopy->Invert() ;
               // emissione
-               if ( AddCurveMove( pCopy) == GDB_ID_NULL)
+               if ( AddCurveMove( pCopy, true) == GDB_ID_NULL)
                   return false ;
             }
          }
@@ -3073,10 +3046,10 @@ Sawing::GenerateExtCurveCl( const ICurveComposite* pCrv,
                pCopy->SimpleOffset( dOffs) ;
             }
            // emissione
-            if ( AddCurveMove( pCopy) == GDB_ID_NULL)
+            if ( AddCurveMove( pCopy, true) == GDB_ID_NULL)
                return false ;
          }
-        // se non è ultimo passo
+        // se non è ultimo passo
          if ( i != 0) {
            // ricavo punto di risalita e punto iniziale
             Point3d ptP4 ;
@@ -3124,7 +3097,7 @@ Sawing::ProcessIntArc( const ICurve* pCrvP, const ICurveArc* pArcC, const ICurve
    if ( IsNull( pArc))
       return false ;
   // determino l'inclinazione per ottenere il raggio e ne verifico il limite
-   double dMaxSideAng = GetIntSawArcMaxSideAng() + EPS_ANG_SMALL ;
+   double dMaxSideAng = m_pMchMgr->GetCurrMachiningsMgr()->GetIntSawArcMaxSideAng()+ EPS_ANG_SMALL ;
    double dSawRad = m_TParams.m_dDiam / 2 ;
    double dRad = pArc->GetRadius() ;
    double dSinA = dSawRad / dRad ;
@@ -3220,7 +3193,7 @@ Sawing::ProcessIntArc( const ICurve* pCrvP, const ICurveArc* pArcC, const ICurve
       m_pMchMgr->SetWarning( 2257, "Warning in Sawing : skipped Entity too small") ;
       return true ;
    }
-  // ricalcolo i versori fresa alle estremità (potrebbero essere cambiate)
+  // ricalcolo i versori fresa alle estremità (potrebbero essere cambiate)
    pArc->GetStartDir( vtStaDirC) ;
    pArc->GetMidDir( vtMidDirC) ;
    pArc->GetEndDir( vtEndDirC) ;
@@ -3312,8 +3285,8 @@ Sawing::GenerateIntArcPv( const ICurveArc* pArc,
    m_pGeomDB->SetName( nId3, MCH_PV_POST_CUT) ;
    m_pGeomDB->SetMaterial( nId3, BLUE) ;
 
-  // dimensione da aggiungere alle regioni nelle parti in cui la lama è inclinata
-   double dExtraL = GetExtraLOnCutRegion() ;
+  // dimensione da aggiungere alle regioni nelle parti in cui la lama è inclinata
+   double dExtraL = m_pMchMgr->GetCurrMachiningsMgr()->GetExtraLOnCutRegion() ;
 
   // regione ridotta di taglio per nesting (escluse parti iniziali e finali)
    PtrOwner<ICurveComposite> pCmpRr( GenerateIntArcPvTrueCut( pArc, dDeltaInt, dDeltaExt, dExtraL)) ;
@@ -3366,17 +3339,6 @@ Sawing::GenerateIntArcPv( const ICurveArc* pArc,
    if ( ! ExeSurfFrAdd( nRId, nRsId)  ||  ! ExeSurfFrAdd( nRId, nReId))
       return false ;
 
-  // creo regioni di lavorazione che interessano le superfici superiore e inferiore del grezzo 
-   int nSurfUpId = m_pGeomDB->CopyGlob( nRrId, GDB_ID_NULL, nPxId) ;
-   m_pGeomDB->SetName( nSurfUpId, MCH_PV_UP_RAWCUT) ;
-   m_pGeomDB->SetMaterial( nSurfUpId, INVISIBLE) ;
-   // solo se lavorazione interessa il fondo del grezzo creo la superficie down
-   if ( dRbHeight < EPS_SMALL) {
-      int nSurfDownId = m_pGeomDB->CopyGlob( nSurfUpId, GDB_ID_NULL, nPxId) ;            
-      m_pGeomDB->SetName( nSurfDownId, MCH_PV_DOWN_RAWCUT) ;
-      m_pGeomDB->SetMaterial( nSurfDownId, INVISIBLE) ;
-   }
-
   // salvo in info gruppo : larghezza XY del taglio, distanza XY tra centro e bordo taglio, extra taglio e quota minima della lama
    m_pGeomDB->SetInfo( nPxId, MCH_PV_KEY_WT, dDeltaInt + dDeltaExt) ;
    m_pGeomDB->SetInfo( nPxId, MCH_PV_KEY_DT, dDeltaT * dLenCoeff) ;
@@ -3571,7 +3533,7 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc,
   // Imposto dati comuni
    SetPathId( nPxId) ;
   // recupero distanza di sicurezza
-   double dSafeZ = GetSafeZ() ;
+   double dSafeZ = m_pMchMgr->GetCurrMachiningsMgr()->GetSafeZ() ;
   // lunghezza di approccio/retrazione
    double dAppr = m_Params.m_dStartPos ;
 
@@ -3609,12 +3571,12 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc,
       else {
          Point3d ptMid ;
          pArc->GetMidPoint( ptMid) ;
-        // prima metà arco
+        // prima metà arco
          SetToolDir( vtMidTool) ;
          SetCorrAuxDir( vtMidCorr) ;
          if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL)
             return false ;
-        // seconda metà arco
+        // seconda metà arco
          SetToolDir( vtEndTool) ;
          SetCorrAuxDir( vtEndCorr) ;
          if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL)
@@ -3695,12 +3657,12 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc,
             pArc->GetMidPoint( ptMid) ;
             ptMid += Z_AX * dDelta ;
             double dCurrAngCen = dAngCen / 2 * ((( i % 2) == 0) ? -1 : 1) ;
-           // prima metà arco
+           // prima metà arco
             SetToolDir( vtMidTool) ;
             SetCorrAuxDir( vtMidCorr) ;
             if ( AddArcMove( ptMid, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
                return false ;
-           // seconda metà arco
+           // seconda metà arco
             SetToolDir( ( ( i % 2) == 0) ? vtStaTool : vtEndTool) ;
             SetCorrAuxDir( ( ( i % 2) == 0) ? vtStaCorr : vtEndCorr) ;
             if ( AddArcMove( ptP3, ptCen, dCurrAngCen, vtN) == GDB_ID_NULL)
@@ -3784,18 +3746,18 @@ Sawing::GenerateIntArcCl( const ICurveArc* pArc,
             Point3d ptMid ;
             pArc->GetMidPoint( ptMid) ;
             ptMid += Z_AX * dDelta ;
-           // prima metà arco
+           // prima metà arco
             SetToolDir( vtMidTool) ;
             SetCorrAuxDir( vtMidCorr) ;
             if ( AddArcMove( ptMid, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL)
                return false ;
-           // seconda metà arco
+           // seconda metà arco
             SetToolDir( vtEndTool) ;
             SetCorrAuxDir( vtEndCorr) ;
             if ( AddArcMove( ptP3, ptCen, dAngCen / 2, vtN) == GDB_ID_NULL)
                return false ;
          }
-        // se non è ultimo passo
+        // se non è ultimo passo
          if ( i != 0) {
            // movimento di risalita sopra il punto finale
             SetFeed( GetEndFeed()) ;
@@ -3917,7 +3879,7 @@ Sawing::CalculateToolAndCorrVersors( const Vector3d& vtTang, int nHeadSide, int
 bool
 Sawing::AdjustForSide( ICurve* pCurve)
 {
-  // se lato lavoro e lato mandrino coincidono, non devo fare alcunché
+  // se lato lavoro e lato mandrino coincidono, non devo fare alcunché
    if ( ( m_Params.m_nWorkSide == SAW_WS_LEFT  &&  m_Params.m_nHeadSide == SAW_HS_LEFT)  ||
         ( m_Params.m_nWorkSide == SAW_WS_RIGHT  &&  m_Params.m_nHeadSide == SAW_HS_RIGHT))
       return true ;
@@ -4086,7 +4048,7 @@ Sawing::AdjustLineForEdges( ICurveLine* pLine, double dElev, const Vector3d& vtC
          dDeltaLoExt = dDeltaF ;
       }
    }
-  // controllo se lunghezza entità accettabile
+  // controllo se lunghezza entità accettabile
    const double MIN_LEN = 1 ;
    double dLenXY = DistXY( pLine->GetStart(), pLine->GetEnd()) ;
    if ( dDeltaI + dLenXY + dDeltaF < MIN_LEN) {
@@ -4157,7 +4119,7 @@ Sawing::AdjustCurveForEdges( ICurve* pCrv, double dElev, double dLenCoeff,
          dDeltaF = dDeltaT ;
    }
    dDeltaF *= dLenCoeff ;
-  // controllo se lunghezza entità accettabile
+  // controllo se lunghezza entità accettabile
    const double MIN_LEN = 1 ;
    double dLenXY ;
    pCrv->GetLength( dLenXY) ;

Simulator.h

@@ -1,24 +1,25 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2023
 //----------------------------------------------------------------------------
-// File : Simulator.h           Data : 01.09.24         Versione : 2.6i1
-// Contenuto : Dichiarazione della classe interfaccia ISimulator.
+// File : Simulator.h           Data : 16.01.23          Versione : 2.5a2
+// Contenuto : Dichiarazione della classe Simulator.
 //
 //
 //
-// Modifiche : 01.09.24 DS Creazione modulo.
+// Modifiche : 19.10.15 DS Creazione modulo.
 //
 //
 //----------------------------------------------------------------------------
 
 #pragma once
 
-#include "/EgtDev/Include/EGkVector3d.h"
+#include "CamData.h"
 #include "/EgtDev/Include/EMkSimuGenConst.h"
-#include "/EgtDev/Include/EgtNumCollection.h"
-#include <string>
 
 class MachMgr ;
+class IGeomDB ;
+class Machine ;
+class PerformanceCounter ;
 
 //------------------------ Struttura per movimento esterno assi --------------
 struct SimAxMv
@@ -37,27 +38,147 @@ enum SimAxMvRes { SIM_AXMV_RES_STOP = -1,
                   SIM_AXMV_RES_OK = 1} ;
 
 //----------------------------------------------------------------------------
-class __declspec( novtable) ISimulator
+class Simulator
 {
    public :
-      virtual ~ISimulator( void) {}
-      virtual bool Init( MachMgr* pMchMgr) = 0 ;
-      virtual bool Start( bool bFirst) = 0 ;
-      virtual bool Move( int& nStatus) = 0 ;
-      virtual bool GoHome( void) = 0 ;
-      virtual bool SetStep( double dStep) = 0 ;
-      virtual bool SetUiStatus( int nUiStatus) = 0 ;
-      virtual bool GetAxisInfoPos( int nI, std::string& sName, std::string& sToken, bool& bLinear, double& dVal) const = 0 ;
-      virtual bool GetToolInfo( std::string& sName, double& dSpeed) const = 0 ;
-      virtual bool GetOperationInfo( std::string& sName, int& nType) const = 0 ;
-      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 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 int  MoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt) = 0 ; 
-      virtual bool SaveCmd( int nType, int nPar, const std::string& sPar) = 0 ;
+      Simulator( void) ;
+      ~Simulator( void) ;
+      bool Init( MachMgr* pMchMgr) ;
+      bool Start( bool bFirst) ;
+      bool Move( int& nStatus) ;
+      bool GoHome( void) ;
+      bool SetStep( double dStep) ;
+      bool SetUiStatus( int nUiStatus) ;
+      bool GetAxisInfoPos( int nI, std::string& sName, std::string& sToken, bool& bLinear, double& dVal) const ;
+      bool GetToolInfo( std::string& sName, double& dSpeed) const ;
+      bool GetOperationInfo( std::string& sName, int& nType) const ;
+      bool GetMoveInfo( int& nGmove, double& dFeed) const ;
+      bool AddCollisionObj( int nInd, bool bToolOn, int nFrameId, int nType, const Vector3d& vtMove, double dPar1, double dPar2, double dPar3) ;
+      bool ExecCollisionCheck( int& nCdInd, int& nObjInd, int nMoveType) ;
+      bool OnCollision( int nCdInd, int nObjInd, int& nErr) ;
+      bool SetToolForVmill( const std::string& sTool, const std::string& sHead, int nExit, const INTVECTOR& vVmill, bool bFirst) ;
+      int  MoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt) ; 
+
+   private :
+      bool UpdateTool( bool bFirst, int& nErr) ;
+      bool UpdateAxes( void) ;
+      bool UpdateAxesPos( void) ;
+      bool ResetInterpolation( void) ;
+      bool ResetAxes( void) ;
+      bool ResetAuxAxes( void) ;
+
+   private :
+      bool VerifySetup( void) ;
+      bool FindAndManageOperationStart( bool bStart, bool bFirst, int& nStatus) ;
+      bool ManageOperationEnd( int& nStatus) ;
+      bool FindAndManagePathStart( int& nStatus) ;
+      bool ManagePathEnd( int& nStatus) ;
+      bool ManagePathStartAux( int& nStatus) ;
+      bool ManagePathEndAux( int& nStatus) ;
+      bool ManageMove( int& nStatus) ;
+      bool ManageSingleMove( int& nStatus, double& dMove) ;
+      int  CalcStatusOnError( int nErr) ;
+      bool GetHeadCurrPosDirAux( const std::string& sHead, int nExit, Point3d& ptH, Vector3d& vtH, Vector3d& vtA) ;
+      bool ExecLineVmill( int nVmId, int nCurrTool, double dVmTdOffs, double dVmAdOffs,
+                          const Point3d& ptHi, const Vector3d& vtHi, const Vector3d& vtAi, const Frame3d& frVzmI,
+                          const Point3d& ptHf, const Vector3d& vtHf, const Vector3d& vtAf, const Frame3d& frVzmF) ;
+      bool NeedCollisionCheck( void) const
+           { return ( ! m_CollObj.empty()  &&  ! m_CdId.empty()) ; }
+      bool Stopped( void)
+           { return ( m_nUiStatus == MCH_UISIM_STOP) ; }
+      bool OnStart( bool bFirst) ;
+      bool OnEnd( void) ;
+      bool OnDispositionStarting( int nOpId, int nOpInd, int nPhase,
+                                  const std::string& sTable, const Point3d& ptOri1, bool bEmpty, bool bSomeByHand) ;
+      bool OnDispositionStart( int nOpId, int nOpInd, int nPhase,
+                               const std::string& sTable, const Point3d& ptOri1, bool bEmpty, bool bSomeByHand) ;
+      bool OnDispositionEnd( void) ;
+      bool OnToolSelect( const std::string& sTool, const std::string& sHead, int nExit, const std::string& sTcPos, bool bFirst, int& nErr) ;
+      bool OnToolDeselect( const std::string& sNextTool, const std::string& sNextHead, int nNextExit, const std::string& sNextTcPos, int& nErr) ;
+      bool OnMachiningStart( int nOpId, int nOpInd, const Point3d& ptMin, const Point3d& ptMax,
+                             const DBLVECTOR& vAxMin, const DBLVECTOR& vAxMax) ;
+      bool OnMachiningEnd( void) ;
+      bool OnPathStartAux( int nInd, const std::string& sAS, int& nErr) ;
+      bool OnPathEndAux( int nInd, const std::string& sAE, int& nErr) ;
+      bool OnPathStart( int nClPathId, int nClPathInd, int nAS, const Point3d& ptStart, const Point3d& ptEnd,
+                        const Vector3d& vtExtr, const Point3d& ptMin, const Point3d& ptMax,
+                        const DBLVECTOR& vAxMin, const DBLVECTOR& vAxMax, double dElev) ;
+      bool OnPathEnd( int nAE) ;
+      bool OnMoveStart( const CamData* pCamData, int& nErr) ;
+      bool OnMoveEnd( int& nErr) ;
+      bool OnResetMachine( void) ;
+
+   private :
+      struct CollObj {
+         int nInd ;
+         bool bToolOn ;
+         int nFrameId ;
+         int nType ;
+         Vector3d vtMove ;
+         double dPar1 ;
+         double dPar2 ;
+         double dPar3 ;
+         CollObj( void) : nInd( 0), bToolOn( false), nFrameId( -1), nType( 0), vtMove(), dPar1( 0), dPar2( 0), dPar3( 0) {}
+         CollObj( int nI, bool bTOn, int nF, int nT, const Vector3d& vtM, double dP1, double dP2, double dP3)
+            : nInd( nI), bToolOn( bTOn), nFrameId( nF), nType( nT), vtMove( vtM), dPar1( dP1), dPar2( dP2), dPar3( dP3) {}
+      } ;
+      typedef std::vector<CollObj> COBVECTOR ;
+      struct VmTool
+      {
+         std::string sName ;
+         std::string sHead ;
+         int         nExit ;
+         double      dTdOffs ;
+         double      dAdOffs ;
+         VmTool( void) : nExit( 0), dTdOffs( 0), dAdOffs( 0) {}
+         VmTool( std::string sN, std::string sH, int nE, double dT, double dA)
+            : sName( sN), sHead( sH), nExit( nE), dTdOffs( dT), dAdOffs( dA) {}
+      } ;
+      typedef std::vector<VmTool> VMTVECTOR ;
+
+   private :
+      MachMgr*      m_pMchMgr ;              // puntatore al gestore di tutte le lavorazioni
+      IGeomDB*      m_pGeomDB ;              // puntatore al DB geometrico
+      Machine*      m_pMachine ;             // puntatore alla macchina
+      PerformanceCounter* m_pPerfCnt ;       // timer per calcolo FPS
+      double        m_dStep ;                // lunghezza di riferimento per la velocità di simulazione
+      int           m_nUiStatus ;            // stato simulazione a livello utente
+      int           m_nOpId ;                // identificativo della operazione (lavoraz.) corrente
+      int           m_nOpInd ;               // contatore della operazione (lavoraz.) corrente
+      int           m_nCLPathId ;            // identificativo del percorso di lavoro corrente    
+      int           m_nCLPathInd ;           // contatore del percorso di lavoro corrente nell'operazione   
+      int           m_nEntId ;               // identificativo dell'entità corrente
+      int           m_nEntInd ;              // contatore dell'entità corrente nel percorso di lavoro
+      double        m_dCoeff ;               // coefficiente di esecuzione del movimento corrente (0...1)
+      int           m_nAuxSTot ;             // numero totale movimenti ausiliari di inizio percorso
+      int           m_nAuxSInd ;             // indice del movimento ausiliario di inizio percorso corrente
+      int           m_nAuxETot ;             // numero totale movimenti ausiliari di fine percorso
+      int           m_nAuxEInd ;             // indice del movimento ausiliario di fine percorso corrente
+      std::string   m_sTool ;                // nome dell'utensile corrente
+      std::string   m_sHead ;                // nome della testa corrente
+      int           m_nExit ;                // indice dell'uscita corrente
+      double        m_dTDiam ;               // diametro dell'utensile corrente
+      bool          m_bCutOnTip ;            // flag capacità di lavorare di testa dell'utensile corrente
+      INTVECTOR     m_VmId ;                 // vettore identificativi Zmap per Virtual Milling
+      INTVECTOR     m_CdId ;                 // vettore identificativi Zmap per Collision Detection
+      VMTVECTOR     m_VmTool ;               // vettore utensili attivi per virtual milling
+      COBVECTOR     m_CollObj ;              // vettore oggetti da testare per collisione con grezzo
+      double        m_dSafeDist ;            // distanza di sicurezza per verifica collisioni
+      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
+      STRVECTOR     m_AxesName ;             // nomi degli assi macchina attivi
+      STRVECTOR     m_AxesToken ;            // token degli assi macchina attivi
+      BOOLVECTOR    m_AxesInvert ;           // flag di asse con verso invertito degli assi macchina attivi
+      DBLVECTOR     m_AxesOffset ;           // valore di offset delgli assi macchina ttivi
+      BOOLVECTOR    m_AxesLinear ;           // flag di lineare degli assi macchina attivi
+      DBLVECTOR     m_AxesVal ;              // valori degli assi macchina all'inizio del movimento corrente
+      STRVECTOR     m_AuxAxesName ;          // nomi degli assi macchina ausiliari abilitati
+      STRVECTOR     m_AuxAxesToken ;         // token degli assi macchina ausiliari abilitati
+      BOOLVECTOR    m_AuxAxesInvert ;        // flag di asse con verso invertito degli assi macchina ausiliari abilitati
+      DBLVECTOR     m_AuxAxesOffset ;        // valore di offset degli assi macchina ausiliari abilitati
+      BOOLVECTOR    m_AuxAxesLinear ;        // flag di lineare degli assi macchina ausiliari abilitati
+      DBLVECTOR     m_AuxAxesVal ;           // valori degli assi macchina ausiliari all'inizio del movimento corrente
+      DBLVECTOR     m_AuxAxesEnd ;           // valori degli assi macchina ausiliari alla fine del movimento corrente
+      INTVECTOR     m_AuxAxesLink ;          // indice + 1 asse principale di aggancio (negativo valore opposto, 0 nessuno)
 } ;

SimulatorMP.h

@@ -1,209 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : SimulatorMP.h         Data : 01.09.24          Versione : 2.6i1
-// Contenuto : Dichiarazione della classe SimulatorMP.
-//             Simulatore multi-processo.
-//
-//
-// Modifiche : 01.09.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "Simulator.h"
-#include "CamData.h"
-
-class IGeomDB ;
-class Machine ;
-class PerformanceCounter ;
-
-//----------------------------------------------------------------------------
-ISimulator* CreateSimulatorMP( void) ;
-
-//----------------------------------------------------------------------------
-class SimulatorMP : public ISimulator
-{
-   public :                       // ISimulator
-      ~SimulatorMP( void) override ;
-      bool Init( MachMgr* pMchMgr) override ;
-      bool Start( bool bFirst) override ;
-      bool Move( int& nStatus) override ;
-      bool GoHome( void) override ;
-      bool SetStep( double dStep) override ;
-      bool SetUiStatus( int nUiStatus) override ;
-      bool GetAxisInfoPos( int nI, std::string& sName, std::string& sToken, bool& bLinear, double& dVal) const override ;
-      bool GetToolInfo( std::string& sName, double& dSpeed) const override ;
-      bool GetOperationInfo( std::string& sName, int& nType) const override ;
-      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 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 ;
-      int  MoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt) override ;
-      bool SaveCmd( int nType, int nPar, const std::string& sPar) override ;
-
-   public :
-      SimulatorMP( void) ;
-
-   private :
-      bool UpdateMachiningTool( bool bFirst, bool& bDeselect, int& nErr) ;
-      bool UpdateDispositionTool( bool bFirst, int& nErr) ;
-      bool UpdateAxes( void) ;
-      bool UpdateAxesPos( void) ;
-      bool ResetInterpolation( void) ;
-      bool ResetAxes( void) ;
-      bool ResetAuxAxes( void) ;
-
-   private :
-      bool VerifySetup( void) ;
-      bool FindAndManageOperationStart( bool bStart, bool bFirst, bool& bChangedTool, int& nStatus) ;
-      bool ManageOperationEnd( int& nStatus) ;
-      bool FindAndManagePathStart( int& nStatus) ;
-      bool ManagePathEnd( int& nStatus) ;
-      bool ManagePathStartAux( int& nStatus) ;
-      bool ManagePathEndAux( int& nStatus) ;
-      bool ManageMove( int& nStatus) ;
-      bool ManageSingleMove( int& nStatus, double& dMove) ;
-      int  CalcStatusOnError( int nErr) ;
-      bool GetHeadCurrPosDirAux( const std::string& sHead, int nExit, Point3d& ptH, Vector3d& vtH, Vector3d& vtA) ;
-      bool ExecLineVmill( int nVmId, int nCurrTool, double dVmTdOffs, double dVmAdOffs,
-                          const Point3d& ptHi, const Vector3d& vtHi, const Vector3d& vtAi, const Frame3d& frVzmI,
-                          const Point3d& ptHf, const Vector3d& vtHf, const Vector3d& vtAf, const Frame3d& frVzmF) ;
-      bool NeedCollisionCheck( void) const
-           { return ( ! m_CollObj.empty()  &&  ! m_CdId.empty()) ; }
-      bool Stopped( void)
-           { return ( m_nUiStatus == MCH_UISIM_STOP) ; }
-      bool SetCollisionMark( int nCdInd, int nObjInd) ;
-      bool ResetCollisionMark( void) ;
-      bool OnInit( void) ;
-      bool OnExit( void) ;
-      bool OnProgramStart( bool bFirst) ;
-      bool OnProgramEnd( void) ;
-      bool OnDispositionStarting( int nOpId, int nOpInd, int nPhase,
-                                  const std::string& sTable, const Point3d& ptOri1, bool bEmpty, bool bSomeByHand) ;
-      bool OnDispositionStart( int nOpId, int nOpInd, int nPhase,
-                               const std::string& sTable, const Point3d& ptOri1, bool bEmpty, bool bSomeByHand) ;
-      bool OnDispositionEnd( void) ;
-      bool OnToolSelect( const std::string& sTool, const std::string& sHead, int nExit, const std::string& sTcPos, bool bFirst, int& nErr) ;
-      bool OnToolDeselect( const std::string& sNextTool, const std::string& sNextHead, int nNextExit, const std::string& sNextTcPos, int& nErr) ;
-      bool OnMachiningStart( int nOpId, int nOpInd, const Point3d& ptMin, const Point3d& ptMax,
-                             const DBLVECTOR& vAxMin, const DBLVECTOR& vAxMax) ;
-      bool OnMachiningEnd( void) ;
-      bool OnPathStartAux( int nInd, const std::string& sAS, int& nErr) ;
-      bool OnPathEndAux( int nInd, const std::string& sAE, int& nErr) ;
-      bool OnPathStart( int nClPathId, int nClPathInd, int nAS, const Point3d& ptStart, const Point3d& ptEnd,
-                        const Vector3d& vtExtr, const Point3d& ptMin, const Point3d& ptMax,
-                        const DBLVECTOR& vAxMin, const DBLVECTOR& vAxMax, double dElev) ;
-      bool OnPathEnd( int nAE) ;
-      bool OnMoveStart( const CamData* pCamData, const CamData* pNextCamData, int& nErr) ;
-      bool OnMoveEnd( int& nErr) ;
-      bool OnResetMachine( void) ;
-      bool ExecCmdData( int& nStatus) ;
-      bool ExecAllCmdData( int& nStatus) ;
-
-   private :
-      struct CollObj {
-         int nInd ;
-         bool bToolOn ;
-         int nFrameId ;
-         int nType ;
-         Vector3d vtMove ;
-         double dPar1 ;
-         double dPar2 ;
-         double dPar3 ;
-         CollObj( void) : nInd( 0), bToolOn( false), nFrameId( -1), nType( 0), vtMove(), dPar1( 0), dPar2( 0), dPar3( 0) {}
-         CollObj( int nI, bool bTOn, int nF, int nT, const Vector3d& vtM, double dP1, double dP2, double dP3)
-            : nInd( nI), bToolOn( bTOn), nFrameId( nF), nType( nT), vtMove( vtM), dPar1( dP1), dPar2( dP2), dPar3( dP3) {}
-      } ;
-      typedef std::vector<CollObj> COBVECTOR ;
-      struct VmTool
-      {
-         std::string sName ;
-         std::string sHead ;
-         int         nExit ;
-         double      dTdOffs ;
-         double      dAdOffs ;
-         VmTool( void) : nExit( 0), dTdOffs( 0), dAdOffs( 0) {}
-         VmTool( std::string sN, std::string sH, int nE, double dT, double dA)
-            : sName( sN), sHead( sH), nExit( nE), dTdOffs( dT), dAdOffs( dA) {}
-      } ;
-      typedef std::vector<VmTool> VMTVECTOR ;
-      enum { SIS_CREATED = 0,
-             SIS_INITIALIZED = 1,
-             SIS_READYTOSTART = 2,
-             SIS_READYTORUN = 3} ;
-
-   private :
-      struct CmdData {
-         int         nType ;
-         int         nMoveType ;
-         SAMVECTOR   vAxNaEpSt ;
-         int         nPar ;
-         std::string sPar ;
-         CmdData( void) : nType(0) {}
-         CmdData( int nM, const SAMVECTOR& vAx)
-            : nType( 1), nMoveType( nM), vAxNaEpSt( vAx) {}
-         CmdData( int nT, int nP, const std::string& sP)
-            : nType( nT), nPar( nP), sPar( sP) {}
-      } ;
-      typedef std::vector<CmdData> CMDVECTOR ;
-
-   private :
-      MachMgr*      m_pMchMgr ;              // puntatore al gestore di tutte le lavorazioni
-      IGeomDB*      m_pGeomDB ;              // puntatore al DB geometrico
-      Machine*      m_pMachine ;             // puntatore 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
-      int           m_nUiStatus ;            // stato simulazione a livello utente
-      int           m_nOpId ;                // identificativo della operazione (lavoraz.) corrente
-      int           m_nOpInd ;               // contatore della operazione (lavoraz.) corrente
-      int           m_nCLPathId ;            // identificativo del percorso di lavoro corrente    
-      int           m_nCLPathInd ;           // contatore del percorso di lavoro corrente nell'operazione   
-      int           m_nEntId ;               // identificativo dell'entità corrente
-      int           m_nEntInd ;              // contatore dell'entità corrente nel percorso di lavoro
-      double        m_dCoeff ;               // coefficiente di esecuzione del movimento corrente (0...1)
-      bool          m_bChangedTool ;         // flag di utensile appena scaricato
-      int           m_nAuxSTot ;             // numero totale movimenti ausiliari di inizio percorso
-      int           m_nAuxSInd ;             // indice del movimento ausiliario di inizio percorso corrente
-      int           m_nAuxETot ;             // numero totale movimenti ausiliari di fine percorso
-      int           m_nAuxEInd ;             // indice del movimento ausiliario di fine percorso corrente
-      std::string   m_sTool ;                // nome dell'utensile corrente
-      std::string   m_sHead ;                // nome della testa corrente
-      int           m_nExit ;                // indice dell'uscita corrente
-      double        m_dTDiam ;               // diametro 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
-      INTVECTOR     m_CdId ;                 // vettore identificativi Zmap per Collision Detection
-      VMTVECTOR     m_VmTool ;               // vettore utensili attivi per virtual milling
-      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
-      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
-      STRVECTOR     m_AxesName ;             // nomi degli assi macchina attivi
-      STRVECTOR     m_AxesToken ;            // token degli assi macchina attivi
-      BOOLVECTOR    m_AxesInvert ;           // flag di asse con verso invertito degli assi macchina attivi
-      DBLVECTOR     m_AxesOffset ;           // valore di offset delgli assi macchina ttivi
-      BOOLVECTOR    m_AxesLinear ;           // flag di lineare degli assi macchina attivi
-      DBLVECTOR     m_AxesVal ;              // valori degli assi macchina all'inizio del movimento corrente
-      STRVECTOR     m_AuxAxesName ;          // nomi degli assi macchina ausiliari abilitati
-      STRVECTOR     m_AuxAxesToken ;         // token degli assi macchina ausiliari abilitati
-      BOOLVECTOR    m_AuxAxesInvert ;        // flag di asse con verso invertito degli assi macchina ausiliari abilitati
-      DBLVECTOR     m_AuxAxesOffset ;        // valore di offset degli assi macchina ausiliari abilitati
-      BOOLVECTOR    m_AuxAxesLinear ;        // flag di lineare degli assi macchina ausiliari abilitati
-      DBLVECTOR     m_AuxAxesVal ;           // valori degli assi macchina ausiliari all'inizio del movimento corrente
-      DBLVECTOR     m_AuxAxesEnd ;           // valori degli assi macchina ausiliari alla fine del movimento corrente
-      INTVECTOR     m_AuxAxesLink ;          // indice + 1 asse principale di aggancio (negativo valore opposto, 0 nessuno)
-      CMDVECTOR     m_CmdData ;              // vettore comandi in attesa di esecuzione
-      int           m_nCmdInd ;              // indice prossimo comando da eseguire
-      double        m_dCmdCoeff ;            // coefficiente di movimento nel comando
-} ;

SimulatorSP.h

@@ -1,188 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2015-2024
-//----------------------------------------------------------------------------
-// File : SimulatorSP.h           Data : 16.01.23          Versione : 2.5a2
-// Contenuto : Dichiarazione della classe Simulator.
-//
-//
-//
-// Modifiche : 19.10.15 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "Simulator.h"
-#include "CamData.h"
-
-class IGeomDB ;
-class Machine ;
-class PerformanceCounter ;
-
-//----------------------------------------------------------------------------
-ISimulator* CreateSimulatorSP( void) ;
-
-//----------------------------------------------------------------------------
-class SimulatorSP : public ISimulator
-{
-   public :
-      ~SimulatorSP( void) override ;
-      bool Init( MachMgr* pMchMgr) override ;
-      bool Start( bool bFirst) override ;
-      bool Move( int& nStatus) override ;
-      bool GoHome( void) override ;
-      bool SetStep( double dStep) override ;
-      bool SetUiStatus( int nUiStatus) override ;
-      bool GetAxisInfoPos( int nI, std::string& sName, std::string& sToken, bool& bLinear, double& dVal) const override ;
-      bool GetToolInfo( std::string& sName, double& dSpeed) const override ;
-      bool GetOperationInfo( std::string& sName, int& nType) const override ;
-      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 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 ;
-      int  MoveAxes( int nMoveType, const SAMVECTOR& vAxNaEpSt) override ; 
-      bool SaveCmd( int nType, int nPar, const std::string& sPar) override
-               { return false ; } 
-
-   public :
-      SimulatorSP( void) ;
-
-   private :
-      bool UpdateTool( bool bFirst, int& nErr) ;
-      bool UpdateAxes( void) ;
-      bool UpdateAxesPos( void) ;
-      bool ResetInterpolation( void) ;
-      bool ResetAxes( void) ;
-      bool ResetAuxAxes( void) ;
-
-   private :
-      bool VerifySetup( void) ;
-      bool FindAndManageOperationStart( bool bStart, bool bFirst, int& nStatus) ;
-      bool ManageOperationEnd( int& nStatus) ;
-      bool FindAndManagePathStart( int& nStatus) ;
-      bool ManagePathEnd( int& nStatus) ;
-      bool ManagePathStartAux( int& nStatus) ;
-      bool ManagePathEndAux( int& nStatus) ;
-      bool ManageMove( int& nStatus) ;
-      bool ManageSingleMove( int& nStatus, double& dMove) ;
-      int  CalcStatusOnError( int nErr) ;
-      bool GetHeadCurrPosDirAux( const std::string& sHead, int nExit, Point3d& ptH, Vector3d& vtH, Vector3d& vtA) ;
-      bool ExecLineVmill( int nVmId, int nCurrTool, double dVmTdOffs, double dVmAdOffs,
-                          const Point3d& ptHi, const Vector3d& vtHi, const Vector3d& vtAi, const Frame3d& frVzmI,
-                          const Point3d& ptHf, const Vector3d& vtHf, const Vector3d& vtAf, const Frame3d& frVzmF) ;
-      bool NeedCollisionCheck( void) const
-               { return ( ! m_CollObj.empty()  &&  ! m_CdId.empty()) ; }
-      bool Stopped( void)
-               { return ( m_nUiStatus == MCH_UISIM_STOP) ; }
-      bool SetCollisionMark( int nCdInd, int nObjInd) ;
-      bool ResetCollisionMark( void) ;
-      bool OnInit( void) ;
-      bool OnExit( void) ;
-      bool OnProgramStart( bool bFirst) ;
-      bool OnProgramEnd( void) ;
-      bool OnDispositionStarting( int nOpId, int nOpInd, int nPhase,
-                                  const std::string& sTable, const Point3d& ptOri1, bool bEmpty, bool bSomeByHand) ;
-      bool OnDispositionStart( int nOpId, int nOpInd, int nPhase,
-                               const std::string& sTable, const Point3d& ptOri1, bool bEmpty, bool bSomeByHand) ;
-      bool OnDispositionEnd( void) ;
-      bool OnToolSelect( const std::string& sTool, const std::string& sHead, int nExit, const std::string& sTcPos, bool bFirst, int& nErr) ;
-      bool OnToolDeselect( const std::string& sNextTool, const std::string& sNextHead, int nNextExit, const std::string& sNextTcPos, int& nErr) ;
-      bool OnMachiningStart( int nOpId, int nOpInd, const Point3d& ptMin, const Point3d& ptMax,
-                             const DBLVECTOR& vAxMin, const DBLVECTOR& vAxMax) ;
-      bool OnMachiningEnd( void) ;
-      bool OnPathStartAux( int nInd, const std::string& sAS, int& nErr) ;
-      bool OnPathEndAux( int nInd, const std::string& sAE, int& nErr) ;
-      bool OnPathStart( int nClPathId, int nClPathInd, int nAS, const Point3d& ptStart, const Point3d& ptEnd,
-                        const Vector3d& vtExtr, const Point3d& ptMin, const Point3d& ptMax,
-                        const DBLVECTOR& vAxMin, const DBLVECTOR& vAxMax, double dElev) ;
-      bool OnPathEnd( int nAE) ;
-      bool OnMoveStart( const CamData* pCamData, const CamData* pNextCamData, int& nErr) ;
-      bool OnMoveEnd( int& nErr) ;
-      bool OnResetMachine( void) ;
-
-   private :
-      struct CollObj {
-         int nInd ;
-         bool bToolOn ;
-         int nFrameId ;
-         int nType ;
-         Vector3d vtMove ;
-         double dPar1 ;
-         double dPar2 ;
-         double dPar3 ;
-         CollObj( void) : nInd( 0), bToolOn( false), nFrameId( -1), nType( 0), vtMove(), dPar1( 0), dPar2( 0), dPar3( 0) {}
-         CollObj( int nI, bool bTOn, int nF, int nT, const Vector3d& vtM, double dP1, double dP2, double dP3)
-            : nInd( nI), bToolOn( bTOn), nFrameId( nF), nType( nT), vtMove( vtM), dPar1( dP1), dPar2( dP2), dPar3( dP3) {}
-      } ;
-      typedef std::vector<CollObj> COBVECTOR ;
-      struct VmTool
-      {
-         std::string sName ;
-         std::string sHead ;
-         int         nExit ;
-         double      dTdOffs ;
-         double      dAdOffs ;
-         VmTool( void) : nExit( 0), dTdOffs( 0), dAdOffs( 0) {}
-         VmTool( std::string sN, std::string sH, int nE, double dT, double dA)
-            : sName( sN), sHead( sH), nExit( nE), dTdOffs( dT), dAdOffs( dA) {}
-      } ;
-      typedef std::vector<VmTool> VMTVECTOR ;
-      enum { SIS_CREATED = 0,
-             SIS_INITIALIZED = 1,
-             SIS_READYTOSTART = 2,
-             SIS_READYTORUN = 3} ;
-
-   private :
-      MachMgr*      m_pMchMgr ;              // puntatore al gestore di tutte le lavorazioni
-      IGeomDB*      m_pGeomDB ;              // puntatore al DB geometrico
-      Machine*      m_pMachine ;             // puntatore 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
-      int           m_nUiStatus ;            // stato simulazione a livello utente
-      int           m_nOpId ;                // identificativo della operazione (lavoraz.) corrente
-      int           m_nOpInd ;               // contatore della operazione (lavoraz.) corrente
-      int           m_nCLPathId ;            // identificativo del percorso di lavoro corrente    
-      int           m_nCLPathInd ;           // contatore del percorso di lavoro corrente nell'operazione   
-      int           m_nEntId ;               // identificativo dell'entità corrente
-      int           m_nEntInd ;              // contatore dell'entità corrente nel percorso di lavoro
-      double        m_dCoeff ;               // coefficiente di esecuzione del movimento corrente (0...1)
-      int           m_nAuxSTot ;             // numero totale movimenti ausiliari di inizio percorso
-      int           m_nAuxSInd ;             // indice del movimento ausiliario di inizio percorso corrente
-      int           m_nAuxETot ;             // numero totale movimenti ausiliari di fine percorso
-      int           m_nAuxEInd ;             // indice del movimento ausiliario di fine percorso corrente
-      std::string   m_sTool ;                // nome dell'utensile corrente
-      std::string   m_sHead ;                // nome della testa corrente
-      int           m_nExit ;                // indice dell'uscita corrente
-      double        m_dTDiam ;               // diametro 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
-      INTVECTOR     m_CdId ;                 // vettore identificativi Zmap per Collision Detection
-      VMTVECTOR     m_VmTool ;               // vettore utensili attivi per virtual milling
-      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
-      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
-      STRVECTOR     m_AxesName ;             // nomi degli assi macchina attivi
-      STRVECTOR     m_AxesToken ;            // token degli assi macchina attivi
-      BOOLVECTOR    m_AxesInvert ;           // flag di asse con verso invertito degli assi macchina attivi
-      DBLVECTOR     m_AxesOffset ;           // valore di offset delgli assi macchina ttivi
-      BOOLVECTOR    m_AxesLinear ;           // flag di lineare degli assi macchina attivi
-      DBLVECTOR     m_AxesVal ;              // valori degli assi macchina all'inizio del movimento corrente
-      STRVECTOR     m_AuxAxesName ;          // nomi degli assi macchina ausiliari abilitati
-      STRVECTOR     m_AuxAxesToken ;         // token degli assi macchina ausiliari abilitati
-      BOOLVECTOR    m_AuxAxesInvert ;        // flag di asse con verso invertito degli assi macchina ausiliari abilitati
-      DBLVECTOR     m_AuxAxesOffset ;        // valore di offset degli assi macchina ausiliari abilitati
-      BOOLVECTOR    m_AuxAxesLinear ;        // flag di lineare degli assi macchina ausiliari abilitati
-      DBLVECTOR     m_AuxAxesVal ;           // valori degli assi macchina ausiliari all'inizio del movimento corrente
-      DBLVECTOR     m_AuxAxesEnd ;           // valori degli assi macchina ausiliari alla fine del movimento corrente
-      INTVECTOR     m_AuxAxesLink ;          // indice + 1 asse principale di aggancio (negativo valore opposto, 0 nessuno)
-} ;

SurfFinishing.h

@@ -21,7 +21,6 @@
 #include "/EgtDev/Include/EgtNumUtils.h"
 
 class ICAvToolSurfTm ;
-class ISurfFlatRegion ;
 
 //----------------------------------------------------------------------------
 class SurfFinishing : public Machining
@@ -74,24 +73,22 @@ class SurfFinishing : public Machining
       bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
       bool Chain( int nGrpDestId) ;
       bool ProcessPath( int nPathId, int nPvId, int nClId) ;
-      bool AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
-                      const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
-      bool AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
-                      const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs) ;
-      bool AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
-                      const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut) ;
+      bool AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf,
+                      const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
+                      double dDepth, double dElev) ;
+      bool CalcZigZag( const ICurveComposite* pOffs, ICRVCOMPOPOVECTOR& vpCrvs) ;
+      bool AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf,
+                      const ICurveComposite* pCompo, const Vector3d& vtTool, const Vector3d& vtExtr,
+                      double dDepth, double dElev, bool bInVsOut) ;
+      bool CalcSpiral( const ICurveComposite* pCompo, bool bSplitArcs,
+                       ICurveComposite* pMCrv, ICurveComposite* pRCrv) ;
       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) ;
       bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
-      bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, const Vector3d& vtNorm, Point3d& ptP1) const ;
-      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 GetSurfaceNormalAtPoint( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf,
-                                    const Point3d& ptTool, const Vector3d& vtTool, Vector3d& vtNorm) const ;
+      bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN, Point3d& ptP1) const ;
+      bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN) ;
+      bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN, Point3d& ptP1) ;
       bool GetActiveSurfaces( INTVECTOR& vSurfId) const ;
       double GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const ;
       double GetRadiusForStartEndElevation( void) const ;
@@ -111,8 +108,6 @@ class SurfFinishing : public Machining
          { return ( IsUnknownValue( m_Params.m_dOffsR) ? m_TParams.m_dOffsR : m_Params.m_dOffsR) ; }
       double GetSideStep( void) const
          { return Clamp( m_Params.m_dSideStep, 0.1, m_TParams.m_dTDiam) ; }
-      int GetLeadInType( void) const ;
-      int GetLeadOutType( void) const ;
 
    private :
       SELVECTOR         m_vId ;             // identificativi entità geometriche da lavorare

SurfFinishingData.cpp

@@ -147,6 +147,7 @@ SurfFinishingData::CopyFrom( const MachiningData* pMdata)
    m_nLeadOutType = pSdata->m_nLeadOutType ;
    m_dLoTang = pSdata->m_dLoTang ;
    m_dLoPerp = pSdata->m_dLoPerp ;
+   m_nLeadLinkType = pSdata->m_nLeadLinkType ;
    m_dApprox = pSdata->m_dApprox ;
    m_sSysNotes = pSdata->m_sSysNotes ;
    m_sUserNotes = pSdata->m_sUserNotes ;
@@ -191,6 +192,7 @@ SurfFinishingData::SameAs(const MachiningData* pMdata) const
             m_nLeadOutType == pSdata->m_nLeadOutType  &&
             abs( m_dLoTang - pSdata->m_dLoTang) < EPS_MACH_LEN_PAR  &&
             abs( m_dLoPerp - pSdata->m_dLoPerp) < EPS_MACH_LEN_PAR  &&
+            m_nLeadLinkType == pSdata->m_nLeadLinkType  &&
             abs( m_dApprox - pSdata->m_dApprox) < EPS_MACH_LEN_PAR  &&
             m_sSysNotes == pSdata->m_sSysNotes  &&
             m_sUserNotes == pSdata->m_sUserNotes) ;
@@ -271,7 +273,7 @@ SurfFinishingData::FromString( const string& sString, int& nKey)
       bOk = ::FromString( sVal, m_nLeadInType) ;
       break ;
    case KEY_LLTY :
-      // campo non più usato
+      bOk = ::FromString( sVal, m_nLeadLinkType) ;
       break ;
    case KEY_LOPR :
       bOk = ::FromString( sVal, m_dLoPerp) ;
@@ -349,7 +351,7 @@ SurfFinishingData::ToString( int nInd) const
    case KEY_LIPR : return ( sSurfFinishingKey[KEY_LIPR] + "=" + ::ToString( m_dLiPerp)) ;
    case KEY_LITG : return ( sSurfFinishingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ;
    case KEY_LITY : return ( sSurfFinishingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ;
-   case KEY_LLTY : return ( sSurfFinishingKey[KEY_LLTY] + "=" + ::ToString( 0)) ;
+   case KEY_LLTY : return ( sSurfFinishingKey[KEY_LLTY] + "=" + ::ToString( m_nLeadLinkType)) ;
    case KEY_LOPR : return ( sSurfFinishingKey[KEY_LOPR] + "=" + ::ToString( m_dLoPerp)) ;
    case KEY_LOTG : return ( sSurfFinishingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTang)) ;
    case KEY_LOTY : return ( sSurfFinishingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ;
@@ -401,6 +403,13 @@ SurfFinishingData::VerifyLeadInType( int nVal) const
             nVal == SURFFIN_LI_TANGENT) ;
 }
 
+//----------------------------------------------------------------------------
+bool
+SurfFinishingData::VerifyLeadLinkType( int nVal) const
+{
+   return ( nVal == SURFFIN_LL_STD  ||  nVal == SURFFIN_LL_CENT) ;
+}
+
 //----------------------------------------------------------------------------
 bool
 SurfFinishingData::VerifyLeadOutType( int nVal) const
@@ -455,6 +464,11 @@ SurfFinishingData::SetParam( int nType, int nVal)
          return false ;
       m_nLeadInType = nVal ;
       return true ;
+   case MPA_LEADLINKTYPE :
+      if ( ! VerifyLeadInType( nVal))
+         return false ;
+      m_nLeadLinkType = nVal ;
+      return true ;
    case MPA_LEADOUTTYPE :
       if ( ! VerifyLeadOutType( nVal))
          return false ;
@@ -601,6 +615,9 @@ SurfFinishingData::GetParam( int nType, int& nVal) const
    case MPA_LEADINTYPE :
       nVal = m_nLeadInType ;
       return true ;
+   case MPA_LEADLINKTYPE :
+      nVal = m_nLeadLinkType ;
+      return true ;
    case MPA_LEADOUTTYPE :
       nVal = m_nLeadOutType ;
       return true ;

SurfFinishingData.h

@@ -42,6 +42,7 @@ struct SurfFinishingData : public MachiningData
    int         m_nLeadOutType ;    // tipo di uscita (come attacco, nessuno, lineare, tangente, inseguimento)
    double      m_dLoTang ;         // distanza tangente verso fine uscita
    double      m_dLoPerp ;         // distanza perpendicolare verso fine uscita
+   int         m_nLeadLinkType ;   // tipo di collegamento ( centro, fuori)
    double      m_dApprox ;         // valore di approssimazione per superfici
    std::string m_sSysNotes ;       // note interne
    std::string m_sUserNotes ;      // note dell'utente
@@ -51,7 +52,7 @@ struct SurfFinishingData : public MachiningData
         m_dOffsR( UNKNOWN_PAR), m_bInvert( false),
         m_dStartPos( 0), m_dOverlap(0), m_dSideStep( 0), m_nSubType( 0), m_dSideAngle( 0),
         m_nLeadInType( 0), m_dLiTang( 0), m_dLiPerp( 0),
-        m_nLeadOutType( 0), m_dLoTang( 0), m_dLoPerp( 0), m_dApprox( 0) {}
+        m_nLeadOutType( 0), m_dLoTang( 0), m_dLoPerp( 0), m_nLeadLinkType( 0), m_dApprox( 0) {}
    SurfFinishingData* Clone( void) const override ;
    bool CopyFrom( const MachiningData* pMdata) override ;
    bool SameAs(const MachiningData* pMdata) const override ;
@@ -76,6 +77,7 @@ struct SurfFinishingData : public MachiningData
    bool VerifySolCh( int nVal) const ;
    bool VerifySubType( int nVal) const ;
    bool VerifyLeadInType( int nVal) const ;
+   bool VerifyLeadLinkType( int nVal) const ;
    bool VerifyLeadOutType( int nVal) const ;
 } ;
 

SurfRoughing.h

@@ -1,189 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : SurfRoughing.h         Data : 24.05.24          Versione : 2.6e5
-// Contenuto : Dichiarazione della classe SurfRoughing.
-//
-//
-//
-// Modifiche : 24.05.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "Machining.h"
-#include "SurfRoughingData.h"
-#include "ToolData.h"
-#include "MachiningConst.h"
-#include "/EgtDev/Include/EGkCurveComposite.h"
-#include "/EgtDev/Include/EgtNumUtils.h"
-#include "/EgtDev/Include/EGkSurfFlatRegion.h"
-#include "/EgtDev/Include/EGkSurfTriMesh.h"
-#include "/EgtDev/Include/EGkIntersPlaneSurfTm.h"
-
-class ICAvToolSurfTm ;
-
-// struttura informazioni sui singoli percorsi
-struct PathInfo {
-   bool bOutStart ;                                // flag per entrata 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 bIsZigZagOneWayBorder ;                    // curve di bordo dei lati chiusi ( per ZigZag e OneWay)
-   PtrOwner<ICurveComposite> pCrvPath ;            // percorso del centro utensile
-   PtrOwner<ICurveComposite> pCvrRet ;             // curva di ritorno per LeadIn/Out a guida
-} ;
-// tipo percorso
-typedef std::vector<PathInfo> PATHINFOVECTOR ;
-
-// struttura informazioni per Step/SubSteps complessivi
-struct StepInfo {
-   double dDepth ;                                 // profondità dello step attuale
-   double dRelativeDepth ;                         // profondità relativa allo step al di sopra
-   double dZlocCoeffFeed ;                         // coeffiziente riduzione Feed lungo Zloc
-   int nSubType ;                                  // tipo di lavorazione dello Step corrente
-   bool bIsSubStep ;                               // step/SubStep
-   bool bInverted ;                                // se percorsi invertiti
-   PtrOwner<ISurfFlatRegion> pSfrPock ;            // regione piana di svuotatura
-   PtrOwner<ISurfFlatRegion> pSfrLimit ;           // regione piana da non svuotare
-   PtrOwner<ICurveComposite> pCompo ;              // curva selezionata per sgrossatura
-   PATHINFOVECTOR vPaths ;                         // percorsi di Pocketing
-} ;
-// tipo step
-typedef std::vector<StepInfo> STEPINFOVECTOR ;
-
-//----------------------------------------------------------------------------
-class SurfRoughing : public Machining
-{
-   public :                           // IUserObj
-      SurfRoughing* 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_SURFROUGHING ; }
-      bool IsEmpty( void) const override
-              { return ( m_nPaths == 0) ; }
-      bool UpdateStatus( int nModif) override
-              { m_nStatus |= nModif ; return true ; }
-
-   protected :                        // Operation
-      int  GetSolCh( void) const override
-              { return m_Params.m_nSolCh ; }
-      bool AdjustEndPointForAxesCalc( const CamData* pCamData, Point3d& ptP) const override ;
-
-   public :                           // Machining
-      bool Prepare( const std::string& sSawName) 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( bool* pbChanged = nullptr) override ;
-      const ToolData& GetToolData( void) const override ;
-      bool GetGeometry( SELVECTOR& vIds) const override ;
-
-   public :
-      SurfRoughing( void) ;
-
-   private :
-      bool VerifyGeometry( SelData Id, int& nSubs) ;
-      bool GetCurves( SelData Id, ICURVEPLIST& lstPC) ;
-      bool Chain( int nGrpDestId) ;
-      bool ProcessPath( int nPathId, int nTempId, int nPvId, int nClId) ;
-      bool CalcPaths( const INTINTVECTOR& vPocket, const ICRVCOMPOPOVECTOR& vCrvPocketCompo, STEPINFOVECTOR& vStepInfo) const ;
-      bool AddPocket( const INTINTVECTOR& vPocket, const Vector3d& vtTool, const ICRVCOMPOPOVECTOR& vCrvPocketCompo,
-                      double dElev, double dStep, double dSubStep, bool bSplitArcs) ;
-      bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
-      bool AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr, bool bOutMove) ;
-      bool AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
-      bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr) ;
-      bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtTool, const ICurveComposite* pCrvPath, Point3d& ptP1) const ;
-      bool VerifyLeadInLeadOut( const ICurve* pCrv, const ICurveComposite* pCrvPock, bool& bSkip) const ;
-      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,
-                       const ICurveComposite* pRCrv, bool bSplitArcs, bool bNoneForced, Point3d& ptP1) ;
-      ISurfTriMesh* GetRaw( void) const ;
-      ISurfFlatRegion* GetSfrByStmIntersection( const IntersParPlanesSurfTm& IPPStm, double dDist, double dSmallOffs = 0) const ;
-      bool GetActiveSurfaces( INTVECTOR& vSurfId) const ;
-      double GetRightFeed( const Vector3d& vtMove, const Vector3d& vtTool) const ;
-      double GetRadiusForStartEndElevation( void) const ;
-      bool AdjustPathForLeadInLeadOut( ICurveComposite* pCrvCompo, int nSubType, const ICurveComposite* pCrvPocket, bool& bOutStart, 
-                                       bool& bSingleCrv, bool& bOptTrap, bool& bIsZigZagOneWayBorder) const ;
-      bool AssignOpenEdgesForPocketCrvCompo( ICurveComposite* pCrvCompo, const ISurfFlatRegion* pSfr) const ;
-      bool ResetCurveAllTempProp( ICurve* pCurve) const ;
-      bool RemoveChunksUnderTolerance( ISurfFlatRegion* pSfr) const ;
-      bool CloseOpenEdgesUnderTolerance( ISurfFlatRegion* pSfr, double dToler) ;
-      bool ModifySurfRefForOpenCloseEdges( ISurfFlatRegion* pSfrRef, const ICurveComposite* pCrvCompo) const ;
-      bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfFlatRegion* pSfrRef) const ;
-      bool SimplifyCurve( ICurveComposite* pCompo) const ;
-      bool SimplyfySfr( ISurfFlatRegion* pSfr) const ;
-      bool CheckSafetyLinearLink( const Point3d& ptCurr, const ISurfFlatRegion* pSfrLimit, const Vector3d& vtTool, 
-                                  const Point3d& ptDest, 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 ;
-
-   private :
-      double GetSpeed() const
-         { return ( IsNullAngValue( m_Params.m_dSpeed) ? m_TParams.m_dSpeed : m_Params.m_dSpeed) ; }
-      double GetFeed() const
-         { return ( IsNullLenValue( m_Params.m_dFeed) ? m_TParams.m_dFeed : m_Params.m_dFeed) ; }
-      double GetAdaptedCoeffFeed( bool bSubStep, int nNumStep, double dStep, double dSubStep) const
-         {   return ( 1. + ( bSubStep ? ( nNumStep + 1) * dSubStep / dStep : 0.)) ; }
-      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) ; }
-      double GetOffsR() const
-         { double dCurrOffsR = IsUnknownValue( m_Params.m_dOffsR) ? m_TParams.m_dOffsR : m_Params.m_dOffsR ; 
-           return std::max( 0.1, dCurrOffsR) ; }
-      double GetOffsL() const
-         { return ( IsUnknownValue( m_Params.m_dOffsL) ? m_TParams.m_dOffsL : m_Params.m_dOffsL) ; }
-      double GetSideStep( void) const
-         { return Clamp( m_Params.m_dSideStep, 0.1, m_TParams.m_dTDiam) ; }
-      int GetLeadInType( void) const
-         { if ( m_Params.m_dLiTang < std::min( 0.1 * m_TParams.m_dDiam, 1.0))
-              return SURFROU_LI_NONE ;
-           if ( m_Params.m_nLeadInType != SURFROU_LI_GLIDE  &&  m_Params.m_dLiElev < 10 * EPS_SMALL)
-              return SURFROU_LI_NONE ;
-           return m_Params.m_nLeadInType ; }
-      int GetLeadOutType( void) const
-         { if ( m_Params.m_dLoTang < std::min( 0.1 * m_TParams.m_dDiam, 1.0))
-              return SURFROU_LO_NONE ;
-           return m_Params.m_nLeadOutType ; }
-
-      /* debug functions */
-       void DrawLoopsSurf( const ISurfFlatRegion* pSfr, bool bWithSurf, Color Col, bool bAlphaCoverage, int nStep) ;
-       void DrawFeed( const ICurveComposite* pCrv, int nStep) ;
-      /* end debug functions */
-
-   private :
-      SELVECTOR         m_vId ;             // identificativi entità geometriche da lavorare
-      SurfRoughingData  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
-      int               m_nStatus ;         // stato di aggiornamento della lavorazione
-      int               m_nPaths ;          // numero di percorsi di lavoro generati
-      double            m_dMaxHelixRad ;    // raggio massimo attacco ad elica nel caso di cerchi
-      double            m_dSubStepToler ;   // tolleranza di rimozione chunk per SubSteps
-} ;

SurfRoughingData.cpp

@@ -1,713 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : SurfRoughingData.cpp      Data : 24.05.24        Versione :  2.6e5
-// Contenuto : Implementazione struttura dati lavorazione sgrossatura superfici.
-//
-//
-//
-// Modifiche : 24.05.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-//--------------------------- Include ----------------------------------------
-#include "stdafx.h"
-#include "SurfRoughingData.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 nSurfRoughingKey {
-   KEY_AB = 0,
-   KEY_AI,
-   KEY_APPR,
-   KEY_DH,
-   KEY_F,
-   KEY_FE,
-   KEY_FS,
-   KEY_FT,
-   KEY_INV,
-   KEY_LIEL,
-   KEY_LITG,
-   KEY_LITY,
-   KEY_LOTG,
-   KEY_LOTY,
-   KEY_NAME,
-   KEY_NNS,
-   KEY_NNU,
-   KEY_OL,
-   KEY_OR,
-   KEY_PS,
-   KEY_S,
-   KEY_SA,
-   KEY_SCC,
-   KEY_SS,
-   KEY_SST,
-   KEY_ST,
-   KEY_SUBTYPE,
-   KEY_TNAME,
-   KEY_TUUID,
-   KEY_UUID,
-   KEY_ZZZ} ;        // rappresenta il numero di elementi
-
-static const array<string,KEY_ZZZ> sSurfRoughingKey = {
-   "AB",
-   "AI",
-   "APPR",
-   "DH",
-   "F",
-   "FE",
-   "FS",
-   "FT",
-   "INV",
-   "LIEL",
-   "LITG",
-   "LITY",
-   "LOTG",
-   "LOTY",
-   "NAME",
-   "NNS",
-   "NNU",
-   "OL",
-   "OR",
-   "PS",
-   "S",
-   "SA",
-   "SCC",
-   "SS",
-   "SST",
-   "ST",
-   "SUB",
-   "TN",
-   "TU",
-   "UUID"} ;
-
-//----------------------------------------------------------------------------
-MCHDATA_REGISTER( MT_SURFROUGHING, "SURFROUGHING", SurfRoughingData) ;
-
-//----------------------------------------------------------------------------
-SurfRoughingData*
-SurfRoughingData::Clone( void) const
-{
-  // alloco oggetto
-   SurfRoughingData* pMdata = new(nothrow) SurfRoughingData ;
-  // copio i dati
-   if ( pMdata != nullptr) {
-      if ( ! pMdata->CopyFrom( this)) {
-         delete pMdata ;
-         return nullptr ;
-      }
-   }
-   return pMdata ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::CopyFrom( const MachiningData* pMdata)
-{
-  // è inutile copiare se sorgente coincide con destinazione
-   if ( pMdata == this)
-      return true ;
-  // la sorgente deve essere dello stesso tipo
-   const SurfRoughingData* pSdata = GetSurfRoughingData( pMdata) ;
-   if ( pSdata == nullptr)
-      return false ;
-  // eseguo copia
-   m_Uuid = pSdata->m_Uuid ;
-   m_sName = pSdata->m_sName ;
-   m_ToolUuid = pSdata->m_ToolUuid ;
-   m_sToolName = pSdata->m_sToolName ;
-   m_sBlockedAxis = pSdata->m_sBlockedAxis ;
-   m_sInitAngs = pSdata->m_sInitAngs ;
-   m_nSolCh = pSdata->m_nSolCh ;
-   m_dSpeed = pSdata->m_dSpeed ;
-   m_dFeed = pSdata->m_dFeed ;
-   m_dEndFeed = pSdata->m_dEndFeed ;
-   m_dStartFeed = pSdata->m_dStartFeed ;
-   m_dTipFeed = pSdata->m_dTipFeed ;
-   m_dOffsR = pSdata->m_dOffsR ;
-   m_dOffsL = pSdata->m_dOffsL ;
-   m_bInvert = pSdata->m_bInvert ;
-   m_sDepth = pSdata->m_sDepth ;
-   m_dStartPos = pSdata->m_dStartPos ;
-   m_dStep = pSdata->m_dStep ;
-   m_dSubStep = pSdata->m_dSubStep ;
-   m_dSideStep = pSdata->m_dSideStep ;
-   m_nSubType = pSdata->m_nSubType ;
-   m_dSideAngle = pSdata->m_dSideAngle ;
-   m_nLeadInType = pSdata->m_nLeadInType ;
-   m_dLiElev = pSdata->m_dLiElev ;
-   m_dLiTang = pSdata->m_dLiTang ;
-   m_nLeadOutType = pSdata->m_nLeadOutType ;
-   m_dLoTang = pSdata->m_dLoTang ;
-   m_dApprox = pSdata->m_dApprox ;
-   m_sSysNotes = pSdata->m_sSysNotes ;
-   m_sUserNotes = pSdata->m_sUserNotes ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::SameAs(const MachiningData* pMdata) const
-{
-  // se coincide con altro -> uguali
-   if ( pMdata == this)
-      return true ;
-  // se sono di tipo diverso -> diversi
-   const SurfRoughingData* pSdata = GetSurfRoughingData( pMdata) ;
-   if ( pSdata == nullptr)
-      return false ;
-  // confronto termine a termine
-   return ( m_Uuid == pSdata->m_Uuid  &&
-            m_sName == pSdata->m_sName  &&
-            m_ToolUuid == pSdata->m_ToolUuid  &&
-            m_sToolName == pSdata->m_sToolName  &&
-            m_sBlockedAxis == pSdata->m_sBlockedAxis  &&
-            m_sInitAngs == pSdata->m_sInitAngs  &&
-            m_nSolCh == pSdata->m_nSolCh  &&
-            abs( m_dSpeed - pSdata->m_dSpeed) < EPS_MACH_ANG_PAR  &&
-            abs( m_dFeed - pSdata->m_dFeed) < EPS_MACH_LEN_PAR  &&
-            abs( m_dEndFeed - pSdata->m_dEndFeed) < EPS_MACH_LEN_PAR  &&
-            abs( m_dStartFeed - pSdata->m_dStartFeed) < EPS_MACH_LEN_PAR  &&
-            abs( m_dTipFeed - pSdata->m_dTipFeed) < EPS_MACH_LEN_PAR  &&
-            abs( m_dOffsR - pSdata->m_dOffsR) < EPS_MACH_LEN_PAR  &&
-            abs( m_dOffsL - pSdata->m_dOffsL) < EPS_MACH_LEN_PAR  &&
-            m_bInvert == pSdata->m_bInvert  &&
-            m_sDepth == pSdata->m_sDepth  &&
-            abs( m_dStartPos - pSdata->m_dStartPos) < EPS_MACH_LEN_PAR  &&
-            abs( m_dStep - pSdata->m_dStep) < EPS_MACH_LEN_PAR  &&
-            abs( m_dSubStep - pSdata->m_dSubStep) < EPS_MACH_LEN_PAR  &&
-            abs( m_dSideStep - pSdata->m_dSideStep) < EPS_MACH_LEN_PAR  &&
-            m_nSubType == pSdata->m_nSubType  &&
-            abs( m_dSideAngle - pSdata->m_dSideAngle) < EPS_MACH_ANG_PAR  &&
-            m_nLeadInType == pSdata->m_nLeadInType  &&
-            abs( m_dLiElev - pSdata->m_dLiElev) < EPS_MACH_LEN_PAR  &&
-            abs( m_dLiTang - pSdata->m_dLiTang) < EPS_MACH_LEN_PAR  &&
-            m_nLeadOutType == pSdata->m_nLeadOutType  &&
-            abs( m_dLoTang - pSdata->m_dLoTang) < EPS_MACH_LEN_PAR  &&
-            abs( m_dApprox - pSdata->m_dApprox) < EPS_MACH_LEN_PAR  &&
-            m_sSysNotes == pSdata->m_sSysNotes  &&
-            m_sUserNotes == pSdata->m_sUserNotes) ;
-}
-
-//----------------------------------------------------------------------------
-int
-SurfRoughingData::GetSize( void) const
-{
-  // in debug verifico validità ultimo campo
-   assert( sSurfRoughingKey[KEY_UUID] == "UUID") ;
-   return KEY_ZZZ ;
-}
-//----------------------------------------------------------------------------
-string
-SurfRoughingData::GetTitle( void) const
-{
-   return MCHDATA_GETNAME( SurfRoughingData) ;
-}
-
-//----------------------------------------------------------------------------
-int
-FindSurfRoughingKey( const string& sKey)
-{
-   auto TheRange = equal_range( sSurfRoughingKey.cbegin(), sSurfRoughingKey.cend(), sKey) ;
-   if ( TheRange.first == TheRange.second)
-      return -1 ;
-   return int( TheRange.first - sSurfRoughingKey.cbegin()) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::FromString( const string& sString, int& nKey)
-{
-  // separo chiave da valore
-   string sKey, sVal ;
-   SplitFirst( sString, "=", sKey, sVal) ;
-  // riconosco la chiave
-   nKey = FindSurfRoughingKey( ToUpper( sKey)) ;
-   bool bOk = ( nKey >= 0) ;
-   switch ( nKey) {
-   case KEY_AB :
-      m_sBlockedAxis = sVal ;
-      break ;
-   case KEY_AI :
-      m_sInitAngs = sVal ;
-      break ;
-   case KEY_APPR :
-      bOk = ::FromString( sVal, m_dApprox) ;
-      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_LIEL :
-      bOk = ::FromString( sVal, m_dLiElev) ;
-      break ;
-   case KEY_LITG :
-      bOk = ::FromString( sVal, m_dLiTang) ;
-      break ;
-   case KEY_LITY :
-      bOk = ::FromString( sVal, m_nLeadInType) ;
-      break ;
-   case KEY_LOTG :
-      bOk = ::FromString( sVal, m_dLoTang) ;
-      break ;
-   case KEY_LOTY :
-      bOk = ::FromString( sVal, m_nLeadOutType) ;
-      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_OR :
-      bOk = ::FromString( sVal, m_dOffsR) ;
-      break ;
-   case KEY_OL :
-      bOk = ::FromString( sVal, m_dOffsL) ;
-      break ;
-   case KEY_PS :
-      bOk = ::FromString( sVal, m_dStartPos) ;
-      break ;
-   case KEY_S :
-      bOk = ::FromString( sVal, m_dSpeed) ;
-      break ;
-   case KEY_SA :
-      bOk = ::FromString( sVal, m_dSideAngle) ;
-      break ;
-   case KEY_SCC :
-      bOk = ::FromString( sVal, m_nSolCh) ;
-      break ;
-   case KEY_SST :
-      bOk = ::FromString( sVal, m_dSubStep) ;
-      break ;
-   case KEY_SS :
-      bOk = ::FromString( sVal, m_dSideStep) ;
-      break ;
-   case KEY_ST :
-      bOk = ::FromString( sVal, m_dStep) ;
-      break ;
-   case KEY_SUBTYPE :
-      bOk = ::FromString( sVal, m_nSubType) ;
-      break ;
-   case KEY_TNAME :
-      m_sToolName = sVal ;
-      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
-SurfRoughingData::ToString( int nInd) const
-{
-   switch ( nInd) {
-   case KEY_AB : return ( sSurfRoughingKey[KEY_AB] + "=" + m_sBlockedAxis) ;
-   case KEY_AI : return ( sSurfRoughingKey[KEY_AI] + "=" + m_sInitAngs) ;
-   case KEY_APPR : return ( sSurfRoughingKey[KEY_APPR] + "=" + ::ToString(m_dApprox)) ;
-   case KEY_DH : return ( sSurfRoughingKey[KEY_DH] + "=" + m_sDepth) ;
-   case KEY_F : return ( sSurfRoughingKey[KEY_F] + "=" + ::ToString( m_dFeed)) ;
-   case KEY_FE : return ( sSurfRoughingKey[KEY_FE] + "=" + ::ToString( m_dEndFeed)) ;
-   case KEY_FS : return ( sSurfRoughingKey[KEY_FS] + "=" + ::ToString( m_dStartFeed)) ;
-   case KEY_FT : return ( sSurfRoughingKey[KEY_FT] + "=" + ::ToString( m_dTipFeed)) ;
-   case KEY_INV : return ( sSurfRoughingKey[KEY_INV] + "=" + ::ToString( m_bInvert)) ;
-   case KEY_LIEL : return ( sSurfRoughingKey[KEY_LIEL] + "=" + ::ToString( m_dLiElev)) ;
-   case KEY_LITG : return ( sSurfRoughingKey[KEY_LITG] + "=" + ::ToString( m_dLiTang)) ;
-   case KEY_LITY : return ( sSurfRoughingKey[KEY_LITY] + "=" + ::ToString( m_nLeadInType)) ;
-   case KEY_LOTG : return ( sSurfRoughingKey[KEY_LOTG] + "=" + ::ToString( m_dLoTang)) ;
-   case KEY_LOTY : return ( sSurfRoughingKey[KEY_LOTY] + "=" + ::ToString( m_nLeadOutType)) ;
-   case KEY_NAME : return ( sSurfRoughingKey[KEY_NAME] + "=" + m_sName) ;
-   case KEY_NNS : return ( sSurfRoughingKey[KEY_NNS] + "=" + m_sSysNotes) ;
-   case KEY_NNU : return ( sSurfRoughingKey[KEY_NNU] + "=" + m_sUserNotes) ;
-   case KEY_OL : return ( sSurfRoughingKey[KEY_OL] + "=" + ::ToString( m_dOffsL)) ;
-   case KEY_OR : return ( sSurfRoughingKey[KEY_OR] + "=" + ::ToString( m_dOffsR)) ;
-   case KEY_PS : return ( sSurfRoughingKey[KEY_PS] + "=" + ::ToString( m_dStartPos)) ;
-   case KEY_S : return ( sSurfRoughingKey[KEY_S] + "=" + ::ToString( m_dSpeed)) ;
-   case KEY_SA : return ( sSurfRoughingKey[KEY_SA] + "=" + ::ToString( m_dSideAngle)) ;
-   case KEY_SCC : return ( sSurfRoughingKey[KEY_SCC] + "=" + ::ToString( m_nSolCh)) ;
-   case KEY_SST : return ( sSurfRoughingKey[KEY_SST] + "=" + ::ToString( m_dSubStep)) ;
-   case KEY_SS : return ( sSurfRoughingKey[KEY_SS] + "=" + ::ToString( m_dSideStep)) ;
-   case KEY_ST : return ( sSurfRoughingKey[KEY_ST] + "=" + ::ToString( m_dStep)) ;
-   case KEY_SUBTYPE : return ( sSurfRoughingKey[KEY_SUBTYPE] + "=" + ::ToString( m_nSubType)) ;
-   case KEY_TNAME : return ( sSurfRoughingKey[KEY_TNAME] + "=" + m_sToolName) ;
-   case KEY_TUUID : return ( sSurfRoughingKey[KEY_TUUID] + "=" + ::ToString( m_ToolUuid)) ;
-   case KEY_UUID : return ( sSurfRoughingKey[KEY_UUID] + "=" + ::ToString( m_Uuid)) ;
-   default : return "" ;
-   }
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::IsOptional( int nKey) const
-{
-   return ( nKey == KEY_LIEL  ||  nKey == KEY_SST) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::VerifySolCh( int nVal) const
-{
-   return IsValidOperationScc( nVal) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::VerifySubType( int nVal) const
-{
-   return ( nVal == SURFROU_SUB_ZIGZAG  ||  nVal == SURFROU_SUB_ONEWAY  ||
-            nVal == SURFROU_SUB_SPIRALIN  ||  nVal == SURFROU_SUB_SPIRALOUT  ||
-            nVal == SURFROU_SUB_CONFORMAL_ZIGZAG  ||  nVal == SURFROU_SUB_CONFORMAL_ONEWAY) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::VerifyLeadInType( int nVal) const
-{
-   return ( nVal == SURFROU_LI_NONE  ||  nVal == SURFROU_LI_GLIDE  ||
-            nVal == SURFROU_LI_ZIGZAG  ||  nVal == SURFROU_LI_HELIX) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::VerifyLeadOutType( int nVal) const
-{
-   return ( nVal == SURFROU_LO_NONE  ||  nVal == SURFROU_LO_GLIDE) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::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_MILL) == 0)
-      return false ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::GetTool( const ToolsMgr* pToolsMgr, const ToolData*& pTdata) const
-{
-   if ( pToolsMgr == nullptr)
-      return false ;
-   pTdata = pToolsMgr->GetTool( m_ToolUuid) ;
-   return ( pTdata != nullptr) ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::SetParam( int nType, bool bVal)
-{
-   switch ( nType) {
-   case MPA_INVERT :
-      m_bInvert = bVal ;
-      return true ;
-   }
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::SetParam( int nType, int nVal)
-{
-   switch ( nType) {
-   case MPA_LEADINTYPE :
-      if ( ! VerifyLeadInType( nVal))
-         return false ;
-      m_nLeadInType = nVal ;
-      return true ;
-   case MPA_LEADOUTTYPE :
-      if ( ! VerifyLeadOutType( nVal))
-         return false ;
-      m_nLeadOutType = nVal ;
-      return true ;
-   case MPA_SCC :
-      if ( ! VerifySolCh( nVal))
-         return false ;
-      m_nSolCh = nVal ;
-      return true ;
-   case MPA_SUBTYPE :
-      if ( ! VerifySubType( nVal))
-         return false ;
-      m_nSubType = nVal ;
-      return true ;
-   }
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::SetParam( int nType, double dVal)
-{
-   switch ( nType) {
-   case MPA_SPEED :
-      m_dSpeed = dVal ;
-      return true ;
-   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_OFFSR :
-      m_dOffsR = dVal ;
-      return true ;
-   case MPA_OFFSL :
-      m_dOffsL = dVal ;
-      return true ;
-   case MPA_DEPTH :
-      m_sDepth = ::ToString( dVal) ;
-      return true ;
-   case MPA_STARTPOS :
-      m_dStartPos = dVal ;
-      return true ;
-   case MPA_STEP :
-      m_dStep = dVal ;
-      return true ;
-   case MPA_SUBSTEP :
-      m_dSubStep = dVal ;
-      return true ;
-   case MPA_SIDESTEP :
-      m_dSideStep = dVal ;
-      return true ;
-   case MPA_SIDEANGLE :
-      m_dSideAngle = dVal ;
-      return true ;
-   case MPA_LIELEV :
-      m_dLiElev = dVal ;
-      return true ;
-   case MPA_LITANG :
-      m_dLiTang = dVal ;
-      return true ;
-   case MPA_LOTANG :
-      m_dLoTang = dVal ;
-      return true ;
-   case MPA_APPROX :
-      m_dApprox = dVal ;
-      return true ;
-   }
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::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
-SurfRoughingData::ResetTool( void)
-{
-   m_sToolName.clear() ;
-   m_ToolUuid.Clear() ;
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::GetParam( int nType, bool& bVal) const
-{
-   switch ( nType) {
-   case MPA_INVERT :
-      bVal = m_bInvert ;
-      return true ;
-   }
-   bVal = false ;
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::GetParam( int nType, int& nVal) const
-{
-   switch ( nType) {
-   case MPA_TYPE :
-      nVal = MT_SURFROUGHING ;
-      return true ;
-   case MPA_SUBTYPE :
-      nVal = m_nSubType ;
-      return true ;
-   case MPA_LEADINTYPE :
-      nVal = m_nLeadInType ;
-      return true ;
-   case MPA_LEADOUTTYPE :
-      nVal = m_nLeadOutType ;
-      return true ;
-   case MPA_SCC :
-      nVal = m_nSolCh ;
-      return true ;
-   }
-   nVal = 0 ;
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::GetParam( int nType, double& dVal) const
-{
-   switch ( nType) {
-   case MPA_SPEED :
-      dVal = m_dSpeed ;
-      return true ;
-   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_OFFSR :
-      dVal = m_dOffsR ;
-      return true ;
-   case MPA_OFFSL :
-      dVal = m_dOffsL ;
-      return true ;
-   case MPA_STARTPOS :
-      dVal = m_dStartPos ;
-      return true ;
-   case MPA_STEP :
-      dVal = m_dStep ;
-      return true ;
-   case MPA_SUBSTEP :
-      dVal = m_dSubStep ;
-      return true ;
-   case MPA_SIDESTEP :
-      dVal = m_dSideStep ;
-      return true ;
-   case MPA_SIDEANGLE :
-      dVal = m_dSideAngle ;
-      return true ;
-   case MPA_LIELEV :
-      dVal = m_dLiElev ;
-      return true ;
-   case MPA_LITANG :
-      dVal = m_dLiTang ;
-      return true ;
-   case MPA_LOTANG :
-      dVal = m_dLoTang ;
-      return true ;
-   case MPA_APPROX :
-      dVal = m_dApprox ;
-      return true ;
-   }
-   dVal = 0 ;
-   return false ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfRoughingData::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 ;
-}

SurfRoughingData.h

@@ -1,92 +0,0 @@
-//----------------------------------------------------------------------------
-//  EgalTech 2024-2024
-//----------------------------------------------------------------------------
-// File : SurfRoughingData.h      Data : 24.05.24       Versione : 2.6e5
-// Contenuto : Dichiarazione della struct SurfRoughingData e costanti associate.
-//
-//
-//
-// Modifiche : 24.05.24 DS Creazione modulo.
-//
-//
-//----------------------------------------------------------------------------
-
-#pragma once
-
-#include "MachiningData.h"
-
-//----------------------------------------------------------------------------
-struct SurfRoughingData : 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_dSpeed ;          // velocità di rotazione (+ se CCW, - se CW)  ( se 0 da utensile)
-   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 testa  ( se 0 da utensile)
-   double      m_dOffsR ;          // offset radiale ( se UNKNOWN_PAR da utensile)
-   double      m_dOffsL ;          // offset longitudinale ( se UNKNOWN_PAR da utensile)
-   bool        m_bInvert ;         // flag di inversione direzione lavorazione
-   std::string m_sDepth ;          // affondamento massimo (espressione numerica)
-   double      m_dStartPos ;       // quota di inizio lavorazione (sempre >= 0)
-   double      m_dStep ;           // passo di affondamento (0=nessun passo)
-   double      m_dSideStep ;       // distanza tra le passate
-   double      m_dSubStep ;        // distanza tra le passate intermedie
-   int         m_nSubType ;        // tipo di lavorazione ( ZigZag, OneWay, SpiralIn, SpiralOut)
-   double      m_dSideAngle ;      // angolo dello ZigZag da X+ locale
-   int         m_nLeadInType ;     // tipo di attacco (nessuno, lineare, tangente, inseguimento)
-   double      m_dLiTang ;         // distanza tangente da inizio attacco
-   double      m_dLiElev ;         // elevazione di uno step di attacco
-   int         m_nLeadOutType ;    // tipo di uscita (come attacco, nessuno, lineare, tangente, inseguimento)
-   double      m_dLoTang ;         // distanza tangente verso fine uscita
-   double      m_dApprox ;         // valore di approssimazione per superfici
-   std::string m_sSysNotes ;       // note interne
-   std::string m_sUserNotes ;      // note dell'utente
-
-   SurfRoughingData( void)
-      : m_ToolUuid(), m_nSolCh( 0), m_dSpeed( 0), m_dFeed( 0), m_dStartFeed( 0), m_dEndFeed( 0), m_dTipFeed( 0),
-        m_dOffsR( UNKNOWN_PAR), m_dOffsL( UNKNOWN_PAR), m_bInvert( false),
-        m_dStartPos( 0), m_dStep( 0), m_dSideStep( 0), m_dSubStep( 0), m_nSubType( 0), m_dSideAngle( 0),
-        m_nLeadInType( 0), m_dLiTang( 0), m_dLiElev( 0),
-        m_nLeadOutType( 0), m_dLoTang( 0), m_dApprox( 0) {}
-   SurfRoughingData* Clone( void) const override ;
-   bool CopyFrom( const MachiningData* pMdata) override ;
-   bool SameAs(const MachiningData* pMdata) const override ;
-   int GetType( void) const override
-          { return MT_SURFROUGHING ; }
-   int GetSize( void) const override ;
-   std::string GetTitle( void) const override ;
-   bool FromString( const std::string& sString, int& nKey) override ;
-   std::string ToString( int nInd) 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 ;
-   bool VerifySubType( int nVal) const ;
-   bool VerifyLeadInType( int nVal) const ;
-   bool VerifyLeadLinkType( int nVal) const ;
-   bool VerifyLeadOutType( int nVal) const ;
-} ;
-
-//----------------------------------------------------------------------------
-inline const SurfRoughingData* GetSurfRoughingData( const MachiningData* pMdata)
-               { if ( pMdata == nullptr  ||  pMdata->GetType() != MT_SURFROUGHING)
-                    return nullptr ;
-                 return ( static_cast<const SurfRoughingData*>( pMdata)) ; }
-inline SurfRoughingData* GetSurfRoughingData( MachiningData* pMdata)
-               { if ( pMdata == nullptr  ||  pMdata->GetType() != MT_SURFROUGHING)
-                    return nullptr ;
-                 return ( static_cast<SurfRoughingData*>( pMdata)) ; }

Table.cpp

@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2015
 //----------------------------------------------------------------------------
-// File : Table.cpp       Data : 19.03.24          Versione : 2.6c2
+// File : Table.cpp       Data : 25.05.15          Versione : 1.6e7
 // Contenuto : Oggetto tavola per gruppo tavola di macchina.
 //
 //
@@ -45,7 +45,6 @@ Table::Clone( void) const
             pTab->m_sName = m_sName ;
             pTab->m_nType = m_nType ;
             pTab->m_ptRef1 = m_ptRef1 ;
-            pTab->m_vsColl = m_vsColl ;
       }
       catch( ...) {
          delete pTab ;
@@ -64,10 +63,7 @@ Table::Dump( string& sOut, bool bMM, const char* szNewLine) const
    sOut += "Id=" + ToString( m_nOwnerId) + szNewLine ;
    sOut += "Name=" + m_sName + szNewLine ;
    sOut += "Type=" + ToString( m_nType) + szNewLine ;
-   sOut += "Ref1=(" + ToString( GetInUiUnits( m_ptRef1, bMM), 4) + ")" + szNewLine ;
-   sOut += "Area1=(" + ToString( GetInUiUnits( m_b3Area1.GetMin(), bMM), 4) + ";" +
-                       ToString( GetInUiUnits( m_b3Area1.GetMax(), bMM), 4) + szNewLine ;
-   sOut += "Coll=" + ToString( m_vsColl) + szNewLine ;
+   sOut += "Ref1=(" + ToString( GetInUiUnits(m_ptRef1, bMM), 4) + ")" + szNewLine ;
    return true ;
 }
 
@@ -103,12 +99,11 @@ Table::Table( void)
 
 //----------------------------------------------------------------------------
 bool
-Table::Set( const string& sName, int nType, const Point3d& ptRef1, const BBox3d& b3Area1, const STRVECTOR& vsColl)
+Table::Set( const string& sName, int nType, const Point3d& ptRef1, const BBox3d& b3Area1)
 {
    m_sName = sName ;
    m_nType = nType ;
    m_ptRef1 = ptRef1 ;
    m_b3Area1 = b3Area1 ;
-   m_vsColl = vsColl ;
    return true ;
 }

Table.h

@@ -30,7 +30,7 @@ class Table : public IUserObj
 
    public :
       Table( void) ;
-      bool Set( const std::string& sName, int nType, const Point3d& ptRef1, const BBox3d& b3Area1, const STRVECTOR& vsColl) ;
+      bool Set( const std::string& sName, int nType, const Point3d& ptRef1, const BBox3d& b3Area1) ;
       const std::string& GetName( void)
                { return m_sName ; }
       int GetType( void)
@@ -39,8 +39,6 @@ class Table : public IUserObj
                { return m_ptRef1 ; }
       const BBox3d& GetArea1( void) 
                { return m_b3Area1 ; }
-      const STRVECTOR& GetCollGroups( void) const
-               { return m_vsColl ; }
 
    private :
       int         m_nOwnerId ;
@@ -49,5 +47,4 @@ class Table : public IUserObj
       int         m_nType ;
       Point3d     m_ptRef1 ;
       BBox3d      m_b3Area1 ;
-      STRVECTOR   m_vsColl ;
 } ;

ToolData.h

@@ -108,4 +108,4 @@ SameTool( const ToolData& Td1, const ToolData& Td2, bool bAlsoNameTcPosHeadExit
             abs( Td1.m_dMinFeed - Td2.m_dMinFeed) < EPS_FEED  &&
             Td1.m_sSysNotes == Td2.m_sSysNotes  &&
             Td1.m_sUserNotes == Td2.m_sUserNotes) ;
-}
+}

ToolsMgr.cpp

@@ -551,11 +551,6 @@ ToolsMgr::SaveCurrTool( void)
          m_suData.emplace( m_tdCurrTool.m_sName, m_tdCurrTool.m_Uuid) ;
       }
    }
-  // se fresa adatto sottotipo a seconda della capacità di lavorare di testa
-   if ( m_tdCurrTool.m_nType == TT_MILL_STD  &&  m_tdCurrTool.m_dTipFeed < EPS_SMALL)
-      m_tdCurrTool.m_nType = TT_MILL_NOTIP ;
-   else if ( m_tdCurrTool.m_nType == TT_MILL_NOTIP  &&  m_tdCurrTool.m_dTipFeed > EPS_SMALL)
-      m_tdCurrTool.m_nType = TT_MILL_STD ;
   // eseguo salvataggio
    m_bModified = true ;
    if ( find( m_utModified.begin(), m_utModified.end(), m_tdCurrTool.m_Uuid) == m_utModified.end())
@@ -743,11 +738,10 @@ ToolsMgr::GetCurrToolThDiam( double& dThDiam) const
    if ( ! m_bCurrTool)
       return false ;
 
-  // se punta a forare, lama, fresa,  mortasatrice/sega a catena o scalpello
+  // se punta a forare, lama, fresa o scalpello
    if ( ( m_tdCurrTool.m_nType & TF_DRILLBIT) != 0  ||
         ( m_tdCurrTool.m_nType & TF_SAWBLADE) != 0  ||
         ( m_tdCurrTool.m_nType & TF_MILL) != 0  ||
-        ( m_tdCurrTool.m_nType & TF_MORTISE) != 0  ||
         ( m_tdCurrTool.m_nType & TF_CHISEL) != 0) {
      // recupero le dimensioni del porta utensili
       double dTHoldBase = 0 ;
@@ -767,8 +761,9 @@ ToolsMgr::GetCurrToolThDiam( double& dThDiam) const
       dThDiam = dTHoldDiam ;
       return true ;
    }
-  // se waterjet
-   else if ( ( m_tdCurrTool.m_nType & TF_WATERJET) != 0) {
+  // se mortasatrice/sega a catena o waterjet
+   else if ( ( m_tdCurrTool.m_nType & TF_MORTISE) != 0  ||
+             ( m_tdCurrTool.m_nType & TF_WATERJET) != 0) {
       dThDiam = 0 ;
       return true ;
    }
@@ -784,11 +779,10 @@ ToolsMgr::GetCurrToolThLength( double& dThLen) const
    if ( ! m_bCurrTool)
       return false ;
 
-  // se punta a forare, lama, fresa, mortasatrice/sega a catena o scalpello
+  // se punta a forare, lama, fresa o scalpello
    if ( ( m_tdCurrTool.m_nType & TF_DRILLBIT) != 0  ||
         ( m_tdCurrTool.m_nType & TF_SAWBLADE) != 0  ||
         ( m_tdCurrTool.m_nType & TF_MILL) != 0  ||
-        ( m_tdCurrTool.m_nType & TF_MORTISE) != 0  ||
         ( m_tdCurrTool.m_nType & TF_CHISEL) != 0) {
      // recupero le dimensioni del porta utensili
       double dTHoldBase = 0 ;
@@ -808,8 +802,9 @@ ToolsMgr::GetCurrToolThLength( double& dThLen) const
       dThLen = dTHoldLen ;
       return true ;
    }
-  // se waterjet
-   else if ( ( m_tdCurrTool.m_nType & TF_WATERJET) != 0) {
+  // se mortasatrice/sega a catena o waterjet
+   else if ( ( m_tdCurrTool.m_nType & TF_MORTISE) != 0  ||
+             ( m_tdCurrTool.m_nType & TF_WATERJET) != 0) {
       dThLen = 0 ;
       return true ;
    }

WaterJetting.h

@@ -80,9 +80,9 @@ class WaterJetting : public Machining
       bool AddLeadInPreview( const ICurveComposite* pCompo, ISurfFlatRegion* pSPV) ;
       bool AddLeadOutPreview( const ICurveComposite* pCompo, ISurfFlatRegion* pSPV) ;
       bool AddLoopsPreview( const ICurveComposite* pCompo, ISurfFlatRegion* pSPV) ;
-      bool AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTool, bool bSplitArcs, double dAddedOverlap) ;
-      bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, bool bSplit) ;
-      bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, bool bSplit) ;
+      bool AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTool, bool bSplitArcs) ;
+      bool AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ) ;
+      bool AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ) ;
       bool CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtN,
                             const ICurveComposite* pCompo, Point3d& ptP1) const ;
       bool AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
@@ -90,6 +90,8 @@ class WaterJetting : public Machining
       bool AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vector3d& vtN,
                        bool bSplitArcs, Point3d& ptP1) ;
       double GetRadiusForStartEndElevation( void) const ;
+      bool GetPointOutOfRaw( const Point3d& ptP, const Vector3d& vtTool, double dElev) const ;
+      bool GetPointAboveRaw( const Point3d& ptP) const ;
       bool SetToolCorrAuxDir( const Vector3d& vtTool, const Vector3d& vtCorr) ;
       bool CalcAndSetToolCorrAuxDir( const ICurveComposite* pCompo, double dU) ;
       Vector3d CalcToolDir( const ICurveComposite* pCompo, double dU) ;

WaterJettingData.cpp

@@ -133,7 +133,7 @@ WaterJettingData::Clone( void) const
 bool
 WaterJettingData::CopyFrom( const MachiningData* pMdata)
 {
-  // è inutile copiare se sorgente coincide con destinazione
+  // è inutile copiare se sorgente coincide con destinazione
    if ( pMdata == this)
       return true ;
   // la sorgente deve essere dello stesso tipo
@@ -242,7 +242,7 @@ WaterJettingData::SameAs( const MachiningData* pMdata) const
 int
 WaterJettingData::GetSize( void) const
 {
-  // in debug verifico validità ultimo campo
+  // in debug verifico validità ultimo campo
    assert( sWaterJettingKey[KEY_WS] == "WS") ;
    return KEY_ZZZ ;
 }
@@ -486,7 +486,7 @@ WaterJettingData::VerifyExtCornerType( int nVal) const
 bool
 WaterJettingData::VerifyIntCornerType( int nVal) const
 {
-   return ( nVal == WJET_IC_NONE  ||  nVal == WJET_IC_SLOW  ||  nVal == WJET_IC_SLOW_FULL) ;
+   return ( nVal == WJET_IC_NONE  ||  nVal == WJET_IC_SLOW) ;
 }
 
 //----------------------------------------------------------------------------