EgtMachKernel :

- Aggiunta funzione per tasche passanti per volumi esterni al grezzo. - migliorata la gestione dei lati aperti piccoli ( da testare ) - migliorie varie .
EgtMachKernel :
2024-03-13 11:23:07 +01:00 · 2024-03-12 13:37:00 +01:00 · 2024-03-04 13:26:55 +01:00 · 2024-03-04 13:26:39 +01:00 · 2024-03-01 17:51:23 +01:00 · 2024-02-26 16:10:46 +01:00
35 changed files with 13644 additions and 4775 deletions
@@ -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)
@@ -618,7 +618,7 @@ Drilling::Apply( bool bRecalc, bool bPostApply)

  // 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") ;
+      m_pMchMgr->SetLastError( 2322, "Error in Milling : Tool loading failed") ;
      return false ;
   }

@@ -2110,8 +2110,6 @@ 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) ;
@@ -2133,7 +2131,7 @@ Drilling::DoStandardDrilling( const Hole& hole, SelData Id, int nPathId, double
            return false ;
         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 ;
      }
      // altrimenti rinvio normale
@@ -2143,7 +2141,7 @@ 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 {
@@ -2156,7 +2154,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)
@@ -2167,7 +2165,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)
@@ -2178,7 +2176,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)
@@ -2186,27 +2184,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) {
      SetFlag( 0) ;
      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) ;
-      if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_OUT) == GDB_ID_NULL)
+      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) {
         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 ;
      }
   }
@@ -2243,8 +2241,6 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId)
   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) ;
@@ -2266,7 +2262,7 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId)
            return false ;
         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 ;
      }
      // altrimenti rinvio normale
@@ -2276,7 +2272,7 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId)
            return false ;
         SetFlag( 0) ;
      }
-      if ( AddRapidMove( ptP1, bSplitArcs) == GDB_ID_NULL)
+      if ( AddRapidMove( ptP1) == GDB_ID_NULL)
         return false ;
   }
   else {
@@ -2287,7 +2283,7 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId)
  // 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
@@ -2307,13 +2303,13 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId)
         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
@@ -2336,7 +2332,7 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId)
         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 ;
@@ -2361,7 +2357,7 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId)
         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 ;
@@ -2385,7 +2381,7 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId)
         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 ;
@@ -2395,7 +2391,7 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId)
  // 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)
@@ -2403,14 +2399,14 @@ Drilling::DoPeckDrilling( const Hole& hole, SelData Id, int nPathId)
      SetFlag( 0) ;
      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) ;
-      if ( AddRapidMove( ptP0, bSplitArcs, MCH_CL_AGB_OUT) == GDB_ID_NULL)
+      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) {
         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 ;
      }
   }
@@ -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>
@@ -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 ----
@@ -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 ;
 }

@@ -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" ;

@@ -135,7 +131,6 @@ 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)
@@ -1,7 +1,7 @@
 //----------------------------------------------------------------------------
-//  EgalTech 2015-2024
+//  EgalTech 2015-2023
 //----------------------------------------------------------------------------
-// File : MachMgr.h           Data : 02.04.24          Versione : 2.6d1
+// File : MachMgr.h           Data : 28.10.23          Versione : 2.5j4
 // Contenuto : Dichiarazione della classe MachMgr.
 //
 //
@@ -13,8 +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.
 //
 //----------------------------------------------------------------------------

@@ -310,7 +308,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 ;
@@ -330,10 +327,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 ;
@@ -374,7 +370,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 ;
@@ -499,7 +494,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
@@ -75,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
@@ -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 ;
 }
@@ -534,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
@@ -617,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
@@ -668,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) ;
 }

 //----------------------------------------------------------------------------
@@ -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] ;
 }
@@ -58,7 +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 ;
 }
@@ -213,7 +212,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 ;
@@ -252,7 +251,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 ;
@@ -1067,8 +1066,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 ;
@@ -61,7 +61,6 @@ 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 ;
@@ -98,7 +97,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 ;
@@ -123,9 +121,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 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 ;
@@ -199,7 +197,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,
@@ -317,7 +315,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
@@ -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
@@ -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,8 +466,6 @@ 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)
@@ -537,19 +508,6 @@ Machine::CalculateKinematicChain( void)
      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()  ||
@@ -1281,10 +1239,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 ;
 }

@@ -1415,10 +1369,6 @@ Machine::GetTipFromPositions( double dX, double dY, double dZ, const DBLVECTOR&
   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 ingombro totale o punto sotto del tip utensile
   if ( bOverall  ||  bBottom) {
     // calcolo la direzione fresa
@@ -1853,7 +1803,7 @@ Machine::GetCurrAxisName( int nInd, string& sAxName) const

 //----------------------------------------------------------------------------
 bool
-Machine::GetAllCurrAxesNames( STRVECTOR& vAxName) const
+Machine::GetAllCurrAxesName( STRVECTOR& vAxName) const
 {
   vAxName.clear() ;
   bool bOk = true ;
@@ -1902,7 +1852,7 @@ Machine::GetCurrAxisToken( int nInd, string& sAxToken) const

 //----------------------------------------------------------------------------
 bool
-Machine::GetAllCurrAxesTokens( STRVECTOR& vAxToken) const
+Machine::GetAllCurrAxesToken( STRVECTOR& vAxToken) const
 {
   vAxToken.clear() ;
   bool bOk = true ;
@@ -2073,17 +2023,13 @@ Machine::GetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vecto
  // 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) ;
+   frTool.Set( ORIG, vtDirT, vtDirA) ;
  // 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() ;
+   Point3d ptCen = ptP + 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() +
@@ -2158,11 +2104,11 @@ Machine::GetRobotAngles( const Point3d& ptP, const Vector3d& vtDirT, const Vecto
   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) {
+   if ( ! vtTool.GetRotation( vtDirT, 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) {
+      if ( ! vtAux.GetRotation( vtDirA, vtR6, EPS_SMALL, dAng6, bDet6)  ||  ! bDet6) {
         LOG_ERROR( GetEMkLogger(), "Error : R6 not calculable (robot)")
         return false ;      
      }
@@ -59,7 +59,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 ;
@@ -453,9 +452,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)
@@ -473,7 +469,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
@@ -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) ;
 }

@@ -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)
@@ -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 ;
 } ;
@@ -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,
@@ -99,15 +99,14 @@ class Milling : public Machining
      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,12 +123,10 @@ 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& vtCorr) 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, bool bInvertSide = false) ;
+      Vector3d CalcCorrDir( const ICurveComposite* pCompo, double dU, bool bInvertSide = false) ;
      bool CalcOffset( ICurveComposite* pCompo, double dSignOffs) ;
      bool TrimExtendCurveToClosedStm( ICurveComposite* pCompo, int nCstmId, bool bInvert) ;

@@ -187,6 +184,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
 } ;
@@ -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) ;
@@ -22,6 +22,7 @@
 #include "/EgtDev/Include/EGkAngle.h"
 #include "/EgtDev/Include/EGkBBox1d.h"
 #include "/EgtDev/Include/EGkGeoPoint3d.h"
+#include "/EgtDev/Include/EGkGeoVector3d.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
 #include "/EgtDev/Include/EGkCurveArc.h"
 #include "/EgtDev/Include/EGkArcSpecial.h"
@@ -37,12 +38,13 @@
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EgtNumUtils.h"
 #include "/EgtDev/Include/EgtPointerOwner.h"
+#include "/EgtDev/Include/EGkDistPointSurfTm.h"

 using namespace std ;

 //----------------------------------------------------------------------------
 const double MAX_DIST_RAW = 200.0 ;
-const double MAX_ROBOT_G0_LEN = 299.0 ;
+const double MAX_ROBOT_G0_LEN = 300.0 ;

 //----------------------------------------------------------------------------
 bool
@@ -564,6 +566,269 @@ Operation::GetAhPointUnderRaw( const Point3d& ptP, const Vector3d& vtTool, doubl
   return false ;
 }

+//----------------------------------------------------------------------------
+bool IsPointOnBox( BBox3d BBox, Point3d pt) {
+   
+   if ( BBox.IsEmpty())
+      return false ;
+
+   int nCheck = 0 ;
+   if (( pt.x - BBox.GetMin().x) < EPS_SMALL)
+      ++ nCheck ;
+   if (( pt.y - BBox.GetMin().y) < EPS_SMALL)
+      ++ nCheck ;
+   if (( pt.z - BBox.GetMin().z) < EPS_SMALL)
+      ++ nCheck ;
+   if (( pt.x - BBox.GetMax().x) < EPS_SMALL)
+      ++ nCheck ;
+   if (( pt.y - BBox.GetMax().y) < EPS_SMALL)
+      ++ nCheck ;
+   if (( pt.z - BBox.GetMax().z) < EPS_SMALL)
+      ++ nCheck ;
+   
+   if ( nCheck >= 2)
+      return true ;
+
+   return false ;
+
+}
+
+
+//----------------------------------------------------------------------------
+bool 
+Operation::GetSignedDistFromStmRaw( int nPhase, const Point3d ptP, const Vector3d vtDir,
+                                    double& dDist, Vector3d& vtNorm) const
+{
+
+  // controllo MachManager e database geometrico
+   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
+      return false ;
+
+  // la distanza  negativa se il punto  interno, positiva se esterno, 0 se sulla suprificie
+   const double RAY_LEN = 100000 ;
+   bool bIsInside = false ;      // se punto interno ad un RawPart
+   bool bIsPointOn = false ;     // se il punto  stato trovato su una faccia
+   bool bIsOnLoop = false ;      // se il punto  su un loop
+   bool bIsOnBox = false ;       // se il punto  su un Box3D
+   bool bSkip = false ;          // se salto controlli sui bordi
+
+  // vettore dei grezzi
+   ISURFTMPOVECTOR vSrfRawPart ;
+
+   int nRawId = m_pMchMgr->GetFirstRawPart() ;
+   while( nRawId != GDB_ID_NULL) {
+     
+     // verifico che il grezzo compaia nella fase
+      if ( m_pMchMgr->VerifyRawPartPhase( nRawId, nPhase)) {
+
+        // recupero l'oggetto dal database con tale Id
+         int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
+         const IGeoObj* pGObj = m_pGeomDB->GetGeoObj( nRawSolidId) ;
+
+        // recupero il frame in cui si trova
+         Frame3d frRaw ;
+         m_pGeomDB->GetGlobFrame( nRawSolidId, frRaw) ;
+         if ( pGObj == nullptr)
+            return false ;
+
+        // controllo che sia una Trimesh
+         if ( pGObj->GetType() == SRF_TRIMESH) {
+
+           // Trimesh della parte p-esima
+            PtrOwner<ISurfTriMesh> pStmRawPart( CloneSurfTriMesh( GetSurfTriMesh( pGObj))) ;
+            if ( IsNull( pStmRawPart))
+               return false ;
+
+           // porto la trimesh in globale
+            pStmRawPart->ToGlob( frRaw) ;
+
+           // salvo la superificie
+            vSrfRawPart.emplace_back( pStmRawPart->Clone()) ;
+
+           // distanza dalla parte p-esima
+            double dCurrDist = 0 ;
+
+           // recupero la distanza tra il punto e la parte p-esima
+            DistPointSurfTm distPtStm( ptP, *pStmRawPart) ;
+            if ( ! distPtStm.GetDist( dCurrDist))
+               return false ;
+
+           // controllo se il punto  dentro al grezzo
+            if ( distPtStm.IsPointInside()) {
+               bIsInside = true ;
+               bSkip = true ;
+            }
+
+            if ( dCurrDist < EPS_SMALL  &&  !bSkip) {
+              // controllo se sono su un Loop
+               POLYLINEVECTOR vP ;
+               bool bIsCurrOnLoop = false ;
+               for ( int i = 0 ; i < pStmRawPart->GetFacetCount() ; ++ i) {
+                  pStmRawPart->GetFacetLoops( i, vP) ;
+                  for ( int j = 0 ; j < ( int)vP.size() &&  !bIsCurrOnLoop ; ++ j) {
+                     PtrOwner<ICurveComposite> pCrvEdge( CreateCurveComposite()) ;
+                     if ( IsNull( pCrvEdge))
+                        return false ;
+                     pCrvEdge->FromPolyLine( vP[j]) ;
+                     if ( !pCrvEdge->IsValid()  ||  pCrvEdge->GetCurveCount() == 0)
+                        return false ;
+                     if ( pCrvEdge->IsPointOn( ptP))
+                        bIsCurrOnLoop = true ;
+                  }
+               }
+               
+              // se il punto sta sulla curva...
+               if ( bIsCurrOnLoop) {
+                  if ( bIsOnLoop) { // se ho gi trovato una curva che contiene il punto ...
+                     BBox3d bCurrBox ;
+                     if ( ! pStmRawPart->GetBBox( GLOB_FRM, bCurrBox))
+                        return false ;
+
+                     if ( IsPointOnBox( bCurrBox, ptP)) { // se il punto sta sul Box
+                        if ( bIsOnBox) { // se il punto stava gi su un altro Box
+                           bIsInside = false ;
+                           bSkip = true ;
+                        }
+                        else // se il punto non stava gi su un box
+                           bIsInside = true ;
+
+                        bSkip = true ;
+                     }
+                     else // se il punto non sta sul box
+                        bIsInside = true ;
+
+                  }
+                  else { // se  la prima curva a contenere il punto
+                     bIsPointOn = true ;
+                    // controllo se il punto sta sulla faccia del box del grezzo corrente
+                     BBox3d bCurrBox ;
+                     if ( ! pStmRawPart->GetBBox( GLOB_FRM, bCurrBox))
+                        return false ;
+                    // controllo se il punto sta su una faccia del box
+                     if ( IsPointOnBox( bCurrBox, ptP))
+                        bIsOnBox = true ;
+                  }
+               }
+              // se il punto non sta sulla curva ...
+               else {
+                  if ( bIsPointOn) {
+                     bIsInside = true ;
+                     bSkip = true ;
+                  }
+                  else
+                     bIsPointOn = true ;
+               }
+
+            }
+         }
+      }
+
+     // passo al grezzo successivo
+      nRawId = m_pMchMgr->GetNextRawPart( nRawId) ;
+   }
+
+   if ( bSkip) {
+      bIsPointOn = false ;
+      bIsOnLoop = false ;
+      bIsOnBox = false ;
+   }
+
+   double dCurrDist = bIsInside ? -INFINITO : INFINITO ;   // distanza attuale
+   dDist = dCurrDist ;
+   double dTmpCurrDist = 0 ;
+
+   for ( int i = 0 ; i < int( vSrfRawPart.size()) ; ++ i) {
+
+      ILSIVECTOR vInfo ;   // info
+      Triangle3d Tria ;    // triangolo della trimesh intersecato
+
+     // recupero la distanza tra il punto e la parte p-esima
+      if ( IntersLineSurfTm( ptP, vtDir, RAY_LEN, *vSrfRawPart[i], vInfo)) {
+
+         if ( vInfo.empty())
+            continue ;
+
+         DistPointSurfTm distPtStm( ptP, *vSrfRawPart[i]) ;
+         if( ! distPtStm.GetDist( dTmpCurrDist))
+            return false ;
+
+         if (( bIsPointOn  &&  !bIsInside)) { // punto sulla superificie totale dei grezzi
+           // se  il grezzo  quello giusto ...
+            if ( dTmpCurrDist < EPS_SMALL) {
+               dDist = 0 ;
+               vSrfRawPart[i]->GetTriangle( vInfo[0].nT, Tria) ;
+               vtNorm = Tria.GetN() ;
+               return true ;
+            }
+            else { // se sono su un altro ... ( prima o poi ritorno al controllo sopra ...)
+            }
+         }
+         else if (( int)vInfo.size() == 1  &&  bIsInside) {
+            if ( distPtStm.IsPointInside()  ||  dTmpCurrDist < EPS_SMALL) {
+              // se punto interno alla grezzo corrente
+               double dUCurr = vInfo[0].dU ;
+               // se direzione || ad una faccia faccia, ma punto non interno al grezzo corrente
+               if ( vInfo[0].nILTT == ILTT_SEGM  ||  vInfo[0].nILTT == ILTT_EDGE)
+                   double dUCurr = - vInfo[0].dU2 ;
+               if ( dUCurr > dCurrDist) {
+                  dCurrDist = dUCurr ;
+                  vSrfRawPart[i]->GetTriangle( vInfo[0].nT, Tria) ;
+                  vtNorm = Tria.GetN() ;
+               }
+            }
+            else { // se interno ma non al grezzo corrente ( prima o poi ritono al controllo sopra )
+            }
+         }
+         else if (( int)vInfo.size() > 1) { // se la linea trapassa il grezzo corrente (entra ed esce)...
+            if ( bIsInside) { // e il punto  interno ( quindi non al grezzo corrente )
+               double dUCurr = 0 ;
+               int nT ;
+               for ( int j = 0 ; j < ( int)vInfo.size() ; ++ j) {
+                  IntLinStmInfo Info = vInfo[j] ;
+                  if ( Info.nILTT == ILTT_SEGM  ||  Info.nILTT == ILTT_SEGM_ON_EDGE) {
+                    // se prosegue un tratto precedente, non devo controllare sia minimo
+                     dUCurr = Info.dU2 ;
+                     nT = Info.nT ;
+                     //break ; ???????
+                  }
+                 // se altrimenti intersezione puntuale, verifico che esca (coseno >= 0)
+                  else if ( Info.dCosDN > - COS_ORTO_ANG_ZERO) {
+                     dUCurr = Info.dU ;
+                     nT = Info.nT ;
+                     break ;
+                  }
+                 // se altrimenti  la prima ed entra ( non la considero ...)
+                  else {
+                  }
+
+               }
+               if ( dUCurr > dCurrDist) { // tengo la distanza pi grande 
+                  dCurrDist = dUCurr ;
+                  vSrfRawPart[i]->GetTriangle( nT, Tria) ;
+                  vtNorm = Tria.GetN() ;
+               }
+            }
+            else { // se invece  un punto esterno a tutto
+               if ( vInfo[0].dU < dCurrDist) { // tengo la distanza ( positiva) pi grande
+                  dCurrDist = vInfo[0].dU ;
+                  vSrfRawPart[i]->GetTriangle( vInfo[0].nT, Tria) ;
+                  vtNorm = Tria.GetN() ;
+               }
+            }
+         }
+      }
+   }
+
+
+   if ( dCurrDist > INFINITO - 1  &&  ! bIsInside) // non ho intersecato mai nessun grezzo
+      dDist = INFINITO ;
+   if ( dCurrDist < -INFINITO + 1  &&  bIsInside) // sono interno ma non interseco un grezzo ... errore
+      return false ;
+   dDist = bIsInside ? - dCurrDist : dCurrDist ;
+
+   return true ;
+}
+
 //----------------------------------------------------------------------------
 bool
 Operation::GetUhPointAboveRaw( const Point3d& ptP, const Vector3d& vtTool, double dToolRad, double dToolRadForElev,
@@ -824,13 +1089,25 @@ Operation::GetDistanceFromRawBottom( int nPhase, int nPathId, double dToler, dou
 {
   if ( m_pMchMgr == nullptr  ||  m_pGeomDB == nullptr)
      return false ;
-  // recupero distanza da fondo dei grezzi interessati o no dal percorso
-   dRbDist = 0 ;
-   dAllRbDist = 0 ;
+
+   // ricerco grezzi interessati dal percorso
   BBox3d b3Compo ;
   if ( ! m_pGeomDB->GetGlobalBBox( nPathId, b3Compo))
      return false ;
-   b3Compo.Expand( dToler, dToler, 0) ;
+   return GetDistanceFromRawBottom( nPhase, b3Compo, dToler, dRbDist, dAllRbDist) ;
+
+}
+
+//----------------------------------------------------------------------------
+bool
+Operation::GetDistanceFromRawBottom( int nPhase, BBox3d& b3Test, double dToler, double& dRbDist, double& dAllRbDist) const
+{
+   if ( m_pMchMgr == nullptr || m_pGeomDB == nullptr)
+      return false ;
+  // recupero distanza da fondo dei grezzi interessati o no dal percorso
+   dRbDist = 0 ;
+   dAllRbDist = 0 ;
+   b3Test.Expand( dToler, dToler, 0) ;
   int nRawId = m_pMchMgr->GetFirstRawPart() ;
   while ( nRawId != GDB_ID_NULL) {
     // verifico che il grezzo compaia nella fase
@@ -838,8 +1115,8 @@ Operation::GetDistanceFromRawBottom( int nPhase, int nPathId, double dToler, dou
         BBox3d b3Raw ;
         int nRawSolidId = m_pGeomDB->GetFirstNameInGroup( nRawId, MACH_RAW_SOLID) ;
         if ( m_pGeomDB->GetGlobalBBox( nRawSolidId, b3Raw)) {
-            double dDist = b3Compo.GetMax().z - b3Raw.GetMin().z ;
-            if ( b3Compo.OverlapsXY( b3Raw)  &&  dDist > dRbDist)
+            double dDist = b3Test.GetMax().z - b3Raw.GetMin().z ;
+            if ( b3Test.OverlapsXY( b3Raw) && dDist > dRbDist)
               dRbDist = dDist ;
            if ( dDist > dAllRbDist)
               dAllRbDist = dDist ;
@@ -1142,6 +1419,9 @@ Operation::ApproxWithArcsIfUseful( ICurveComposite* pCompo, bool bCareTempProp)
   pCompo->GetExtrusion( vtExtr) ;
   double dThick = 0 ;
   pCompo->GetThickness( dThick) ;
+  // recupero le proprietà temporanee
+   int nProp0 = pCompo->GetTempProp( 0) ;
+   int nProp1 = pCompo->GetTempProp( 1) ;
  // verifico se ci sono tante linee corte
   int nSmallLineCnt = 0 ;
   const ICurve* pCrv = pCompo->GetFirstCurve() ;
@@ -1237,12 +1517,16 @@ Operation::ApproxWithArcsIfUseful( ICurveComposite* pCompo, bool bCareTempProp)
   pCompo->SetExtrusion( vtExtr) ;
   pCompo->SetThickness( dThick) ;

+  // riassegno le proprietà temporanee
+   pCompo->SetTempProp( nProp0, 0) ;
+   pCompo->SetTempProp( nProp1, 1) ;
+
   return true ;
 }

 //----------------------------------------------------------------------------
 bool
-Operation::ApproxWithLines( ICurveComposite* pCompo, bool bFeed) const
+Operation::ApproxWithLines( ICurveComposite* pCompo, double dMaxLen) const
 {
  // recupero estrusione e spessore
   Vector3d vtExtr = Z_AX ;
@@ -1251,12 +1535,10 @@ Operation::ApproxWithLines( ICurveComposite* pCompo, bool bFeed) const
   pCompo->GetThickness( dThick) ;
  // calcolo approssimazione lineare
   PolyLine PL ;
-   double dLinTol = GetApproxLinTol() ;
-   if ( ! pCompo->ApproxWithLines( dLinTol, ANG_TOL_MID_DEG, ICurve::APL_SPECIAL, PL))
+   if ( ! pCompo->ApproxWithLines( 50 * EPS_SMALL, ANG_TOL_MAX_DEG, ICurve::APL_SPECIAL, PL))
      return false ;
  // se prevista massima lunghezza
-   double dMaxLen = GetMaxSplitLen( true, bFeed) ;
-   if ( dMaxLen > 99 * EPS_SMALL)
+   if ( dMaxLen > 100 * EPS_SMALL)
      PL.AdjustForMaxSegmentLen( dMaxLen) ;
  // sostituisco le linee alle curve originali
   pCompo->Clear() ;
@@ -2283,45 +2565,21 @@ Operation::CalculateClPathRobotAxesValues( int nClPathId, int nLinAxes, int nRot
         pCamData->SetAxes( CamData::AS_ERR, vAxVal) ;
         return false ;
      }
-     // se inizio
+     // se inizio, scelgo la prima soluzione
      if ( bFirst) {
-        // porto gli angoli ai valori più vicini ai precedenti con offset di uno o più giri
-         for ( int i = 0 ; i < int( vAng1.size()) ; ++ i) {
-            m_pMchMgr->GetNearestAngleInStroke( i, vAxRotPrec[i], vAng1[i]) ;
-            if ( abs( vAng1[i] - vAxRotPrec[i]) > dAngDeltaMinForHome)
-               m_pMchMgr->GetNearestAngleInStroke( i, vAxRotHome[i], vAng1[i]) ;
-         }
-         for ( int i = 0 ; i < int( vAng2.size()) ; ++ i) {
-            m_pMchMgr->GetNearestAngleInStroke( i, vAxRotPrec[i], vAng2[i]) ;
-            if ( abs( vAng2[i] - vAxRotPrec[i]) > dAngDeltaMinForHome)
-               m_pMchMgr->GetNearestAngleInStroke( i, vAxRotHome[i], vAng2[i]) ;
-         }
+         vAxVal = vAng1 ;
         bFirst = false ;
      }
-     // altrimenti movimenti successivi
+     // altrimenti, scelgo la soluzione piÃ¹ vicina
      else {
-        // porto gli angoli ai valori più vicini ai precedenti con offset di uno o più giri
-         for ( int i = 0 ; i < int( vAng1.size()) ; ++ i) {
-            if ( bRotContOnNext)
-               vAng1[i] = AngleNearAngle( vAng1[i], vAxRotPrec[i]) ;
-            else
-               m_pMchMgr->GetNearestAngleInStroke( i, vAxRotPrec[i], vAng1[i]) ;
-         }
-         for ( int i = 0 ; i < int( vAng2.size()) ; ++ i) {
-            if ( bRotContOnNext)
-               vAng2[i] = AngleNearAngle( vAng2[i], vAxRotPrec[i]) ;
-            else
-               m_pMchMgr->GetNearestAngleInStroke( i, vAxRotPrec[i], vAng2[i]) ;
-         }
+        // minimizzo rotazione polso
+         if ( abs( vAng1[3] - vAxRotPrec[3]) < abs( vAng2[3] - vAxRotPrec[3]) + 10 * EPS_ANG_SMALL)
+            vAxVal = vAng1 ;
+         else
+            vAxVal = vAng2 ; 
+        // controllo continuitÃ  di R6 dalla posizione precedente 
+         m_pMchMgr->GetNearestAngleInStroke( 5, vAxRotPrec[5], vAxVal[5]) ;
      }
-     // Scelgo la soluzione più vicina
-      // minimizzo rotazione polso
-      if ( vAng2.empty()  ||  abs( vAng1[3] - vAxRotPrec[3]) < abs( vAng2[3] - vAxRotPrec[3]) + 10 * EPS_ANG_SMALL)
-         vAxVal = vAng1 ;
-      else
-         vAxVal = vAng2 ; 
-      // controllo continuità di R6 dalla posizione precedente 
-      m_pMchMgr->GetNearestAngleInStroke( 5, vAxRotPrec[5], vAxVal[5]) ;
     // verifico di essere nelle corse degli assi
      int nStat ;
      bool bOsOk = m_pMchMgr->VerifyOutstroke( 0, 0, 0, vAxVal, false, nStat) ;
@@ -2983,7 +3241,7 @@ Operation::AdjustOneStartMovement( int nClPathId, int nPrevClPathId, Operation*
              // elimino eventuali risalite finali
               if ( pPrevOp == nullptr  ||  ! pPrevOp->RemoveRise())
                  return false ;
-              // aggiungo risalita a Z max alla fine della lavorazione precedente
+              // aggiungo risalita a Z max alla fine del percorso precedente
               DBLVECTOR vAxNew = vAxPrev ;
               if ( ! pPrevOp->AddRise( vAxNew))
                  return false ;
@@ -2991,14 +3249,11 @@ Operation::AdjustOneStartMovement( int nClPathId, int nPrevClPathId, Operation*
           // altrimenti precedente appartiene alla stessa operazione
            else {
              // eventuali risalite finali già eliminate dal chiamante
-              // aggiungo risalita a Z max alla fine del percorso precedente
+              // aggiungo risalita a Z opportuna alla fine del percorso precedente
               DBLVECTOR vAxNew = vAxPrev ;
               if ( ! AddRise( vAxNew, -1, nPrevClPathId))
                  return false ;
            }
-           // inserisco la posizione iniziale a Zmax in questo percorso
-            if ( ! AddRobotClimb( nEntId, -1))
-               return false ;
         }
      }
   }
@@ -3464,23 +3719,18 @@ Operation::CalcRobotAxesAbovePos( const Point3d& ptP, const Vector3d& vtT, const
   if ( vAx.size() < 6) {
      vAx = vAng1 ;
   }
-   // altrimenti, scelgo la soluzione più vicina
-   else {
-     // porto gli angoli ai valori più vicini ai precedenti con offset di uno o più giri
-      for ( int i = 0 ; i < int( vAng1.size()) ; ++ i)
-         m_pMchMgr->GetNearestAngleInStroke( i, vAx[i], vAng1[i]) ;
-      for ( int i = 0 ; i < int( vAng2.size()) ; ++ i)
-         m_pMchMgr->GetNearestAngleInStroke( i, vAx[i], vAng2[i]) ;
-     // salvo precedente R6
-      double dPrevR6 = vAx[5] ;
-     // minimizzo rotazione polso
-      if ( vAng2.empty()  ||  abs( vAng1[3] - vAx[3]) < abs( vAng2[3] - vAx[3]) + 10 * EPS_ANG_SMALL)
-         vAx = vAng1 ;
-      else
-         vAx = vAng2 ; 
-     // controllo continuità di R6 dalla posizione precedente 
-      m_pMchMgr->GetNearestAngleInStroke( 5, dPrevR6, vAx[5]) ;
-   }
+ // altrimenti, scelgo la soluzione piÃ¹ vicina
+  else {
+    // salvo precedente R6
+     double dPrevR6 = vAx[5] ;
+    // minimizzo rotazione polso
+     if ( abs( vAng1[3] - vAx[3]) < abs( vAng2[3] - vAx[3]) + 10 * EPS_ANG_SMALL)
+        vAx = vAng1 ;
+     else
+        vAx = vAng2 ; 
+    // controllo continuitÃ  di R6 dalla posizione precedente 
+     m_pMchMgr->GetNearestAngleInStroke( 5, dPrevR6, vAx[5]) ;
+  }
  // verifico di essere nelle corse degli assi
   int nStat ;
   if ( ! m_pMchMgr->VerifyOutstroke( 0, 0, 0, vAx, false, nStat)  ||  nStat != 0)
@@ -3652,11 +3902,10 @@ Operation::SpecialGetMaxZ( const DBLVECTOR& vAx1, const Vector3d& vtTool1,
   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TCPOS, GetToolTcPos()) ;
   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_MCHID, GetOwner()) ;
   // valori degli assi
-   bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ;
   for ( int i = 1 ; i <= nNumAx1 ; ++ i)
-      bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisPrev( i, EMC_VAR, bIsRobot), vAx1[i-1]) ;
+      bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisPrev( i, EMC_VAR), vAx1[i-1]) ;
   for ( int i = 1 ; i <= nNumAx2 ; ++ i)
-      bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisValue( i, EMC_VAR, bIsRobot), vAx2[i-1]) ;
+      bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisValue( i, EMC_VAR), vAx2[i-1]) ;
   // direzioni utensile
   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TDIRP, vtTool1) ;
   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TDIR, vtTool2) ;
@@ -3789,7 +4038,7 @@ Operation::TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEn
      return false ;
  // Recupero assi correnti e ne verifico la costanza
   STRVECTOR vAxName ;
-   pMch->GetAllCurrAxesNames( vAxName) ;
+   pMch->GetAllCurrAxesName( vAxName) ;
   if ( vAxName.size() != vAxStart.size()  ||  vAxName.size() != vAxEnd.size())
      return false ;
  // Porto la macchina in home
@@ -3815,12 +4064,9 @@ Operation::TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEn
  // Aggancio bloccaggi alla tavola corrente
   for ( const auto nFxtId : vFxtId)
      pMch->LinkFixtureToGroup( nFxtId, sTable) ;
-  // Parti di tavola da considerare per la collisione
-   INTVECTOR vTabCollId ;
-   pMch->GetCurrTableCollGroups( vTabCollId) ;
  // Parti di testa e collegati da considerare per la collisione
-   INTVECTOR vHeadCollId ;
-   pMch->GetCurrHeadCollGroups( vHeadCollId) ;
+   INTVECTOR vCollId ;
+   pMch->GetCurrHeadCollGroups( vCollId) ;

  // Lancio la verifica custom
   int nRes = SpecialTestCollisionAvoid( vAxStart, vAxEnd) ;
@@ -3857,7 +4103,7 @@ Operation::TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEn
     // Determino sottobox e box della testa e degli altri oggetti da considerare per la collisione
      BOXIVECTOR vbiSH ;
      BBox3d b3Head ;
-      for ( int nCId : vHeadCollId) {
+      for ( int nCId : vCollId) {
         int nHId = m_pGeomDB->GetFirstInGroup( nCId) ;
         while ( nHId != GDB_ID_NULL) {
            BBox3d b3Tmp ;
@@ -3949,40 +4195,6 @@ Operation::TestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEn
      if ( ExeGetDebugLevel() >= 5) {
         LOG_DBG_INFO( GetEMkLogger(), ( bCollide ? "   COLLIDE" : "   avoid")) ;
      }
-     // Se non trovata collisione, li confronto con oggetti da verificare della tavola
-      if ( ! bCollide) {
-         for ( const auto nTabCollId : vTabCollId) {
-           // verifico i box
-            BBox3d b3TabColl ;
-            int nFlag = BBF_ONLY_VISIBLE | BBF_IGNORE_TEXT | BBF_IGNORE_DIM ;
-            m_pGeomDB->GetGlobalBBox( nTabCollId, b3TabColl, nFlag) ;
-           // eventuale emissione Log
-            if ( ExeGetDebugLevel() >= 5) {
-               string sBox = " TabColl : " + ( b3TabColl.IsEmpty() ? string( "Empty Box") : ToString( b3TabColl, 1)) ;
-               LOG_DBG_INFO( GetEMkLogger(), sBox.c_str()) ;
-            }
-           // se i box interferiscono
-            if ( ! b3TabColl.IsEmpty()  &&  b3Head.Overlaps( b3TabColl)) {
-              // eventuale emissione Log
-               if ( ExeGetDebugLevel() >= 5) {
-                  LOG_DBG_INFO( GetEMkLogger(), "   Can collide -->") ;
-               }
-              // verifico i sottobox
-               for ( const auto& biSH : vbiSH) {
-                  if ( biSH.first.Overlaps( b3TabColl)) {
-                     bCollide = true ;
-                     break ;
-                  }
-               }
-               if ( bCollide)
-                  break ;
-            }
-         }
-        // eventuale emissione Log
-         if ( ExeGetDebugLevel() >= 5) {
-            LOG_DBG_INFO( GetEMkLogger(), ( bCollide ? "   COLLIDE" : "   avoid")) ;
-         }
-      }
     // Se non trovata collisione, li confronto con i bloccaggi
      if ( ! bCollide) {
         for ( const auto nFxtId : vFxtId) {
@@ -4056,11 +4268,10 @@ Operation::SpecialTestCollisionAvoid( const DBLVECTOR& vAxStart, const DBLVECTOR
   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TCPOS, GetToolTcPos()) ;
   bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_MCHID, GetOwner()) ;
   // valori degli assi
-   bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ;
   for ( int i = 1 ; i <= int( vAxStart.size()) ; ++ i)
-      bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisPrev( i, EMC_VAR, bIsRobot), vAxStart[i-1]) ;
+      bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisPrev( i, EMC_VAR), vAxStart[i-1]) ;
   for ( int i = 1 ; i <= int( vAxEnd.size()) ; ++ i)
-      bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisValue( i, EMC_VAR, bIsRobot), vAxEnd[i-1]) ;
+      bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisValue( i, EMC_VAR), vAxEnd[i-1]) ;
  // eseguo
   bOk = bOk && pMch->LuaCallFunction( ON_SPECIAL_TESTCOLLISIONAVOID, false) ;
  // recupero valori parametri obbligatori
@@ -4107,10 +4318,9 @@ Operation::SpecialMoveZup( DBLVECTOR& vAx, Vector3d& vtTool, int& nFlag, int& nF
      // direzione utensile
      bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TDIR, vtTool) ;
      // valore degli assi
-      bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ;
      int nNumAxes = int( vAx.size()) ;
      for ( int i = 1 ; i <= nNumAxes ; ++ i)
-         bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisValue( i, EMC_VAR, bIsRobot), vAx[i-1]) ;
+         bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisValue( i, EMC_VAR), vAx[i-1]) ;
     // eseguo
      bOk = bOk && pMch->LuaCallFunction( ON_SPECIAL_MOVEZUP, false) ;
     // recupero valori parametri obbligatori
@@ -4120,7 +4330,7 @@ Operation::SpecialMoveZup( DBLVECTOR& vAx, Vector3d& vtTool, int& nFlag, int& nF
      bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + GVAR_FLAG2, nFlag2) ;
      bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + GVAR_TDIR, vtTool) ;
      for ( int i = 1 ; i <= nNumAxes ; ++ i)
-         bOk = bOk && pMch->LuaGetGlobVar( GetGlobVarAxisValue( i, EMC_VAR, bIsRobot), vAx[i-1]) ;
+         bOk = bOk && pMch->LuaGetGlobVar( GetGlobVarAxisValue( i, EMC_VAR), vAx[i-1]) ;
     // reset
      bOk = bOk && pMch->LuaResetGlobVar( EMC_VAR) ;
     // segnalo errori
@@ -4162,12 +4372,11 @@ Operation::SpecialMoveRapid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd,
      bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_EXIT, GetExitNbr()) ;
      bOk = bOk && pMch->LuaSetGlobVar( EMC_VAR + GVAR_TCPOS, GetToolTcPos()) ;
     // valore degli assi
-      bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ;
      int nNumAxes = int( vAxStart.size()) ;
      for ( int i = 1 ; i <= nNumAxes ; ++ i)
-         bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisPrev( i, EMC_VAR, bIsRobot), vAxStart[i-1]) ;
+         bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisPrev( i, EMC_VAR), vAxStart[i-1]) ;
      for ( int i = 1 ; i <= nNumAxes ; ++ i)
-         bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisValue( i, EMC_VAR, bIsRobot), vAxEnd[i-1]) ;
+         bOk = bOk && pMch->LuaSetGlobVar( GetGlobVarAxisValue( i, EMC_VAR), vAxEnd[i-1]) ;
     // eseguo
      bOk = bOk && pMch->LuaCallFunction( ON_SPECIAL_MOVERAPID, false) ;
     // recupero valori parametri obbligatori
@@ -4175,7 +4384,7 @@ Operation::SpecialMoveRapid( const DBLVECTOR& vAxStart, const DBLVECTOR& vAxEnd,
      bOk = bOk && pMch->LuaGetGlobVar( EMC_VAR + EVAR_MODIF, bModif) ;
      vAxNew.resize( nNumAxes) ;
      for ( int i = 1 ; i <= nNumAxes ; ++ i)
-         bOk = bOk && pMch->LuaGetGlobVar( GetGlobVarAxisValue( i, EMC_VAR, bIsRobot), vAxNew[i-1]) ;
+         bOk = bOk && pMch->LuaGetGlobVar( GetGlobVarAxisValue( i, EMC_VAR), vAxNew[i-1]) ;
     // reset
      bOk = bOk && pMch->LuaResetGlobVar( EMC_VAR) ;
     // segnalo errori
@@ -14,14 +14,15 @@

 #pragma once

-#include "MachMgr.h"
 #include "MachConst.h"
 #include "MachineStruConst.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 ;
@@ -43,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 ;
@@ -61,21 +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 bool               GetSplitArcs( const Vector3d& vtTool) const
-                                    { if ( m_pMchMgr == nullptr  ||  m_pMchMgr->GetCurrIsRobot())
-                                         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)
-                                         return 50 * EPS_SMALL ; 
-                                      return m_pMchMgr->GetCurrMachiningsMgr()->GetApproxLinTol() ; }

   protected :
      Operation( void) ;
@@ -104,6 +90,8 @@ class Operation : public IUserObj
                                 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   GetMinDistanceFromRawSide( int nPhase, const Point3d& ptP, double dExpand,
                                        double& dDist, Vector3d& vtDir) const ;
@@ -114,13 +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, 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, double dMaxLen = 0) const ;
      bool   VerifyArcs( ICurveComposite* pCompo, double dMaxAngCen = MAX_ANG_CEN) const ;
     
      bool   CalcAndSetBBox( int nClId) ;
@@ -213,26 +202,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 :
@@ -212,46 +212,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 +270,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 +346,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 +367,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 +407,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) ;
@@ -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,9 +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_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
@@ -131,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
@@ -148,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
@@ -241,120 +229,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
-GetGlobVarAxisToken( int nAx, bool bIsRobot = false)
+GetGlobVarAxisToken( 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 "" ;
-      }
-   }
+   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
-GetGlobVarAxisName( int nAx, bool bIsRobot = false)
+GetGlobVarAxisName( int nAx)
 {
-   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 "" ;
+   }  
 }
@@ -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
@@ -66,82 +69,248 @@ class Pocketing : public Machining
      Pocketing( void) ;

   private :
+     // Debug functions ----
+      void DrawLoopsSurf( const ISurfFlatRegion* pSfr, bool bWithSurf = true, Color Col = Color( 0., 0., 1., 0.45), 
+                          bool bAlphaCoverage = false) ;
+      void DrawSimpleSurf( const ISurfFlatRegion* pSrf, Color Col = Color( 0., 0., 1., 0.45)) ;
+      void DrawVectorCurves( const ICRVCOMPOPOVECTOR& vCrv) ;
+      void DrawSimpleCurve( const ICurveComposite* pCrv, bool bUniform = false, Color Col = WHITE) ;
+      void DrawSimpleTriMesh( const ISurfTriMesh* pStm, Color Col = Color( 0., 0., 0., 1.)) ;
+      void DrawSimplePoint( const Point3d& pT, Color Col = WHITE) ;
+      void DrawSimpleVector( const Vector3d& vt, Point3d ptPos = ORIG, Color Col = WHITE) ;
+     // --------------------
+
      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( 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 PNTVECTOR& vPtInside, ISurfTriMesh* pStmPart) ;
+      bool SetPocketingVolume( const PNTVECTOR& vPtInside, ISurfTriMesh* pStm) ;
+      bool AdjustPocketingSideForVolumePart( ISurfTriMesh* pStmVolPart, const Vector3d& vtTool) ;
+      bool SewingMissingFacesOnPlanes( ISurfTriMesh* pStm, const Plane3d& plPlane) ;
+      bool ChainBisectors( ICURVEPOVECTOR& vpCrvs, ICRVCOMPOPOVECTOR& vCrvCompo) ;
+      bool ChooseBestBisectorPath( ICRVCOMPOPOVECTOR& vCrvCompo, const Point3d& ptS,
+                                   const Point3d& ptE, ICurveComposite* pCrvPath) ;
+      bool GetSpecialElevation( const ISurfFlatRegion* pSfr, const ICurveLine* pLine, const bool bInVsOut,
+                                double& dElev) ;
+
+      bool GetDangerSfrForSideStep( const ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm_Part, const double dExtraLenInOut,
+                                    ISurfFlatRegion* pSfrDanger) ;
+      bool AdjustTrapezoidSpiralLeadInLeadOutForSideAngle( ICurveComposite* pMCrv, const double dExtraLenInOut,
+                                                           const int nOutsideRaw, const Vector3d& vtN) ;
+      bool GetRaw( ISurfTriMesh* pStmRaw) ;
+      bool SliceVolume( const ISurfTriMesh* pStmVol, const ISurfTriMesh* pStm_Part, const ISurfTriMesh* pSt_Raw,
+                        ISURFFRPOVECTOR& vSrfSliced, ISURFFRPOVECTOR& vSfrLimit, std::vector<ICRVCOMPOPOVECTOR>& vCrvOEWithFlags,
+                        BOOLVECTOR& vbChangedPrec, VCT3DVECTOR& vVtTrasl, int& nStep, const Vector3d vtTool,
+                        const double dElev, const double dDepth, const double dStep, double& dExtraLenInOut) ;
+      bool TranslateVolumeFaces( const double dTrasl, Frame3d& frElevation, ISurfTriMesh* pStmVol, ISurfTriMesh* pStm_Part,
+                                 ISurfTriMesh* pStmRaw) ;
+      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 CheckSideAngleForVolume( const ISurfTriMesh* pStmVol_Sliced, const ISurfTriMesh* pStm_Part,
+                                    ISurfFlatRegion* pSfr_Projection, double& dExtraLenInOut, ISurfFlatRegion* pSfr) ;
+      bool ProjectVolume( const ISurfTriMesh* pStmVol, const ISurfTriMesh* pStm_Part, const Vector3d& vtTrasl,
+                          const Vector3d& vtTraslPrec, const bool bIsExtraStep, ISurfFlatRegion* pSfrOpenProjPrec,
+                          ISurfFlatRegion* pSfr, const bool bOneStep, double& dExtraLenInOut) ;
+      bool ChooseCloseOrOpenEdge( ISurfFlatRegion* pSfr, const ISurfTriMesh* pStm, const bool bOnIsClosed = false) ;
+      bool SimplifySfrLoops( ISurfFlatRegion* pSfr) ;
+      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 Vector3d& vtTanS,
+                           const Vector3d& vtTanE, const double dRad, const double dDiamJ,
+                           const ISurfFlatRegion* pSfrLimit, ICurveComposite* pCrvBorder) ;
+      bool GetProjectionOfStmToNotPocket( const ISurfTriMesh* pStm, const ISurfTriMesh* pStmVol,
+                                          const Vector3d& vtTrasl, ISurfFlatRegion* pSfrProj) ;
+      bool CreateSurfFrIncidence( const ICurveComposite* pCrv, const Vector3d& vtTanS, const Vector3d& vtTaneE, 
+                                  const double dRad, ISurfFlatRegion* pSfrInc) ;
+      bool GetNewSfrByAnotherPocketing( ISurfFlatRegion* pSfrPock, const ISurfFlatRegion* pSfrNoExtendedByOpenEdges,
+                                        const ISurfTriMesh* pStmVol, const ISurfTriMesh* pStm_Part,
+                                        const ISurfFlatRegion* pSfrLimit) ;
+      bool GetHomogeneousParts( ICurveComposite* pCrvCompo, ICRVCOMPOPOVECTOR& vpCrvs) ;
+      bool OptimizedSpiralCirle( const ICurveComposite* pCrvCompo, const double dToll, double& dRad,
+                                 Point3d& ptC, bool& bIsCirlce) ;
+      bool ModifyCurveToSmoothed( ICurveComposite* pCrv, double dRightLen, double dLeftLen, bool bAsParam) ;
+      bool OrderCurvesByLastPntOfPath( ICRVCOMPOPOVECTOR& vCrv, Point3d ptEnd, PNTVECTOR& vPtStart,
+                                       VCT3DVECTOR& vVtOut, BOOLVECTOR& vbMidOut) ;
+      bool SetPtStartForPath( ICurveComposite* pCrv0, const ISurfFlatRegion* pSrfToWork, const Point3d& ptEndPrec,
+                              const Frame3d& frPocket, Point3d& ptStart, Vector3d& vtMidOut, bool& bMidOut,
+                              int nOffs = 0, ICurveComposite* pCrvOrig = nullptr) ;
+      bool SetSpecialPtStartForOpenEdges( const ICurveComposite* pCrvOrig, const Frame3d& frPocket,
+                                          ICurveComposite* pCrvCompo, 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 GetBoxCrvOptTrap( const int nCrv, const ICurveComposite* pCrvCompo, const double dDiam, int& nType, ICurveComposite* pCrvBox) ;
+      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, const double dDiam, const int nType, 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,
+                               const Frame3d& frPocket, Point3d& ptMid, Vector3d& vtMidOut) ;
+      bool AdjustContourStart( ICurveComposite* pCompo, const ICRVCOMPOPOVECTOR& vCrvIsl, bool bOrder = false,
+                               Point3d ptRef = P_INVALID) ;
+      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, ISURFFRPOVECTOR& vSrfLimit, const Vector3d& vtTool, const Vector3d& vtExtr,
+                        const double dDepth, const double dElev, const double dMaxElev, const double dOkStep,
+                        const bool bSplitArcs, const double dExtraLenInOut) ;
+      bool AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVECTOR>& vCrvOrig, BOOLVECTOR& vbChangedPrec,
+                         VCT3DVECTOR& vVtTrasl, ISURFFRPOVECTOR& vSrfLimit, const Vector3d& vtTool, const Vector3d& vtExtr,
+                         double dDepth, double dElev, double dMaxElev, double dOkStep, bool bSplitArcs,
+                         const double dExtraLenInOut) ;
+      bool CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptStart, const Point3d& ptEndPrec, 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 CreateSpiralPocketingPath( ICRVCOMPOPOVECTOR& vOffs, ICURVEPOVECTOR& vLinks,
+                                      const ICRVCOMPOPOVECTOR& vOffsClosedCurves, const ICRVCOMPOPOVECTOR& vOffsFirstCurve) ;
+      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, const ICRVCOMPOPOVECTOR& vOffIslands,
                            ICurveComposite* pCrvLink) ;
+      bool CalcBoundedSmootedLink( const Point3d& ptStart, const Vector3d& vtStart, const Point3d& ptEnd,
+                                   const Vector3d& vtEnd, const double dParMeet,
+                                   const ICRVCOMPOPOVECTOR& vOffIslands, ICurveComposite* pCrvLink) ;
+      bool ModifyBiArc( ICurve* pCrvBiArc, double dCutToll, ICurveComposite* pNewCrv) ;
+      bool CutCurveByOffsets( ICurveComposite* pCurve, ICRVCOMPOPOVECTOR& vOffs) ;
+      bool CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, const ICRVCOMPOPOVECTOR& vOffs,
+                              const 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 CalcSingleOffsetSpiral( const ISurfFlatRegion* pSfr, ICurveComposite* pOffs,
+                                   Point3d& ptStart, Vector3d& vtMidOut, bool& bMidOut) ;
      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 ICurveComposite* pCrvCompo, const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart,
+                      const Vector3d& vtEnd, 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) ;
+      bool SetLeadInPointStart( const Point3d& ptCurr, const Vector3d vtN,
+                                const bool& bAtLeft, Vector3d& vtStart, Point3d& ptDest) ;
+      bool CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFlatRegion* pSfr,
+                           const ISurfFlatRegion* pSfrLimit, ICurveComposite* pCrvStepLink) ;
      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 +346,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 ;            // flag per ottimizzazione numero di Offset necessari
+      bool          m_bOptOffsetCM ;          // flag per ottimizzazione numero di Offset necessari con centroidi e medial Axis
+      bool          m_bAssignFeed ;           // flag per controllo della Feed
+      double        m_dDiam_Prec ;            // diametro utensile per precedente svuotatura
+      double        m_dOffsetR_Prec ;         // offset radiale della svuotatura precedente
+      double        m_dSideStep_Prec ;        // side Step della svuotatura precedente
+      double        m_dLen_Prec ;             // Lunghezza del tool precedente
+      bool          m_bOrderStepZ ;           // parametro per ordinare gli step Extra per Z decrescente o meno
+      bool          m_bPocketPlane ;          // flag per svuotare solo la rimanenza sullo Step Extra
+      double        m_dOpenEdgeRad ;          // raggio di rientro per i lati aperti
 } ;
@@ -521,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) ;
 }

 //----------------------------------------------------------------------------
@@ -843,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
@@ -984,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) ;
@@ -1025,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) ;
@@ -1065,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) ;
@@ -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) ;
@@ -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=") ;
@@ -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)
@@ -2296,7 +2279,7 @@ 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()) ;
@@ -2492,7 +2475,7 @@ 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
+  // dimensione da aggiungere alle regioni nelle parti in cui la lama è inclinata
   double dExtraL = m_pMchMgr->GetCurrMachiningsMgr()->GetExtraLOnCutRegion() ;

  // lunghezza taglio parziale
@@ -2640,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
@@ -2896,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
@@ -2974,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 ;
            }
         }
@@ -3007,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 ;
            }
         }
@@ -3074,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 ;
@@ -3221,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) ;
@@ -3313,7 +3285,7 @@ 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
+  // 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)
@@ -3367,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) ;
@@ -3610,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)
@@ -3696,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)
@@ -3785,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()) ;
@@ -3918,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 ;
@@ -4087,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) {
@@ -4158,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) ;
@@ -282,15 +282,15 @@ Simulator::Move( int& nStatus)
      m_dCoeff = 0 ;
   }

-  // Se appena arrivato alla fine di un percorso di lavoro (verifico anche completamento dei comandi aux di start per path vuote)
-   if ( m_nEntId == GDB_ID_NULL  &&  m_nAuxEInd == 0  &&  m_nCLPathInd > 0  &&  m_nAuxSInd >= m_nAuxSTot) {
+  // Se appena arrivato alla fine di un percorso di lavoro
+   if ( m_nEntId == GDB_ID_NULL  &&  m_nAuxEInd == 0  &&  m_nCLPathInd > 0) {
     // gestione fine percorso di lavoro
      if ( ! ManagePathEnd( nStatus))
         return false ;
   }

-  // Se alla fine del percorso dopo esecuzione azioni ausiliarie (verifico anche completamento dei comandi aux di start per path vuote)
-   if ( m_nEntId == GDB_ID_NULL  &&  m_nAuxEInd >= m_nAuxETot  &&  m_nAuxSInd >= m_nAuxSTot) {
+  // Se alla fine del percorso dopo esecuzione azioni ausiliarie
+   if ( m_nEntId == GDB_ID_NULL  &&  m_nAuxEInd >= m_nAuxETot) {
     // ricerca e gestione inizio percorso di lavoro
      if ( ! FindAndManagePathStart( nStatus))
         return false ;
@@ -579,8 +579,8 @@ Simulator::UpdateAxes( void)
   if ( pMachine == nullptr)
      return false ;
  // Carico i nomi e i token degli assi macchina attivi
-   if ( ! pMachine->GetAllCurrAxesNames( m_AxesName)  ||
-        ! pMachine->GetAllCurrAxesTokens( m_AxesToken))
+   if ( ! pMachine->GetAllCurrAxesName( m_AxesName)  ||
+        ! pMachine->GetAllCurrAxesToken( m_AxesToken))
      return false ;
  // Aggiorno flag di invertito, offset, tipo e posizione corrente degli assi macchina attivi
   for ( size_t i = 0 ; i < m_AxesName.size() ; ++ i) {
@@ -1622,17 +1622,16 @@ Simulator::OnToolSelect( const string& sTool, const string& sHead, int nExit, co
        ! m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_TCPOS, sTcPos))
      return false ;
  // 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) {
-         if ( ! m_pMachine->LuaSetGlobVar( GetGlobVarAxisToken( i, bIsRobot), m_AxesToken[i-1])  ||
-              ! m_pMachine->LuaSetGlobVar( GetGlobVarAxisName( i, bIsRobot), m_AxesName[i-1]))
+         if ( ! m_pMachine->LuaSetGlobVar( GetGlobVarAxisToken(i), m_AxesToken[i-1])  ||
+              ! m_pMachine->LuaSetGlobVar( GetGlobVarAxisName(i), m_AxesName[i-1]))
            return false ;
      }
      else {
-         if ( ! m_pMachine->LuaResetGlobVar( GetGlobVarAxisToken( i, bIsRobot))  ||
-              ! m_pMachine->LuaResetGlobVar( GetGlobVarAxisName( i, bIsRobot)))
+         if ( ! m_pMachine->LuaResetGlobVar( GetGlobVarAxisToken(i))  ||
+              ! m_pMachine->LuaResetGlobVar( GetGlobVarAxisName(i)))
            return false ;
      }
   }
@@ -1875,17 +1874,16 @@ Simulator::OnMoveStart( const CamData* pCamData, int& nErr)
   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_INDEX, pCamData->GetIndex()) ;      
   bOk = bOk && m_pMachine->LuaSetGlobVar( GLOB_VAR + GVAR_ERR, nErr) ;
  // valore degli assi all'inizio e alla fine del movimento
-   bool bIsRobot = m_pMchMgr->GetCurrIsRobot() ;
   int nNumAxes = int( m_AxesName.size()) ;
   const DBLVECTOR& AxesEnd = pCamData->GetAxesVal() ;
   for ( int i = 1 ; i <= MAX_AXES ; ++ i) {
      if ( i <= nNumAxes) {
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisPrev( i, GLOB_VAR, bIsRobot), m_AxesVal[i-1]) ;
-         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot), AxesEnd[i-1]) ;
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisPrev( i), m_AxesVal[i-1]) ;
+         bOk = bOk && m_pMachine->LuaSetGlobVar( GetGlobVarAxisValue( i), AxesEnd[i-1]) ;
      }
      else {
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisPrev( i, GLOB_VAR, bIsRobot)) ;
-         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue( i, GLOB_VAR, bIsRobot)) ;
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisPrev( i)) ;
+         bOk = bOk && m_pMachine->LuaResetGlobVar( GetGlobVarAxisValue( i)) ;
      }
   }
  // versori utensile, correzione e ausiliario alla fine del movimento
@@ -2139,8 +2137,6 @@ Simulator::SetToolForVmill( const string& sTool, const string& sHead, int nExit,
      ExeVolZmapSetSawTool( vVmill, sTool, dLen, dDiam, dThick, 0, dCornR, nFlag, bFirst) ;
   else if ( nType == TT_WATERJET)
      ExeVolZmapSetStdTool( vVmill, sTool, dLen + 50, dDiam, dCornR, dMaxMat, nFlag, bFirst) ;
-   else if ( nType == TT_ADDITIVE)
-      ExeVolZmapSetAdditiveTool( vVmill, sTool, dLen, dDiam, dCornR, nFlag, bFirst) ;
   else if ( abs( dSideAng) < EPS_ANG_SMALL  ||  abs( dThick) < EPS_SMALL) {
      ExeVolZmapSetStdTool( vVmill, sTool, dLen, dDiam, dCornR, dMaxMat, nFlag, bFirst) ;
   }
@@ -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 ;
 }
@@ -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 ;
 } ;
@@ -1676,12 +1676,18 @@ WaterJetting::ProcessPath( int nPathId, int nPvId, int nClId)
   m_pGeomDB->GetName( nPathId, sPathName) ;

  // eventuale approssimazione con segmenti di retta
-   bool bSplitArcs = GetSplitArcs( vtTool) ;
-   if ( ! bSplitArcs) {      
-     // verifiche sull'ampiezza dell'angolo al centro degli eventuali archi
-      VerifyArcs( pCompo) ;
+   int nSplitArcs = m_pMchMgr->GetCurrMachiningsMgr()->GetSplitArcs() ;
+   bool bSplitArcs = ( nSplitArcs == SPLAR_ALWAYS  ||
+                       ( nSplitArcs == SPLAR_NO_XY_PLANE  &&  ! vtTool.IsZplus())  ||
+                       ( nSplitArcs == SPLAR_GEN_PLANE  &&  vtTool.IsGeneric())) ;
+   if ( bSplitArcs  &&  ! ApproxWithLines( pCompo)) {
+      m_pMchMgr->SetLastError( 3211, "Error in WaterJetting : Linear Approx not computable") ;
+      return false ;
   }

+  // verifiche sull'ampiezza dell'angolo al centro degli eventuali archi
+   VerifyArcs( pCompo) ;
+
  // se abilitato probing, verifico lunghezza entità ed eventualmente le divido
   if ( m_Params.m_bProbing)
      VerifyMaxLenCurves( pCompo, m_Params.m_dProbingMaxDist) ;
@@ -1774,8 +1780,8 @@ WaterJetting::GeneratePreView( int nPathId, const ICurveComposite* pCompo, doubl
  // calcolo la regione
   PtrOwner<ISurfFlatRegion> pSfr ;
   double dSideCoeff = ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL ? 1. / cos( m_Params.m_dSideAngle * DEGTORAD) : 1) ;
-   double dRad = 0.5 * m_TParams.m_dDiam * dSideCoeff ;
-   pSfr.Set( GetSurfFlatRegionFromFatCurve( Release( pCrv), dRad, false, false)) ;
+   double Rad = 0.5 * m_TParams.m_dDiam * dSideCoeff ;
+   pSfr.Set( GetSurfFlatRegionFromFatCurve( Release( pCrv), Rad, false, false)) ;
   if ( IsNull( pSfr))
      return false ;
  // aggiungo eventuale attacco
@@ -1787,18 +1793,32 @@ WaterJetting::GeneratePreView( int nPathId, const ICurveComposite* pCompo, doubl
  // aggiungo eventuali anelli su angoli esterni
   if ( ! AddLoopsPreview( pCompo, pSfr))
      return false ;
-  // ne recupero i contorni
-   for ( int i = 0 ; i < pSfr->GetLoopCount( 0) ; ++i) {
-      PtrOwner<ICurve> pCrv2( pSfr->GetLoop( 0, i)) ;
-      if ( IsNull( pCrv2))
-         return false ;
+  // ne recupero il contorno
+   PtrOwner< ICurve> pCrv2 ;
+   pCrv2.Set( pSfr->GetLoop( 0, 0)) ;
+   if ( IsNull( pCrv2))
+      return false ;
+   // inserisco la curva nel DB
+   int nC2Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv2)) ;
+   if ( nC2Id == GDB_ID_NULL)
+      return false ;
+   // assegno nome e colore
+   m_pGeomDB->SetName( nC2Id, MCH_PV_CUT) ;
+   m_pGeomDB->SetMaterial( nC2Id, colCut) ;
+  // eventuali altri contorni ( interni di contornatura chiusa)
+   const int MAX_INT_LOOP = 1000 ;
+   for ( int i = 1 ; i <= MAX_INT_LOOP ; ++i) {
+      PtrOwner< ICurve> pCrv3 ;
+      pCrv3.Set( pSfr->GetLoop( 0, i)) ;
+      if ( IsNull( pCrv3))
+         break ;
     // inserisco la curva nel DB
-      int nC2Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv2)) ;
-      if ( nC2Id == GDB_ID_NULL)
+      int nC3Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv3)) ;
+      if ( nC3Id == GDB_ID_NULL)
         return false ;
     // assegno nome e colore
-      m_pGeomDB->SetName( nC2Id, MCH_PV_CUT) ;
-      m_pGeomDB->SetMaterial( nC2Id, colCut) ;
+      m_pGeomDB->SetName( nC3Id, MCH_PV_CUT) ;
+      m_pGeomDB->SetMaterial( nC3Id, colCut) ;
   }
  // inserisco la regione nel DB
   int nRId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfr)) ;
@@ -1812,11 +1832,10 @@ WaterJetting::GeneratePreView( int nPathId, const ICurveComposite* pCompo, doubl
      return false ;
   m_pGeomDB->SetName( nRrId, MCH_PV_RRCUT) ;
   m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ;
-
  // eventuali ripetizioni in basso per tagli inclinati
   if ( abs( m_Params.m_dSideAngle) > EPS_ANG_SMALL) {
     // creo copia della curva composita
-      PtrOwner<ICurveComposite> pCrv( pCompo->Clone()) ;
+      PtrOwner< ICurve> pCrv( pCompo->Clone()) ;
      if ( IsNull( pCrv))
         return false ;
     // rimuovo eventuale overlap
@@ -1825,114 +1844,98 @@ WaterJetting::GeneratePreView( int nPathId, const ICurveComposite* pCompo, doubl
         pCrv->TrimStartAtLen( dAddedOverlap) ;
         pCrv->Invert() ;
      }
-
-      ICURVEPOVECTOR vpCrvs ;    
-      if ( m_Params.m_dSideAngle < 0) {
-        // se inclinazione negativa devo considerare separatamente ogni sottocurva della composita
-         vpCrvs.reserve( pCrv->GetCurveCount()) ;
-         for ( int i = 0 ; i < pCrv->GetCurveCount() ; i++)
-            vpCrvs.emplace_back( pCrv->GetCurve( i)->Clone()) ;     
-      }
-      else {
-        // se inclinazione positiva posso considerare la curva completa
-         vpCrvs.emplace_back( pCrv->Clone()) ;
-      }
-      
     // offset per raggio utensile
-      double dSignOffs1 = dRad ;
+      double dRad = 0.5 * m_TParams.m_dDiam / cos( m_Params.m_dSideAngle * DEGTORAD) ;
+      double dSignOffs1 =  dRad ;
      if ( ( m_Params.m_nWorkSide == WJET_WS_RIGHT  &&  m_Params.m_dSideAngle > 0)  ||
           ( m_Params.m_nWorkSide == WJET_WS_LEFT  &&  m_Params.m_dSideAngle < 0))
         dSignOffs1 = - dSignOffs1 ;
+      OffsetCurve OffsCrv1 ;
+      OffsCrv1.Make( pCrv, dSignOffs1, ICurve::OFF_FILLET) ;
+      PtrOwner< ICurve> pOffs1( OffsCrv1.GetLongerCurve()) ;
+      if ( IsNull( pOffs1))
+         return false ;
     // offset per inclinazione
      double dSignOffs2 = dRad + m_dElev * abs( sin( m_Params.m_dSideAngle * DEGTORAD)) ;
      if ( ( m_Params.m_nWorkSide == WJET_WS_RIGHT  &&  m_Params.m_dSideAngle < 0)  ||
           ( m_Params.m_nWorkSide == WJET_WS_LEFT  &&  m_Params.m_dSideAngle > 0))
         dSignOffs2 = - dSignOffs2 ;
-
+      OffsetCurve OffsCrv2 ;
+      OffsCrv2.Make( pCrv, dSignOffs2, ICurve::OFF_EXTEND) ;
+      PtrOwner< ICurve> pOffs2( OffsCrv2.GetLongerCurve()) ;
+      if ( IsNull( pOffs2))
+         return false ;
     // calcolo la regione
-      PtrOwner<ISurfFlatRegion> pSfr( CreateSurfFlatRegion()) ;
+      PtrOwner<ISurfFlatRegion> pSfr ;
+     // se i due offset sono aperti
+      if ( ! pOffs1->IsClosed()  &&  ! pOffs2->IsClosed()) {
+        // li unisco
+         PtrOwner<ICurveComposite> pBound( CreateCurveComposite()) ;
+         if ( IsNull( pBound))
+            return false ;
+         pBound->AddCurve( Release( pOffs1)) ;
+         pOffs2->Invert() ;
+         Point3d ptStart ; pOffs2->GetStartPoint( ptStart) ;
+         pBound->AddLine( ptStart) ;
+         pBound->AddCurve( Release( pOffs2)) ;
+         pBound->Close() ;
+        // creo la regione
+         SurfFlatRegionByContours SfrCntr( false, false) ;
+         SfrCntr.AddCurve( Release( pBound)) ;
+         pSfr.Set( SfrCntr.GetSurf()) ;
+      }
+     // altrimenti sono chiusi
+      else {
+        // creo la regione
+         SurfFlatRegionByContours SfrCntr( false, false) ;
+         SfrCntr.AddCurve( Release( pOffs1)) ;
+         SfrCntr.AddCurve( Release( pOffs2)) ;
+         pSfr.Set( SfrCntr.GetSurf()) ;
+      }
      if ( IsNull( pSfr))
         return false ;
-      for ( int i = 0 ; i < int( vpCrvs.size()) ; i++) {
-         OffsetCurve OffsCrv1 ;
-         OffsCrv1.Make( vpCrvs[i], dSignOffs1, ICurve::OFF_FILLET) ;
-         PtrOwner< ICurve> pOffs1( OffsCrv1.GetLongerCurve()) ;
-         if ( IsNull( pOffs1))
-            return false ;
-         OffsetCurve OffsCrv2 ;
-         OffsCrv2.Make( vpCrvs[i], dSignOffs2, ICurve::OFF_EXTEND) ;
-         PtrOwner< ICurve> pOffs2( OffsCrv2.GetLongerCurve()) ;
-         if ( IsNull( pOffs2))
-            return false ;
-        // calcolo la regione corrente
-         PtrOwner<ISurfFlatRegion> pSfrCurr ;
-        // se i due offset sono aperti         
-         if ( ! pOffs1->IsClosed()  &&  ! pOffs2->IsClosed()) {
-           // li unisco
-            PtrOwner<ICurveComposite> pBound( CreateCurveComposite()) ;
-            if ( IsNull( pBound))
-               return false ;
-            pBound->AddCurve( Release( pOffs1)) ;
-            pOffs2->Invert() ;
-            Point3d ptStart ; pOffs2->GetStartPoint( ptStart) ;
-            pBound->AddLine( ptStart) ;
-            pBound->AddCurve( Release( pOffs2)) ;
-            pBound->Close() ;
-           // creo la regione
-            SurfFlatRegionByContours SfrCntr( false, false) ;
-            SfrCntr.AddCurve( Release( pBound)) ;
-            pSfrCurr.Set( SfrCntr.GetSurf()) ;
-         }
-        // altrimenti sono chiusi
-         else {
-           // creo la regione
-            SurfFlatRegionByContours SfrCntr( false, false) ;
-            SfrCntr.AddCurve( Release( pOffs1)) ;
-            SfrCntr.AddCurve( Release( pOffs2)) ;
-            pSfrCurr.Set( SfrCntr.GetSurf()) ;
-         }
-         if ( IsNull( pSfrCurr))
-            return false ;
-
-        // aggiungo alla superficie complessiva
-         if ( pSfr->IsValid())
-            pSfr->Add( *pSfrCurr) ;
-         else
-            pSfr.Set( Release( pSfrCurr)) ;      
-      }
     // la regione deve essere rivolta verso Z+
      if ( pSfr->GetNormVersor().z < 0)
         pSfr->Invert() ;
-
-     // aggiungo eventuali loops
-      AddLoopsPreview( pCrv, pSfr) ;
-
-     // ne recupero i contorni
-      for ( int i = 0 ; i < pSfr->GetLoopCount( 0) ; ++i) {
-         PtrOwner<ICurve> pCrv2( pSfr->GetLoop( 0, i)) ;
-         if ( IsNull( pCrv2))
+      // ne recupero il contorno
+      PtrOwner< ICurve> pCrv2 ;
+      pCrv2.Set( pSfr->GetLoop( 0, 0)) ;
+      if ( IsNull( pCrv2))
+         return false ;
+      // inserisco la curva nel DB
+      int nC2Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv2)) ;
+      if ( nC2Id == GDB_ID_NULL)
+         return false ;
+      // assegno nome e colore
+      m_pGeomDB->SetName( nC2Id, MCH_PV_DOWN_CUT) ;
+      m_pGeomDB->SetMaterial( nC2Id, colCut) ;
+      // eventuali altri contorni ( interni di contornatura chiusa)
+      const int MAX_INT_LOOP = 1000 ;
+      for ( int i = 1 ; i <= MAX_INT_LOOP ; ++i) {
+         PtrOwner< ICurve> pCrv3 ;
+         pCrv3.Set( pSfr->GetLoop( 0, i)) ;
+         if ( IsNull( pCrv3))
+            break ;
+         // inserisco la curva nel DB
+         int nC3Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv3)) ;
+         if ( nC3Id == GDB_ID_NULL)
            return false ;
-        // inserisco la curva nel DB
-         int nC2Id = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pCrv2)) ;
-         if ( nC2Id == GDB_ID_NULL)
-            return false ;
-        // assegno nome e colore
-         m_pGeomDB->SetName( nC2Id, MCH_PV_DOWN_CUT) ;
-         m_pGeomDB->SetMaterial( nC2Id, colCut) ;
+         // assegno nome e colore
+         m_pGeomDB->SetName( nC3Id, MCH_PV_DOWN_CUT) ;
+         m_pGeomDB->SetMaterial( nC3Id, colCut) ;
      }
-
-     // inserisco la regione nel DB
+      // inserisco la regione nel DB
      int nRId = m_pGeomDB->AddGeoObj( GDB_ID_NULL, nPathId, Release( pSfr)) ;
      if ( nRId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nRId, MCH_PV_DOWN_RCUT) ;
      m_pGeomDB->SetMaterial( nRId, INVISIBLE) ;
-     // la copio anche come regione ridotta
+      // la copio anche come regione ridotta
      int nRrId = m_pGeomDB->Copy( nRId, GDB_ID_NULL, nPathId) ;
      if ( nRrId == GDB_ID_NULL)
         return false ;
      m_pGeomDB->SetName( nRrId, MCH_PV_DOWN_RRCUT) ;
-      m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ;   
+      m_pGeomDB->SetMaterial( nRrId, INVISIBLE) ;
   }
   return true ;
 }
@@ -2080,11 +2083,6 @@ WaterJetting::AddLoopsPreview( const ICurveComposite* pCompo, ISurfFlatRegion* p
            return false ;
        // lunghezza tratti lineari e loro punti estremi
         double dTgLen = 0.5 * m_TParams.m_dDiam * tan( 0.5 * dAng * DEGTORAD) ;
-         if ( m_Params.m_dSideAngle > EPS_ANG_SMALL) {
-            double dW = m_dElev * sin( m_Params.m_dSideAngle * DEGTORAD) ;
-            double dExtraLen = dW / tan( ( 180 - abs( dAng)) / 2 * DEGTORAD) ; 
-            dTgLen += dExtraLen ;
-         }
         Point3d ptP ; pCrvC->GetStartPoint( ptP) ;
         Point3d ptPe = ptP + vtEnd * dTgLen ;
         Point3d ptPs = ptP - vtStart * dTgLen ;
@@ -2117,6 +2115,7 @@ WaterJetting::AddLoopsPreview( const ICurveComposite* pCompo, ISurfFlatRegion* p
         if ( IsNull( pSfr)  ||  ! pSPV->Add( *pSfr))
            return false ;
      }
+
   }
   return true ;
 }
@@ -2248,7 +2247,7 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
        // imposto versore correzione e ausiliario sul punto di partenza
         CalcAndSetToolCorrAuxDir( pCompo, i) ;
        // aggiungo approccio al punto iniziale
-         if ( ! AddApproach( ptP1, vtTool, dSafeZ, bSplitArcs)) {
+         if ( ! AddApproach( ptP1, vtTool, dSafeZ)) {
            m_pMchMgr->SetLastError( 3207, "Error in WaterJetting : Approach not computable") ;
            return false ;
         }
@@ -2274,57 +2273,27 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
         vtEnd.GetAngleXY( vtStart, dAng) ;
        // Se angolo esterno e richiesto anello esterno
         if ( IsExternalAngle( dAng)  &&  m_Params.m_nExtCornerType == WJET_EC_LOOP) {
-           // lunghezza tratti lineari
+           // lunghezza tratti lineari e loro punti estremi
            double dTgLen = 0.5 * m_TParams.m_dDiam * tan( 0.5 * dAng * DEGTORAD) ;
-            if ( m_Params.m_dSideAngle > EPS_ANG_SMALL) {
-              // se inclinazione positiva calcolo di quanto deve uscire per non rovinare lo spigolo
-               double dW = m_dElev * sin( m_Params.m_dSideAngle * DEGTORAD) ;
-               double dExtraLen = dW / tan( ( 180 - abs( dAng)) / 2 * DEGTORAD) ; 
-               dTgLen += dExtraLen ;
-            }         
-           // calcolo punti estremi
            Point3d ptP ; pCrvC->GetStartPoint( ptP) ;
            Point3d ptPe = ptP + vtEnd * dTgLen ;
            Point3d ptPs = ptP - vtStart * dTgLen ;
-
           // tratto prima dell'anello
            SetFeed( GetActualFeed()) ;
-            if ( AddLinearMove( ptPe, bSplitArcs) == GDB_ID_NULL)
+            if ( AddLinearMove( ptPe) == GDB_ID_NULL)
               return false ;
-
           // anello
            PtrOwner<ICurve> pCrvA( GetArc2PVN( ptPe, ptPs, vtEnd, vtN)) ;
            if ( ! IsNull( pCrvA)  &&  pCrvA->GetType() == CRV_ARC) {
-              // suddivido l'anello in due parti per forzare il passaggio dalla posizione vtTool = Z_AX
-               PtrOwner<ICurveComposite> pCompoArc( ConvertCurveToComposite( Release( ( pCrvA)))) ;
-               if ( IsNull( pCompoArc))
+               if ( AddCurveMove( pCrvA) == GDB_ID_NULL)
                  return false ;
-               if ( pCompoArc->AddJoint( 0.5)) {
-                 // aggiungo il primo tratto
-                  Vector3d vtCorr = CalcCorrDir( pCompoArc, 1) ;                   
-                  SetToolCorrAuxDir( Z_AX, vtCorr) ;
-                  if ( AddCurveMove( pCompoArc->GetCurve(0), bSplitArcs) == GDB_ID_NULL)
-                     return false ;
-                 // aggiungo secondo tratto
-                  CalcAndSetToolCorrAuxDir( pCompo, i + 0.5) ;
-                  if ( AddCurveMove( pCompoArc->GetCurve(1), bSplitArcs) == GDB_ID_NULL)
-                     return false ;               
-               }
-               else {
-                 // se non è possibile suddividere anello 
-                  CalcAndSetToolCorrAuxDir( pCompo, i + 0.5) ;
-                  if ( AddCurveMove( pCompoArc, bSplitArcs) == GDB_ID_NULL)
-                     return false ;   
-               }               
            }
            else {
-               CalcAndSetToolCorrAuxDir( pCompo, i + 0.5) ;
-               if ( AddLinearMove( ptPs, bSplitArcs) == GDB_ID_NULL)
+               if ( AddLinearMove( ptPs) == GDB_ID_NULL)
                  return false ;
            }
-
           // tratto dopo l'anello
-            if ( AddLinearMove( ptP, bSplitArcs) == GDB_ID_NULL)
+            if ( AddLinearMove( ptP) == GDB_ID_NULL)
               return false ;
         }
        // se angolo esterno e richiesto rallentamento esterno, eseguo accelerazione
@@ -2344,7 +2313,7 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
                  return false ;
               CalcAndSetToolCorrAuxDir( pCompo, i + dU) ;
               SetFeed( ( 1 - dCoeff) * dMinFeed + dCoeff * GetActualFeed()) ;
-               if ( AddCurveMove( pCrvT, bSplitArcs) == GDB_ID_NULL)
+               if ( AddCurveMove( pCrvT) == GDB_ID_NULL)
                  return false ;
               dUprev = dU ;
            }
@@ -2386,7 +2355,7 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
               Vector3d vtCorr = CalcCorrDir( pCompo, i + dU) ;
               SetToolCorrAuxDir( vtTool, vtCorr) ;
               SetFeed( ( 1 - dCoeff) * dMinFeed + dCoeff * GetActualFeed()) ;
-               if ( AddCurveMove( pCrvT, bSplitArcs) == GDB_ID_NULL)
+               if ( AddCurveMove( pCrvT) == GDB_ID_NULL)
                  return false ;
               dUprev = dU ;
            }
@@ -2423,7 +2392,7 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
                  return false ;
               CalcAndSetToolCorrAuxDir( pCompo, i + dU) ;
               SetFeed( ( 1 - dCoeff) * GetActualFeed() + dCoeff * dMinFeed) ;
-               if ( AddCurveMove( pCrvT, bSplitArcs) == GDB_ID_NULL)
+               if ( AddCurveMove( pCrvT) == GDB_ID_NULL)
                  return false ;
               dUprev = dU ;
            }
@@ -2466,22 +2435,15 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
               Vector3d vtCorr = CalcCorrDir( pCompo, i + dU) ;
               SetToolCorrAuxDir( vtTool, vtCorr) ;
               SetFeed( ( 1 - dCoeff) * GetActualFeed() + dCoeff * dMinFeed) ;
-               if ( AddCurveMove( pCrvT, bSplitArcs) == GDB_ID_NULL)
+               if ( AddCurveMove( pCrvT) == GDB_ID_NULL)
                  return false ;
               dUprev = dU ;
            }
            dNextFeed = dMinFeed ;
         }
-
-        // se successivo non è angolo esterno ad anello imposto versore correzione e ausiliario del punto di arrivo
-         if ( ! IsExternalAngle( dAng)  ||  m_Params.m_nExtCornerType != WJET_EC_LOOP)
-            CalcAndSetToolCorrAuxDir( pCompo, i + 1) ;
      }
-      else {
-        // se ultima entità imposto versore correzione e ausiliario del punto finale
-         CalcAndSetToolCorrAuxDir( pCompo, i + 1) ;  
-      }     
-     
+     // imposto versore correzione e ausiliario del punto di arrivo
+      CalcAndSetToolCorrAuxDir( pCompo, i + 1) ;
     // elaborazioni sulla curva corrente
      if ( pCurve->GetType() == CRV_LINE) {
         ICurveLine* pLine = GetCurveLine( pCurve) ;
@@ -2494,20 +2456,25 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
         }
         else
            ++ nIdxSkip ;
-         if ( AddLinearMove( ptP3, bSplitArcs) == GDB_ID_NULL)
+         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
            return false ;
      }
      else if ( pCurve->GetType() == CRV_ARC) {
+         ICurveArc* pArc = GetCurveArc( pCurve) ;
+         Point3d ptCen = pArc->GetCenter() ;
+         double dAngCen = pArc->GetAngCenter() ;
+         Point3d ptP3 ; pArc->GetEndPoint( ptP3) ;
+         Point3d ptCurr ; GetCurrPos( ptCurr) ;
+         double dDeltaAng ; pArc->CalcPointAngle( ptCurr, dDeltaAng) ;
         SetFeed( dNextFeed) ;
        // controlli per indice del punto di arrivo
-         Point3d ptP3 ; pCurve->GetEndPoint( ptP3) ;
         if ( SqDistXY( ptP3, m_ptLastProbe) >= m_Params.m_dProbingMinDist * m_Params.m_dProbingMinDist) {
            SetIndex( i + 1 - nIdxSkip) ;
            m_ptLastProbe = ptP3 ;
         }
         else
            ++ nIdxSkip ;
-         if ( AddCurveMove( pCurve, bSplitArcs) == GDB_ID_NULL)
+         if ( AddArcMove( ptP3, ptCen, dAngCen - dDeltaAng, vtN) == GDB_ID_NULL)
            return false ;
      }
     // se ultima entità, uscita e retrazione
@@ -2524,7 +2491,7 @@ WaterJetting::AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTo
         }
        // aggiungo retrazione
         SetFlag( 203) ;
-         if ( ! AddRetract( ptP1, vtTool, dSafeZ, bSplitArcs)) {
+         if ( ! AddRetract( ptP1, vtTool, dSafeZ)) {
            m_pMchMgr->SetLastError( 3210, "Error in WaterJetting : Retract not computable") ;
            return false ;
         }
@@ -2558,7 +2525,7 @@ class LeadIOStatus

 //----------------------------------------------------------------------------
 bool
-WaterJetting::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, bool bSplit)
+WaterJetting::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ)
 {
   SetFlag( 1) ;
  // 1 -> punto sopra inizio
@@ -2567,18 +2534,18 @@ WaterJetting::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double dS
      return false ;
  // affondo al punto iniziale
   SetFlag( ( m_Params.m_bLiHole ? 201 : 202)) ;
-   if ( AddRapidMove( ptP, bSplit) == GDB_ID_NULL)
+   if ( AddRapidMove( ptP) == GDB_ID_NULL)
      return false ;
   return true ;
 }

 //----------------------------------------------------------------------------
 bool
-WaterJetting::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, bool bSplit)
+WaterJetting::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ)
 {
  // Risalgo in rapido alla quota di sicurezza
   Point3d ptP4 = ptP + vtTool * dSafeZ ;
-   if ( AddRapidMove( ptP4, bSplit) == GDB_ID_NULL)
+   if ( AddRapidMove( ptP4) == GDB_ID_NULL)
      return false ;
   return true ;
 }
@@ -2628,19 +2595,29 @@ WaterJetting::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vect
 {
  // Assegno il tipo
   int nType = GetLeadInType() ;
+   double dTang = m_Params.m_dLiTang ;
  // Eseguo a seconda del tipo
   switch ( nType) {
   case WJET_LI_NONE :
      return true ;
   case WJET_LI_LINEAR :
-      return ( AddLinearMove( ptStart, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;
+      return ( AddLinearMove( ptStart, MCH_CL_LEADIN) != GDB_ID_NULL) ;
   case WJET_LI_TANGENT :
      {
         PtrOwner<ICurve> pCrv( GetArc2PVN( ptStart, ptP1, - vtStart, vtN)) ;
         if ( IsNull( pCrv))
            return false ;
         pCrv->Invert() ;
-         return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADIN) != GDB_ID_NULL) ;     
+        // eventuale spezzatura
+         if ( bSplitArcs) {
+            PtrOwner<ICurveComposite> pCompo ;
+            if ( ! pCompo.Set( ConvertCurveToComposite( Release( pCrv)))  ||  ! ApproxWithLines( pCompo))
+               return false ;
+            return ( AddCurveMove( pCompo, MCH_CL_LEADIN) != GDB_ID_NULL) ;          
+         }
+         else {
+            return ( AddCurveMove( pCrv, MCH_CL_LEADIN) != GDB_ID_NULL) ;
+         }
      }
   default :
      return false ;
@@ -2690,7 +2667,7 @@ WaterJetting::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vec
         Vector3d vtPerp = vtEnd ;
         vtPerp.Rotate( vtN, 0, ( bCcwRot ? 1 : - 1)) ;
         ptP1 = ptEnd + vtEnd * dTang + vtPerp * dPerp ;
-         return ( AddLinearMove( ptP1, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
+         return ( AddLinearMove( ptP1, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
      }
   case WJET_LO_TANGENT :
      {
@@ -2702,7 +2679,16 @@ WaterJetting::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Vec
         PtrOwner<ICurve> pCrv( GetArc2PVN( ptEnd, ptP1, vtEnd, vtN)) ;
         if ( IsNull( pCrv))
            return false ;
-         return ( AddCurveMove( pCrv, bSplitArcs, MCH_CL_LEADOUT) != GDB_ID_NULL) ;        
+        // eventuale spezzatura
+         if ( bSplitArcs) {
+            PtrOwner<ICurveComposite> pCompo ;
+            if ( ! pCompo.Set( ConvertCurveToComposite( Release( pCrv)))  ||  ! ApproxWithLines( pCompo))
+               return false ;
+            return ( AddCurveMove( pCompo, MCH_CL_LEADOUT) != GDB_ID_NULL) ;          
+         }
+         else {
+            return ( AddCurveMove( pCrv, MCH_CL_LEADOUT) != GDB_ID_NULL) ;
+         }
      }
   default :
      return false ;
@@ -2966,7 +2952,7 @@ WaterJetting::CalcOffset( ICurveComposite* pCompo, double dSignOffs)

 //----------------------------------------------------------------------------
 // Valore limite angolo per corner
-const double ANG_CORNER = 10 ;    
+const double ANG_CORNER = 10 ;

 //----------------------------------------------------------------------------
 bool
@@ -81,8 +81,8 @@ class WaterJetting : public Machining
      bool AddLeadOutPreview( const ICurveComposite* pCompo, ISurfFlatRegion* pSPV) ;
      bool AddLoopsPreview( const ICurveComposite* pCompo, ISurfFlatRegion* pSPV) ;
      bool AddStandardWj( const ICurveComposite* pCompo, const Vector3d& vtTool, bool bSplitArcs) ;
-      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 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,
Author	SHA1	Message	Date
Riccardo Elitropi	a1113ad94c	EgtMachKernel : - Aggiunta funzione per tasche passanti per volumi esterni al grezzo. - migliorata la gestione dei lati aperti piccoli ( da testare ) - migliorie varie .	2024-03-13 11:23:07 +01:00
Riccardo Elitropi	c321205086	EgtMachKernel : - migliore svuotature.	2024-03-12 13:37:00 +01:00
Riccardo Elitropi	33f969a254	Merge commit '839639fcc85a0ff8799a6e2fc8e8778ad8772066' into Svuotature_LeadIn/Out	2024-03-04 13:26:55 +01:00
Riccardo Elitropi	aad600faca	EgtMachKernel : - aggiunta svuotatura ottimizzata a spirale - correzioni varie.	2024-03-04 13:26:39 +01:00
Riccardo Elitropi	caee6ccb83	EgtMachKernel : - migliorata gestione Archi - migliorata gestioni lati aperti e gestione delle operazioni booleane tra regioni piane - migliorie varie.	2024-03-01 17:51:23 +01:00
Riccardo Elitropi	0980e10c33	Merge commit 'd3b281a858c34a3f760c5afd925417b421b1a6d6' into Svuotature_LeadIn/Out	2024-02-26 16:10:46 +01:00
Riccardo Elitropi	85258fe4c4	EgtMachKernel : - migliorata gestione lati aperti e scelta ordine degli Offset. - migliorie generali.	2024-02-26 16:08:59 +01:00
Riccardo Elitropi	ecc2c66fac	Merge commit '737124b0bd167e644bb1c0131e675f515cbecb1f' into Svuotature_LeadIn/Out	2024-02-22 09:48:25 +01:00
Riccardo Elitropi	97a0aed32c	EgtMachKernel : - piccola miglioria.	2024-02-22 09:48:05 +01:00
Riccardo Elitropi	c23c975275	Merge commit '028a5b7bbaab65b2d1111aeb67560a6ea01e0f39' into Svuotature_LeadIn/Out	2024-02-13 12:26:04 +01:00
Riccardo Elitropi	b9e0c6e7e3	EgtMachKernel : - implementazione Dijkstra per percorsi di ritorno.	2024-02-13 12:25:28 +01:00
Riccardo Elitropi	dd28529753	Merge commit '1179ad7e84b5d7bca253c3219b8ba01e10082a08' into Svuotature_LeadIn/Out	2024-02-09 08:01:06 +01:00
Riccardo Elitropi	9d471f4647	EgtMachKernel : - migliorie sui lati aperti.	2024-02-05 12:08:47 +01:00
Riccardo Elitropi	6c8d1931f3	EgtMachKernel : - aggiunta gestione parametri ( Lati Aperti e Offset ottimizzati).	2024-02-02 13:00:37 +01:00
Riccardo Elitropi	7f8798a159	EgtMachKernel : - migliorie selezione lati aperti. - migliorie percorsi di ritorno.	2024-02-02 11:47:47 +01:00
Riccardo Elitropi	443fac5f0f	EgtMachKernel : - semplificazione curve con archi.	2024-02-01 13:23:43 +01:00
Riccardo Elitropi	84fc7b0dc3	EgtMachKernel : - codice di prova per VRONI - entrate Spiral - ZigZag.	2024-01-31 13:22:23 +01:00
Riccardo Elitropi	4f64b1efc2	EgtMachKernel : - Entrate Helix e ZigZag ( codice di prova).	2024-01-30 13:30:18 +01:00
Riccardo Elitropi	9c09f30f08	Merge commit 'd8c5fe0ea751afacaf031f6029b0ce07b22b1547' into Svuotature_LeadIn/Out	2024-01-30 11:08:49 +01:00
Riccardo Elitropi	e10f917bab	EgtMachKernel : - caricamento codice per Merge.	2024-01-30 11:05:08 +01:00
Riccardo Elitropi	073c5f737e	EgtMachKernel : - migliorie Tagli e Proeizioni - percorsi di ritorno con Bisettori.	2024-01-22 13:04:13 +01:00
Riccardo Elitropi	d57198ac19	EgtMachKernel : - percorsi di ritorno con Vroni smussati ( algoritmo Douglas-Peucker).	2024-01-19 13:35:19 +01:00
Riccardo Elitropi	ea20040495	Merge commit 'd66cc479364215ad5a542e0b9051d399e0b3c0d1' into Svuotature_LeadIn/Out	2024-01-19 11:48:20 +01:00
Riccardo Elitropi	6adad38ffa	EgtMachKernel : - migliorie lati aperti - aggiunta messaggi errore.	2024-01-18 13:06:31 +01:00
Riccardo Elitropi	bac737ee53	EgtMachKernel : - Aggiunta caso speciale per Tool non cilindrici.	2024-01-18 09:18:37 +01:00
Riccardo Elitropi	4ae515befd	EgtMachKernel : - LeadIn/Out tool non cilindrici.	2024-01-17 13:20:51 +01:00
Riccardo Elitropi	58b119c68f	EgtMachKernel : - LeadIn/Out tool non cilindrici, casi ottimizzati a trapezio.	2024-01-16 13:32:56 +01:00
Riccardo Elitropi	28e76415ed	EgtMachKernel : - LeadIn/Out Spiral per tool non cilindrici.	2024-01-15 13:36:53 +01:00
Riccardo Elitropi	c163fe503e	EgtMachKernel : - Test per entrate/Uscite con tool non cilindrici. - Proiezioni facce chiuse con tool non cilindrici.	2024-01-15 11:12:08 +01:00
Riccardo Elitropi	c928a50243	EgtMachKernel : - prima prova con tool non cilindrici, proiezioni.	2024-01-12 13:38:23 +01:00
Riccardo Elitropi	ac8feb7a17	EgtMachKernel : - utilizzo della funzione limite per LeadIn/Out.	2024-01-11 17:57:23 +01:00
Riccardo Elitropi	8ae1d4cdc2	EgtMachKernel : - LeadIn/Out VORONOI e Dijkstra per casi ottimizzati a Spirale. - migliorie sui percotrsi di ritorno.	2024-01-10 18:28:17 +01:00
Riccardo Elitropi	d684f6fb82	EgtMachKernel : - LeadIn/Out con VORONI e Dijkstra ( cammini minimi).	2024-01-09 18:48:31 +01:00
Riccardo Elitropi	0cbf148bb6	EgtMachKernel : - primo Test LeadIn/Out con VRONI.	2024-01-08 13:23:43 +01:00
Riccardo Elitropi	ee9a446cc0	EgtMachKernel : - Primo calcolo di LeadIn/Out.	2024-01-05 13:30:07 +01:00
Riccardo Elitropi	2e1d893d5d	EgtMachKernel : - Gestione LeadIn/Out ( inizio stesura funzioni).	2024-01-04 13:00:55 +01:00
Riccardo Elitropi	cdfa857c02	Merge commit 'b7eee50e55973024da5fc7d80020ee7daacf64d2' into Svuotature_LeadIn/Out	2024-01-04 09:37:36 +01:00
Riccardo Elitropi	b7eee50e55	EgtMachKernel : - modifica funzione lati aperti.	2024-01-04 09:35:51 +01:00
Riccardo Elitropi	3cda97534e	EgtMachKernel : -piccola modifica.	2024-01-04 09:35:14 +01:00
Riccardo Elitropi	5975b00def	EgtMachKernel : - implementazione CalcRegionElevation.	2024-01-04 09:33:47 +01:00
Riccardo Elitropi	d845442ebd	Merge commit 'b5ef9ae6dc7564e172af1a7558348e60b5da6a0f' into svuotature	2024-01-03 09:32:55 +01:00
Riccardo Elitropi	511d1c0aef	EgtMachKernel : - primo codice per Lead In/out.	2023-12-22 13:12:32 +01:00
Riccardo Elitropi	4c25e19753	EgtMachKernel : - migliorie codice.	2023-12-22 11:59:17 +01:00
Riccardo Elitropi	f8de95a6b6	EgtMachKernel : - adattamento funzione VerifyPathFromBottom e GeneratePocketingPv.	2023-12-19 11:45:10 +01:00
Riccardo Elitropi	2c1cd101b2	EgtMachKernel : - Aggiunta funzione che svuota le parti non svuotate di una lavorazione precedente.	2023-12-19 11:01:39 +01:00
Riccardo Elitropi	f5a94ee0dd	EgtMachKernel : - lavorazione precedente. Primo test.	2023-12-18 13:10:38 +01:00
Riccardo Elitropi	790660e549	EgtMachKernel : - rimozione funzioni non necessarie e pulizia codice.	2023-12-18 09:08:15 +01:00
Riccardo Elitropi	d60cec01ef	EgtMachKernel : - primo codice di Test Volumi di svuotatura.	2023-12-15 19:31:11 +01:00
Riccardo Elitropi	9267f902ae	EgtMachKernel : merge con Master.	2023-11-29 12:41:34 +01:00
Riccardo Elitropi	4558f5d842	Merge commit 'c8c8d9e2a52041f2b511b5a4d9325945733f0a22' into svuotature	2023-11-29 12:27:32 +01:00
Riccardo Elitropi	a404881759	EgtMachKernel : - migliorata gestione Chunk per OneWay.	2023-11-29 12:19:06 +01:00
Riccardo Elitropi	77cd16a5b6	EgtMachKernel : - volumi di pocketing .	2023-11-15 13:17:43 +01:00
Riccardo Elitropi	c89683cc0e	EgtmachKernel : - primo codice per ricavare Volume di Pocketing.	2023-11-14 13:26:09 +01:00
Riccardo Elitropi	cc50f573bc	EgtMachKernel : modifica funzione GetCurves.	2023-11-13 13:29:58 +01:00
Riccardo Elitropi	c13dba8c9f	EgtMachKernel : - codice senza considerare il volume di svuotatura.	2023-11-13 08:15:21 +01:00
Riccardo Elitropi	c8cd417dac	EgtMachKernel : - migliorie codice con test reali.	2023-11-09 17:11:39 +01:00
Riccardo Elitropi	ce704bdcbc	EgtMachKernel : - migliorato codice OneWay.	2023-11-08 13:40:49 +01:00
Riccardo Elitropi	7ca922c9b6	EgtMachKernel : - codice per casi ottimizzati ZigZag.	2023-11-07 17:46:49 +01:00
Riccardo Elitropi	4d02f573d2	EgtMachKernel : - codice di test migliorato per casi ottimizzati a spirale.	2023-11-06 18:34:10 +01:00
Riccardo Elitropi	0dfc9a38da	EgtMachKernel : - primo codice di test da migliorare per Trapezi SpiralIn/Out.	2023-11-03 18:17:26 +01:00
Riccardo Elitropi	4ed4445d09	EgtMachKernel : - Prime idee per ottimizzazioni.	2023-11-02 17:57:28 +01:00
Riccardo Elitropi	072b47590e	EgtMachKernel : - casi ottimizzati Trapezi ( Codice non testato).	2023-10-31 16:43:04 +01:00
Riccardo Elitropi	31980fb85f	EgtMachKernel : - primo codice di prova per ottimizzazioni su step con geometrie uguali ( SpiralIn/Out/ZigZag).	2023-10-30 11:47:17 +01:00
Riccardo Elitropi	f51b05da5b	EgtMachKernel : - entrate rese coerenti tra i vari step ( SpiralIn/Out) - rimozione del ricalcolo dei percorsi nel caso di geometria uguale tra gli step (SpiralIn/Out).	2023-10-11 13:17:34 +02:00
Riccardo Elitropi	46868459ae	Merge commit 'b3a1ee8e6cbe1ea0c56e64133c96300e3f22bf89' into svuotature	2023-10-10 11:15:54 +02:00
Riccardo Elitropi	ac85a09ff2	EgtMachKernel : - migliorie per entrate.	2023-10-10 11:04:59 +02:00
Riccardo Elitropi	4ed01598a5	EgtMachKernel : - controllo validità superfici e coerenza con le normali.	2023-09-18 13:17:24 +02:00
Riccardo Elitropi	ec91d76869	EgtMachKernel : - migliorie proeiezioni e gesitoni lati aperti.	2023-09-15 13:06:31 +02:00
Riccardo Elitropi	cee893f4ca	EgtMachKernel : - migliorie varie.	2023-09-13 13:20:55 +02:00
Riccardo Elitropi	4e23dbe156	EgtMachKernel : - migliorie gestioni lati aperti in adattamento a TriMesh - inizio risoluzione problemi per lati aperti dentro al grezzo.	2023-09-12 17:35:31 +02:00
Riccardo Elitropi	944473df2e	EgtMachKernel : - migliorie gestioni lati aperti con isole chiuse molto vicine. - migliorie generali e pulizia codice.	2023-09-11 13:31:23 +02:00
Riccardo Elitropi	efde63ba64	EgtMachKernel : - migliorie approssimazione curve e FlatRegions.	2023-09-08 13:41:35 +02:00
Riccardo Elitropi	09cddcf9ac	EgtMachKernel : - migliorie approssimazione sulle curve - casi ottimizzati ZigZag con isole.	2023-09-07 13:08:34 +02:00
Riccardo Elitropi	7dcf367d48	EgtMachKernel : - pulizia codice.	2023-09-06 09:48:03 +02:00
Riccardo Elitropi	5562a0f20c	Merge commit 'f30f028b171a931f82cd15e95b4bea832a33c540' into svuotature	2023-09-06 09:47:26 +02:00
Riccardo Elitropi	05fb2ad32b	EgtMachKernel : - prova per svuotatura King e Sella.	2023-09-05 15:24:39 +02:00
Riccardo Elitropi	e146e1b6da	EgtMachKernel : - prime prove svuotatura King.	2023-08-25 13:33:24 +02:00
Riccardo Elitropi	701fcbdd34	EgtMachKernel : - piccole migliorie.	2023-08-23 12:45:09 +02:00
Riccardo Elitropi	44aef02ca1	EgtMachKernel : - prime prove per extra steps.	2023-08-22 13:57:43 +02:00
Riccardo Elitropi	01d3e7baa9	EgtMachKernel: - modifiche proiezioni con scalatura.	2023-08-21 13:32:56 +02:00
Riccardo Elitropi	98aac3154c	EgtMachKernel : - migliorie tagli di superifici per svuotature.	2023-08-17 17:13:31 +02:00
Riccardo Elitropi	a839a29dce	EgtMachKernel : - adattamento svuotatura a Trimesh.	2023-08-10 13:14:44 +02:00
Riccardo Elitropi	c58926bb5c	EgtMachKernel : - codice di prova. Adattamento superficie di svuotatura a Trimesh iniziale.	2023-08-04 13:40:35 +02:00
Riccardo Elitropi	ea36a0b8a1	EgtMachKernel : - Test codice.	2023-08-03 13:12:53 +02:00
Riccardo Elitropi	c7070e5f2f	EgtMachKernel : - pulizia del codice.	2023-08-02 13:10:25 +02:00
Riccardo Elitropi	a5007038b8	Merge commit '2b5aacc160c24afa2dc9ca348e57a204992c5880' into svuotature	2023-08-01 11:36:59 +02:00
Riccardo Elitropi	ff8e875290	EgtMachKernel : - migliorata la regione di incidenza per lati aperti - controllo pulizia dei lati aperti con angoli piccoli.	2023-08-01 11:35:38 +02:00
Riccardo Elitropi	d7a5f4aa72	EgtMachKernel : - migliorati casi ottimizzati trapezi e ZigZag con 0 lati aperti.	2023-07-28 17:02:29 +02:00
Riccardo Elitropi	7cd3925e4c	EgtMachKernel : - merge con master.	2023-07-26 13:13:27 +02:00
Riccardo Elitropi	25f141fbf0	Merge commit '1097f2a19f77801d64fe615ec214a3cba214c818' into svuotature	2023-07-26 11:58:33 +02:00
Riccardo Elitropi	ed677dfec6	EgtMachKernel : - migliorie varie.	2023-07-26 11:45:43 +02:00
Riccardo Elitropi	61d5029db9	EgtMachKernel : - migliorate le proeizioni.	2023-07-24 13:27:17 +02:00
Riccardo Elitropi	4cd354c85a	EgtMachKernel : - primo prototipo funzione di ricerca dei falsi lati aperti.	2023-07-19 13:44:41 +02:00
Riccardo Elitropi	0fd0b12445	EgtMachKernel : - modifiche lati aperti e Offset sulle curve omogenee.	2023-07-18 13:33:39 +02:00
Riccardo Elitropi	2a3a9fefe3	EgtMachKernel : - finti lati aperti.	2023-07-17 13:42:53 +02:00
Riccardo Elitropi	1fef9786ac	EgtMachKernel : - Intersezioni e proiezioni, gestione dei nuovi lati aperti.	2023-07-11 16:29:48 +02:00
Riccardo Elitropi	6d8848ec46	EgtMachKernel : - Migliorie proiezioni.	2023-07-10 13:19:42 +02:00
Riccardo Elitropi	2616d97d0a	EgtMachKernel : - migliorie proiezioni con grezzi con lati curvi.	2023-07-07 13:43:50 +02:00
Riccardo Elitropi	3fa4e64cc2	EgtMachKernel : - modifiche lati aperti e proiezioni.	2023-07-06 13:13:41 +02:00
Riccardo Elitropi	648ca06815	EgtMachKernel : - semplificazione proiezione grezzo.	2023-07-05 13:31:21 +02:00
Riccardo Elitropi	638d252b38	EgtMachKernel : - migliorie sui lati aperti.	2023-07-04 13:37:55 +02:00
Riccardo Elitropi	cd2a7cc921	EgtMachKernel : - Merge con Master.	2023-07-03 13:35:53 +02:00
Riccardo Elitropi	919ca81c43	Merge commit 'cdb35b4c38c4b3ca65f90c061aa46d4db1f9506f' into svuotature	2023-07-03 13:34:24 +02:00
Riccardo Elitropi	6935bec958	EgtMachKernel : - migliorie proiezioni grezzo con isole aperte e contorni chiusi.	2023-06-30 13:29:59 +02:00
Riccardo Elitropi	8e52fd584a	EgtMachKernel : - migliorie proiezioni.	2023-06-29 13:14:54 +02:00
Riccardo Elitropi	f69de493d6	EgtMachKernel : - prima versione aggiornata per proiezioni ( temporaneo).	2023-06-28 13:26:34 +02:00
Riccardo Elitropi	e04805a99a	EgtMachKernel : - migliorie codice proiezione con grezzo.	2023-06-27 13:43:26 +02:00
Riccardo Elitropi	ccac200e41	EgtMachKernel : - conservazione temp prop in Operation per curve. - migliorie intersezioni trimesh con piano.	2023-06-26 13:36:36 +02:00
Riccardo Elitropi	2c501206b2	EgtMachKernel : - minimizzati i percorsi di estensione sui lati aperti con archi - controlli su regioni svuotate in precedenza.	2023-06-23 13:39:52 +02:00
Riccardo Elitropi	297bc0c86d	EgtMachKernel : - Aggiunta funzioni di distanza dal grezzo in Operation.	2023-06-23 09:33:39 +02:00
Riccardo Elitropi	fac69a1d65	EgtMachKernel : - merge file mancanti.	2023-06-23 09:19:28 +02:00
Riccardo Elitropi	4711734998	EgtMachKernel : - merge con master.	2023-06-23 09:05:29 +02:00
Riccardo Elitropi	e04a05831e	Revert "Merge commit '994658da167a7ac3f607f4b535a65febe8f308d1' into svuotature" This reverts commit `e96f467b56`, reversing changes made to `ec1ee961be`.	2023-06-23 08:38:57 +02:00
Riccardo Elitropi	e96f467b56	Merge commit '994658da167a7ac3f607f4b535a65febe8f308d1' into svuotature	2023-06-23 08:20:50 +02:00
Riccardo Elitropi	ec1ee961be	EgtMachKernel : - migliorie archi lati aperti.	2023-06-22 13:14:35 +02:00
Riccardo Elitropi	ca74fa6794	EgtMachKernel : - migliorie.	2023-06-21 13:23:32 +02:00
Riccardo Elitropi	8242146446	EgtMachKernel : - migliorie unione sui lati aperti.	2023-06-20 13:29:13 +02:00
Riccardo Elitropi	4e2df90961	EgtMachKernel : - Isole aperte generate da lati aperti - migliorie alle approssimazioni degli archi.	2023-06-16 13:45:33 +02:00
Riccardo Elitropi	3393ea8325	EgtMachKernel : - prima prova di taglio con grezzo a disco.	2023-06-14 11:35:13 +02:00
Riccardo Elitropi	1060a10491	EgtMachKernel : - test codice per Isole aperte ed intersezioni grezzo con esse - migliorie alle curve.	2023-06-13 14:33:25 +02:00
Riccardo Elitropi	d46f94f8da	EgtMachKernel : - prima prova per isole con lati aperti e gestione angoli piccoli.	2023-06-09 13:47:04 +02:00
Riccardo Elitropi	3dcba13efc	EgtMachKernel : - merge con master.	2023-06-05 08:36:59 +02:00
Riccardo Elitropi	e4983d5276	Merge commit 'df86ffdee340b33c359d7e6b57598a70c1a1c006' into svuotature	2023-06-05 08:33:45 +02:00
Riccardo Elitropi	fee74d47f8	EgtMachKernel : - migliorie varie in pocketing.	2023-06-05 08:25:31 +02:00
Riccardo Elitropi	37f4e0982f	EgtMachKernel : - merge con master.	2023-05-11 11:50:21 +02:00
Riccardo Elitropi	fb5e01881d	Merge commit 'c6aa83ccd5c3d5819773872b6dbdbb6617517c4b' into svuotature	2023-05-11 11:40:21 +02:00
Riccardo Elitropi	a5096facc7	EgtMachKernel : - Feed ( test) - Svuotatura con pocketing precedente - correzioni varie.	2023-05-11 11:31:00 +02:00
Riccardo Elitropi	dbe11e6343	EgtMachKernel : - prima versione per Feed ( da migliorare) .	2023-04-12 13:28:45 +02:00
Riccardo Elitropi	ed4a9ec745	EgtMachKernel : - primo prototipo per funzione Feed.	2023-03-31 17:08:38 +02:00
Riccardo Elitropi	25b940927e	EgtMachKernel : - ottimizzazioni offset per centroidi e medial Axis - ottimizzazione percorsi di medial Axis ( raccordi con centroidi ).	2023-03-30 18:01:05 +02:00
Riccardo Elitropi	0911f167b1	EgtMachKernel : - Ottimizzazioni numero Offset per spirali.	2023-03-29 18:12:06 +02:00
Riccardo Elitropi	766e6a208d	EgtMachKernel : - correzione circonferenze per percorsi sui centroidi.	2023-03-28 17:34:17 +02:00
Riccardo Elitropi	9b0b1fe9d4	EgtMachKernel : - merge con master.	2023-03-28 17:24:54 +02:00
Riccardo Elitropi	4d676c1f3b	Merge commit '025eea9c0f0d77443110bc2fc19c3a2e6ee89c45' into svuotature	2023-03-28 15:56:27 +02:00
Riccardo Elitropi	3d5398f877	EgtMachKernel : - prima versione svuotature ( isole, intersezioni e proiezioni grezzo, entrate ).	2023-03-28 15:47:32 +02:00
Riccardo Elitropi	38d63633c2	EgtMachKernel : - Svuotature con intersezioni grezzo ( temp ).	2023-02-16 14:53:53 +01:00
Riccardo Elitropi	14b433d206	Merge commit '15931dc3046a4928e6d943e812a7e893befd9daa' into svuotature	2023-02-16 14:50:49 +01:00