From bd744a710c9be305f34ea90b25fb3fc400939ce2 Mon Sep 17 00:00:00 2001
From: Dario Sassi <dario.sassi@egalware.com>
Date: Tue, 31 Dec 2024 10:48:34 +0100
Subject: [PATCH 1/4] EgtMachKernel 2.6l4 : - quando si applica una lavorazione
 se non si trova l'utensile con UUID ora lo si cerca con il nome.

---
 Chiseling.cpp       |  10 +++++++---
 Drilling.cpp        |  11 +++++++----
 EgtMachKernel.rc    | Bin 11782 -> 11782 bytes
 FiveAxisMilling.cpp |  10 +++++++---
 GenMachining.cpp    |  10 +++++++---
 Milling.cpp         |  10 +++++++---
 Mortising.cpp       |  10 +++++++---
 Pocketing.cpp       |  10 +++++++---
 PocketingNT.cpp     |  10 +++++++---
 SawFinishing.cpp    |  10 +++++++---
 SawRoughing.cpp     |  10 +++++++---
 SurfFinishing.cpp   |  10 +++++++---
 SurfRoughing.cpp    |  10 +++++++---
 WaterJetting.cpp    |  10 +++++++---
 14 files changed, 91 insertions(+), 40 deletions(-)

diff --git a/Chiseling.cpp b/Chiseling.cpp
index aeeef47..033403d 100644
--- a/Chiseling.cpp
+++ b/Chiseling.cpp
@@ -769,10 +769,14 @@ Chiseling::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/Drilling.cpp b/Drilling.cpp
index 7e37dad..5ed34b3 100644
--- a/Drilling.cpp
+++ b/Drilling.cpp
@@ -1258,7 +1258,6 @@ Drilling::MultiHeadDrilling( const SELVECTOR& vId, int nClId, TABMHDRILL& tabDri
      // se presente e valido
       const ToolData* pTdata = pTMgr->GetTool( sToolName) ;
       vTools.emplace_back( pTdata) ;
-
      // imposto il tool di riferimento come il tool m_TParams
       if ( pTdata->m_Uuid == m_TParams.m_Uuid)
          nMainToolInd = nT ;
@@ -2307,10 +2306,14 @@ Drilling::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/EgtMachKernel.rc b/EgtMachKernel.rc
index f570e9ca2a79b60fdc98bc0d5a704c8dd80663fd..7f5e212c4acf49db923c2e17cadf371d42bbf401 100644
GIT binary patch
delta 97
zcmZpRX^YwLhmFx>^ItYwW=50Aj>5W|vxM9jH?QON0rG*u7nvrX5iEd9O=7{OSQ@Kh
Hr8(RHQ1Kv2

delta 97
zcmZpRX^YwLhmFyA^ItYwW=7-5j>5W|vxM9jH?QON0rG*u7nvrX5iEd9O=7{OSQ@Kh
Hr8(RHPhB8F

diff --git a/FiveAxisMilling.cpp b/FiveAxisMilling.cpp
index 38fd900..b4e71b4 100644
--- a/FiveAxisMilling.cpp
+++ b/FiveAxisMilling.cpp
@@ -867,10 +867,14 @@ FiveAxisMilling::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/GenMachining.cpp b/GenMachining.cpp
index e41999b..394b07a 100644
--- a/GenMachining.cpp
+++ b/GenMachining.cpp
@@ -856,10 +856,14 @@ GenMachining::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/Milling.cpp b/Milling.cpp
index 212faff..e79d1d3 100644
--- a/Milling.cpp
+++ b/Milling.cpp
@@ -1111,10 +1111,14 @@ Milling::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/Mortising.cpp b/Mortising.cpp
index 2a481b2..4ad938a 100644
--- a/Mortising.cpp
+++ b/Mortising.cpp
@@ -817,10 +817,14 @@ Mortising::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/Pocketing.cpp b/Pocketing.cpp
index 4d0985a..0728b88 100644
--- a/Pocketing.cpp
+++ b/Pocketing.cpp
@@ -947,10 +947,14 @@ Pocketing::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/PocketingNT.cpp b/PocketingNT.cpp
index c63c929..e6a2669 100644
--- a/PocketingNT.cpp
+++ b/PocketingNT.cpp
@@ -955,10 +955,14 @@ PocketingNT::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/SawFinishing.cpp b/SawFinishing.cpp
index 592c4c0..fc4fef6 100644
--- a/SawFinishing.cpp
+++ b/SawFinishing.cpp
@@ -796,10 +796,14 @@ SawFinishing::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/SawRoughing.cpp b/SawRoughing.cpp
index 007304f..1f5a784 100644
--- a/SawRoughing.cpp
+++ b/SawRoughing.cpp
@@ -754,10 +754,14 @@ SawRoughing::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/SurfFinishing.cpp b/SurfFinishing.cpp
index 4ecd6e0..1a404a3 100644
--- a/SurfFinishing.cpp
+++ b/SurfFinishing.cpp
@@ -822,10 +822,14 @@ SurfFinishing::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/SurfRoughing.cpp b/SurfRoughing.cpp
index ad0ef2e..50f11ee 100644
--- a/SurfRoughing.cpp
+++ b/SurfRoughing.cpp
@@ -860,10 +860,14 @@ SurfRoughing::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;
diff --git a/WaterJetting.cpp b/WaterJetting.cpp
index 85bfcdc..370051f 100644
--- a/WaterJetting.cpp
+++ b/WaterJetting.cpp
@@ -965,10 +965,14 @@ WaterJetting::UpdateToolData( bool* pbChanged)
    ToolsMgr* pTMgr = m_pMchMgr->GetCurrToolsMgr() ;
    if ( pTMgr == nullptr)
       return false ;
-  // recupero l'utensile nel DB utensili
+  // recupero l'utensile nel DB utensili (se fallisce con UUID provo con il nome)
    const ToolData* pTdata = pTMgr->GetTool( m_Params.m_ToolUuid) ;
-   if ( pTdata == nullptr)
-      return false ;
+   if ( pTdata == nullptr) {
+      pTdata = pTMgr->GetTool( m_Params.m_sToolName) ;
+      if ( pTdata == nullptr)
+         return false ;
+      m_Params.m_ToolUuid = m_TParams.m_Uuid ;
+   }
   // salvo posizione TC, testa e uscita originali
    string sOrigTcPos = m_TParams.m_sTcPos ;
    string sOrigHead = m_TParams.m_sHead ;

From a60e8e2da796c2011fbcfeecb6dadc0391526d76 Mon Sep 17 00:00:00 2001
From: Dario Sassi <dario.sassi@egalware.com>
Date: Tue, 31 Dec 2024 15:50:57 +0100
Subject: [PATCH 2/4] EgtMachKerenel : - modifiche a NewLinkMgr, ora con codice
 1 controlla le aree protette solo sui link mentre con codice 2 le controlla
 anche nelle lavorazione (con codice 0 come prima le controlla sempre).

---
 MachineCalc.cpp   | 3 +++
 Operation.cpp     | 2 +-
 SurfFinishing.cpp | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/MachineCalc.cpp b/MachineCalc.cpp
index 8a79d89..305e9ea 100644
--- a/MachineCalc.cpp
+++ b/MachineCalc.cpp
@@ -1747,6 +1747,9 @@ Machine::VerifyProtectedAreas( double dX, double dY, double dZ, const DBLVECTOR&
   // se non esiste funzione gestione aree protette, non devo fare alcunchè
    if ( ! LuaExistsFunction( ON_VERIFY_PROTECTEDAREAS))
       return true ;
+  // se non è collegamento e aree protette solo per questi, non devo fare alcunchè
+   if ( nLinkType == 0  &&  m_nNewLinkMgr == 1)
+      return true ;
   // default
    bool bOk = true ;
    int nErr = 99 ;
diff --git a/Operation.cpp b/Operation.cpp
index 6e7f7b5..33b2b5e 100644
--- a/Operation.cpp
+++ b/Operation.cpp
@@ -2960,7 +2960,7 @@ Operation::ManageProtectedAreas( const DBLVECTOR& vAxStart, const DBLVECTOR& vAx
    bool bNewLink = m_pMchMgr->GetCurrMachine()->GetNewLinkMgr() ;
 
   // codifica tipo di collegamento
-   int nLinkType = 0 + ( pPrevOp == nullptr ? 0 : 2) + ( pNextOp == nullptr ? 0 : 1) ;
+   int nLinkType = ( pPrevOp == nullptr ? 0 : 2) + ( pNextOp == nullptr ? 0 : 1) ;
 
   // Verifico se il collegamento le attraversa
    Point3d ptSta( vAxStart[0], vAxStart[1], vAxStart[2]) ;
diff --git a/SurfFinishing.cpp b/SurfFinishing.cpp
index 77ef9c9..d79a4fb 100644
--- a/SurfFinishing.cpp
+++ b/SurfFinishing.cpp
@@ -3394,7 +3394,7 @@ SurfFinishing::ChooseFinishingForOptimal( const ISurfFlatRegion* pSfr, int nChun
          if ( AreSameOrOppositeVectorApprox( vtTanMaxLine, vtX)) {
             bSpiral = false ; // ZigZag
             X_AX.GetAngle( vtX, dSideAng) ;
-            abs( dSideAng) ;
+            dSideAng = abs( dSideAng) ;
          }
       }
    }

From cb20faa0cc75489823e5f5300710b55b5839f052 Mon Sep 17 00:00:00 2001
From: Dario Sassi <dario.sassi@egalware.com>
Date: Thu, 2 Jan 2025 17:04:41 +0100
Subject: [PATCH 3/4] EgtMachKernel : - piccole migliorie a finitura superfici.

---
 SurfFinishing.cpp | 905 +++++++++++++++++++++++-----------------------
 1 file changed, 450 insertions(+), 455 deletions(-)

diff --git a/SurfFinishing.cpp b/SurfFinishing.cpp
index d79a4fb..6971f0e 100644
--- a/SurfFinishing.cpp
+++ b/SurfFinishing.cpp
@@ -4,7 +4,7 @@
 // File : SurfFinishing.cpp       Data : 28.05.19          Versione : 2.1e5
 // Contenuto : Implementazione gestione finitura superfici.
 //
-// Note : Questa lavorazione � sempre espressa nel riferimento globale.
+//
 //
 // Modifiche : 28.05.19 DS Creazione modulo.
 //
@@ -18,7 +18,6 @@
 #include "SurfFinishing.h"
 #include "OperationConst.h"
 #include "GeoConst.h"
-#include "set"
 #include "/EgtDev/Include/EXeCmdLogOff.h"
 #include "/EgtDev/Include/EXeConst.h"
 #include "/EgtDev/Include/EGkCurveLine.h"
@@ -466,14 +465,14 @@ SurfFinishing::SetParam( int nType, const string& sVal)
 bool
 SurfFinishing::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
    for ( const auto& Id : vIds) {
-     // test sull'entit�
+     // test sull'entità
       int nSubs ;
       if ( ! VerifyGeometry( Id, nSubs)) {
          string sInfo = "Warning in SurfFinishing : Skipped entity " + ToString( Id) ;
@@ -505,7 +504,7 @@ SurfFinishing::Apply( bool bRecalc, bool bPostApply)
    int nCurrPaths = m_nPaths ;
    m_nPaths = 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 ;
 
@@ -516,7 +515,7 @@ SurfFinishing::Apply( bool bRecalc, bool bPostApply)
       return false ;
    }
 
-  // non � prevista finitura superficie con aggregato da sotto
+  // non è prevista finitura superficie con aggregato da sotto
    if ( IsAggrBottom( m_TParams.m_sHead)) {
       m_pMchMgr->SetLastError( 3122, "Error in SurfFinishing : aggregate from bottom not allowed") ;
       return false ;
@@ -542,7 +541,7 @@ SurfFinishing::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)
@@ -579,7 +578,7 @@ SurfFinishing::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)
@@ -622,7 +621,7 @@ SurfFinishing::Apply( bool bRecalc, bool bPostApply)
 bool
 SurfFinishing::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 ;
 
@@ -632,7 +631,7 @@ SurfFinishing::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
@@ -877,7 +876,7 @@ SurfFinishing::UpdateToolData( bool* pbChanged)
 bool
 SurfFinishing::GetGeometry( SELVECTOR& vIds) const
 {
-  // restituisco l'elenco delle entit�
+  // restituisco l'elenco delle entità
    vIds = m_vId ;
    return true ;
 }
@@ -922,7 +921,7 @@ SurfFinishing::VerifyGeometry( SelData Id, int& nSubs)
       }
       return ( pCurve != nullptr) ;
    }
-  // se altrimenti � superficie trimesh
+  // se altrimenti è superficie trimesh
    else if ( pGObj->GetType() == SRF_TRIMESH) {
       const ISurfTriMesh* pSurf = ::GetSurfTriMesh( pGObj) ;
       return ( pSurf != nullptr  &&  pSurf->GetFacetCount() >= 1) ;
@@ -1179,7 +1178,7 @@ SurfFinishing::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)
@@ -1202,8 +1201,8 @@ SurfFinishing::ProcessPath( int nPathId, int nPvId, int nClId)
    int nCopyId = m_pGeomDB->CopyGlob( nSfrId, GDB_ID_NULL, nTempId) ;
    if ( nCopyId == GDB_ID_NULL)
       return false ;
-   PtrOwner<ISurfFlatRegion> pSfrGDB( CloneSurfFlatRegion( m_pGeomDB->GetGeoObj( nCopyId))) ;
-   if ( IsNull( pSfrGDB)  ||  ! pSfrGDB->IsValid())
+   const ISurfFlatRegion* pSfrGDB( GetSurfFlatRegion( m_pGeomDB->GetGeoObj( nCopyId))) ;
+   if ( ! pSfrGDB->IsValid())
       return false ;
 
   // recupero estrusione e spessore
@@ -1234,13 +1233,13 @@ SurfFinishing::ProcessPath( int nPathId, int nPvId, int nClId)
    }
 
   // recupero il Loop esterno della regione da svuotatare
-   PtrOwner<ICurveComposite> pCompo( ConvertCurveToComposite( pSfrGDB->GetLoop( 0, 0))) ;
-   if ( IsNull( pCompo)  ||  ! pCompo->IsValid())
+   PtrOwner<ICurve> pCrvExt( pSfrGDB->GetLoop( 0, 0)) ;
+   if ( IsNull( pCrvExt)  ||  ! pCrvExt->IsValid())
       return false ;
 
   // verifico sia piana e sistemo senso antiorario visto dalla direzione di estrusione
    Plane3d plPlane ; double dArea ;
-   if ( ! pCompo->GetArea( plPlane, dArea)) {
+   if ( ! pCrvExt->GetArea( plPlane, dArea)) {
       m_pMchMgr->SetLastError( 3005, "Error in SurfFinishing : Contour Not Flat") ;
       return false ;
    }
@@ -1249,7 +1248,7 @@ SurfFinishing::ProcessPath( int nPathId, int nPvId, int nClId)
       return false ;
    }
    if ( plPlane.GetVersN() * vtExtr * dArea < 0)
-      pCompo->Invert() ;
+      pCrvExt->Invert() ;
    if ( plPlane.GetVersN() * vtExtr < 0)
       plPlane.Invert() ;
 
@@ -1329,7 +1328,7 @@ SurfFinishing::ProcessPath( int nPathId, int nPvId, int nClId)
 
      // determino la regione da lavorare
       PtrOwner<ISurfFlatRegion> pSfrCnt( CreateSurfFlatRegion()) ;
-      if ( IsNull( pSfrCnt)  ||  ! pSfrCnt->AddExtLoop( *pCompo)) {
+      if ( IsNull( pSfrCnt)  ||  ! pSfrCnt->AddExtLoop( *pCrvExt)) {
          m_pMchMgr->SetLastError( 3124, "Error in SurfFinishing : region not computable") ;
          return false ;
       }
@@ -1337,7 +1336,7 @@ SurfFinishing::ProcessPath( int nPathId, int nPvId, int nClId)
         // recupero l'isola
          PtrOwner<ICurve> pCrvIsl( pSfrGDB->GetLoop( 0, nL)) ;
          if ( IsNull( pCrvIsl)  ||  ! pCrvIsl->IsValid()  ||
-              ! pSfrCnt->AddIntLoop( *pCrvIsl))
+              ! pSfrCnt->AddIntLoop( Release( pCrvIsl)))
             return false ;
       }
 
@@ -1350,7 +1349,7 @@ SurfFinishing::ProcessPath( int nPathId, int nPvId, int nClId)
          for ( int i = 0 ; i < int( vSrfLoc.size()) ; ++ i)
             vpStm.emplace_back( GetSurfTriMesh( vSrfLoc[i].Get())) ;
          Frame3d frPocket ;
-         Point3d ptCen ; pCompo->GetCentroid( ptCen) ;
+         Point3d ptCen ; pCrvExt->GetCentroid( ptCen) ;
          frPocket.Set( ptCen, vtTool) ;
          frPocket.ToLoc( frSurf) ;
          const double SILH_TOL = 1.0 ;
@@ -1397,7 +1396,7 @@ SurfFinishing::ProcessPath( int nPathId, int nPvId, int nClId)
             if ( ! pSfrCnt->Intersect( *pSfrSil)) {
               // ricreo la regione originale
                pSfrCnt->Clear() ;
-               pSfrCnt->AddExtLoop( *pCompo) ;
+               pSfrCnt->AddExtLoop( *pCrvExt) ;
             }
            // azzero le proprietà delle curve semplici dei contorni delle regioni ( se 1 lato aperto)
             for ( int nC = 0 ; nC < pSfrCnt->GetChunkCount() ; ++ nC) {
@@ -1529,15 +1528,15 @@ SurfFinishing::GetActiveSurfaces( INTVECTOR& vSurfId) const
            // ciclo sui layer dei pezzi
             int nLayId = m_pGeomDB->GetFirstGroupInGroup( nPartId) ;
             while ( nLayId != GDB_ID_NULL) {
-              // ciclo sulle entit� del layer
+              // ciclo sulle entità del layer
                int nEntId = m_pGeomDB->GetFirstInGroup( nLayId) ;
                while ( nEntId != GDB_ID_NULL) {
-                 // se entit� superficie e visibile, la aggiungo
+                 // se entità superficie e visibile, la aggiungo
                   int nStat ;
                   if ( m_pGeomDB->GetGeoType( nEntId) == SRF_TRIMESH  &&
                         m_pGeomDB->GetCalcStatus( nEntId, nStat)  &&  nStat != GDB_ST_OFF)
                      vSurfId.emplace_back( nEntId) ;
-                 // passo alla entit� successiva
+                 // passo alla entità successiva
                   nEntId = m_pGeomDB->GetNext( nEntId) ;
                }
                nLayId =m_pGeomDB->GetNextGroup( nLayId) ;
@@ -1627,411 +1626,9 @@ SurfFinishing::AddZigZag( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, cons
          if ( IsNull( pCurve))
             return false ;
          pCurve->ToGlob( frPocket) ;
-        // se prima entit�
+        // se prima entità
          if ( i == 0 ) {
-           // dati inizio entit�
-            Point3d ptStart ;
-            pCurve->GetStartPoint( ptStart) ;
-            Vector3d vtStart ;
-            pCurve->GetStartDir( vtStart) ;
-           // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto)
-            double dStartOnExtr = vtStart * vtTool ;
-            if ( dStartOnExtr > 0) {
-               vtStart -= dStartOnExtr * vtTool ;
-               vtStart.Normalize() ;
-            }
-           // determino normale della superficie sul punto iniziale
-            Vector3d vtNorm ;
-            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) {
-               Point3d ptEnd ;
-               pCurve->GetEndPoint( ptEnd) ;
-               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm))
-                  vtNorm = V_NULL ;
-            }
-           // determino inizio attacco
-            Point3d ptP1 ;
-            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1))
-               return false ;
-           // eventuale correzione inizio attacco per evitare interferenze
-            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1))
-               return false ;
-           // determino elevazione su inizio attacco
-            double dStElev ;
-            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
-               dStElev = dElev ;
-            dStElev -= ( ptP1 - ptStart) * vtTool ;
-           // se inizio, approccio globale al punto iniziale
-            if ( bStart) {
-               if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
-                  m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ;
-                  return false ;
-               }
-               bStart = false ;
-            }
-           // altrimenti, approccio di collegamento
-            else {
-               if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
-                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
-                  return false ;
-               }
-            }
-           // aggiungo attacco
-            SetFeed( GetStartFeed()) ;
-            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
-               m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ;
-               return false ;
-            }
-         }
-        // elaborazioni sulla curva corrente (sempre un segmento di retta)
-         ICurveLine* pLine = GetCurveLine( pCurve) ;
-         if ( pLine == nullptr)
-            return false ;
-         Point3d ptP3 = pLine->GetEnd() ;
-         Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
-         SetFeed( GetRightFeed( vtMove, vtTool)) ;
-         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
-            return false ;
-        // se ultima entit�
-         if ( i == nMaxInd) {
-           // dati fine entit�
-            Point3d ptEnd ;
-            pCurve->GetEndPoint( ptEnd) ;
-            Vector3d vtEnd ;
-            pCurve->GetEndDir( vtEnd) ;
-           // vettore tangente finale non deve scendere rispetto a estrusione
-            double dEndOnExtr = vtEnd * vtTool ;
-            if ( dEndOnExtr < 0) {
-               vtEnd -= dEndOnExtr * vtTool ;
-               vtEnd.Normalize() ;
-            }
-           // determino normale della superficie sul punto finale
-            Vector3d vtNorm ;
-            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
-               Point3d ptStart ;
-               pCurve->GetStartPoint( ptStart) ;
-               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm))
-                  vtNorm = V_NULL ;
-            }
-           // determino fine uscita
-            Point3d ptP1 ;
-            if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1))
-               return false ;
-           // eventuale correzione fine uscita per evitare interferenze
-            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1))
-               return false ;
-           // aggiungo uscita
-            SetFeed( GetEndFeed()) ;
-            if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) {
-               m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ;
-               return false ;
-            }
-           // determino elevazione su fine uscita
-            double dEndElev ;
-            if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
-               dEndElev = dElev ;
-            dEndElev -= ( ptP1 - ptEnd) * vtTool ;
-           // se non � ultimo tratto, aggiungo retrazione di collegamento
-            if ( k < int( vpCrvs.size()) - 1) {
-               if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
-                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
-                  return false ;
-               }
-            }
-           // altrimenti aggiungo retrazione finale
-            else {
-               if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
-                  m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
-                  return false ;
-               }
-            }
-         }
-      }
-   }
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfFinishing::AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
-                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
-{
-  // recupero distanze di sicurezza
-   double dSafeZ = GetSafeZ() ;
-  // lunghezza di approccio/retrazione
-   double dAppr = m_Params.m_dStartPos ;
-
-  // calcolo lo one-way
-   double dPockRad = m_Params.m_dSideStep ;
-   double dPockRadOffs = m_TParams.m_dDiam / 2 - m_Params.m_dSideStep - m_Params.m_dOverlap ;
-   ICRVCOMPOPOVECTOR vpCrvs ;
-   if ( ! CalcPocketing( pSfrPock, dPockRad, dPockRadOffs, m_Params.m_dSideStep, m_Params.m_dSideAngle,
-                         POCKET_ONEWAY, false, false, true, false, P_INVALID, nullptr, vpCrvs)) {
-      m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
-      return false ;
-   }
-
-  // determino il riferimento di base della svuotatura
-   Frame3d frPocket ;
-   Point3d ptCen ; pSfrPock->GetCentroid( ptCen) ;
-   frPocket.Set( ptCen, vtTool) ;
-
-  // ciclo sulle curve risultanti
-   bool bStart = true ;
-   double dProgCoeff = 1. / max( int( vpCrvs.size()), 1) ;
-   for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) {
-      PtrOwner<ICurveComposite> pMCrv( Release( vpCrvs[k])) ;
-      pMCrv->ToLoc( frPocket) ;
-     // li correggo per non interferire con le superfici
-      if ( pCAvTlStm != nullptr) {
-        // approssimo la curva con una polilinea
-         PolyLine PL ;
-         if ( ! pMCrv->ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
-            return false ;
-        // eventuale aggiunta di punti per garantire max distanza
-         const double MIN_DIST = 1. ;
-         const double MAX_DIST = 50. ;
-         double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ;
-         if ( ! PL.AdjustForMaxSegmentLen( dDist))
-            return false ;
-        // porto nel riferimento delle superfici
-         PL.LocToLoc( frPocket, frSurf) ;
-        // porto i dati geometrici in locale alle superfici
-         Vector3d vtAxL = vtTool ;
-         vtAxL.ToLoc( frSurf) ;
-         Vector3d vtMoveL = vtAxL ;
-        // traslo della lunghezza utensile diminuita dell'affondamento
-         PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
-        // eseguo CAv
-         if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox, ( k + 1) * dProgCoeff))
-            return false ;
-        // contro-traslo della lunghezza utensile
-         PL.Translate( - vtAxL * m_TParams.m_dLen) ;
-        // riporto la polilinea nel riferimento della curva
-         PL.LocToLoc( frSurf, frPocket) ;
-        // elimino i punti allineati
-         PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
-        // creo una curva composita a partire dalla polilinea
-         PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ;
-         if ( IsNull( pCompo)  ||  ! pCompo->FromPolyLine( PL))
-            return false ;
-        // sostituisco la vecchia curva con la nuova
-         pMCrv.Set( pCompo) ;
-      }
-     // ciclo sulle curve elementari
-      int nMaxInd = pMCrv->GetCurveCount() - 1 ;
-      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
-        // curva corrente
-         const ICurve* pCrvC = pMCrv->GetCurve( i) ;
-        // copio la curva
-         PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
-         if ( IsNull( pCurve))
-            return false ;
-         pCurve->ToGlob( frPocket) ;
-        // se prima entit�
-         if ( i == 0 ) {
-           // dati inizio entit�
-            Point3d ptStart ;
-            pCurve->GetStartPoint( ptStart) ;
-            Vector3d vtStart ;
-            pCurve->GetStartDir( vtStart) ;
-           // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto)
-            double dStartOnExtr = vtStart * vtTool ;
-            if ( dStartOnExtr > 0) {
-               vtStart -= dStartOnExtr * vtTool ;
-               vtStart.Normalize() ;
-            }
-           // determino normale della superficie sul punto iniziale
-            Vector3d vtNorm ;
-            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) {
-               Point3d ptEnd ;
-               pCurve->GetEndPoint( ptEnd) ;
-               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm))
-                  vtNorm = V_NULL ;
-            }
-           // determino inizio attacco
-            Point3d ptP1 ;
-            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1))
-               return false ;
-           // eventuale correzione inizio attacco per evitare interferenze
-            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1))
-               return false ;
-           // determino elevazione su inizio attacco
-            double dStElev ;
-            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
-               dStElev = dElev ;
-            dStElev -= ( ptP1 - ptStart) * vtTool ;
-           // se inizio, approccio globale al punto iniziale
-            if ( bStart) {
-               if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
-                  m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ;
-                  return false ;
-               }
-               bStart = false ;
-            }
-           // altrimenti, approccio di collegamento
-            else {
-               if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
-                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
-                  return false ;
-               }
-            }
-           // aggiungo attacco
-            SetFeed( GetStartFeed()) ;
-            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
-               m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ;
-               return false ;
-            }
-         }
-        // elaborazioni sulla curva corrente (sempre un segmento di retta)
-         ICurveLine* pLine = GetCurveLine( pCurve) ;
-         if ( pLine == nullptr)
-            return false ;
-         Point3d ptP3 = pLine->GetEnd() ;
-         Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
-         SetFeed( GetRightFeed( vtMove, vtTool)) ;
-         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
-            return false ;
-        // se ultima entit�
-         if ( i == nMaxInd) {
-           // dati fine entit�
-            Point3d ptEnd ;
-            pCurve->GetEndPoint( ptEnd) ;
-            Vector3d vtEnd ;
-            pCurve->GetEndDir( vtEnd) ;
-           // vettore tangente finale non deve scendere rispetto a estrusione
-            double dEndOnExtr = vtEnd * vtTool ;
-            if ( dEndOnExtr < 0) {
-               vtEnd -= dEndOnExtr * vtTool ;
-               vtEnd.Normalize() ;
-            }
-           // determino normale della superficie sul punto finale
-            Vector3d vtNorm ;
-            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
-               Point3d ptStart ;
-               pCurve->GetStartPoint( ptStart) ;
-               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm))
-                  vtNorm = V_NULL ;
-            }
-           // determino fine uscita
-            Point3d ptP1 ;
-            if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1))
-               return false ;
-           // eventuale correzione fine uscita per evitare interferenze
-            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1))
-               return false ;
-           // aggiungo uscita
-            SetFeed( GetEndFeed()) ;
-            if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) {
-               m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ;
-               return false ;
-            }
-           // determino elevazione su fine uscita
-            double dEndElev ;
-            if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
-               dEndElev = dElev ;
-            dEndElev -= ( ptP1 - ptEnd) * vtTool ;
-           // se non � ultimo tratto, aggiungo retrazione di collegamento
-            if ( k < int( vpCrvs.size()) - 1) {
-               if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
-                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
-                  return false ;
-               }
-            }
-           // altrimenti aggiungo retrazione finale
-            else {
-               if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
-                  m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
-                  return false ;
-               }
-            }
-         }
-      }
-   }
-
-   return true ;
-}
-
-//----------------------------------------------------------------------------
-bool
-SurfFinishing::AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
-                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut)
-{  
-  // recupero distanze di sicurezza
-   double dSafeZ = GetSafeZ() ;
-  // lunghezza di approccio/retrazione
-   double dAppr = m_Params.m_dStartPos ;
-
-  // calcolo la spirale
-   double dPockRad = m_Params.m_dSideStep ;
-   double dPockRadOffs = m_TParams.m_dDiam / 2 - m_Params.m_dSideStep - m_Params.m_dOverlap ;
-   int nType = ( bInVsOut ? POCKET_SPIRALIN : POCKET_SPIRALOUT) ;
-   ICRVCOMPOPOVECTOR vpCrvs ;
-   if ( ! CalcPocketing( pSfrPock, dPockRad, dPockRadOffs, m_Params.m_dSideStep, m_Params.m_dSideAngle,
-                         nType, false, false, true, false, P_INVALID, nullptr, vpCrvs)) {
-      m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
-      return false ;
-   }
-
-  // determino il riferimento di base della svuotatura
-   Frame3d frPocket ;
-   Point3d ptCen ; pSfrPock->GetCentroid( ptCen) ;
-   frPocket.Set( ptCen, vtTool) ;
-
-  // ciclo sulle curve risultanti
-   bool bStart = true ;
-   for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) {
-      PtrOwner<ICurveComposite> pMCrv( Release( vpCrvs[k])) ;
-      pMCrv->ToLoc( frPocket) ;
-     // li correggo per non interferire con le superfici
-      if ( pCAvTlStm != nullptr) {
-        // approssimo la curva con una polilinea
-         PolyLine PL ;
-         if ( ! pMCrv->ApproxWithLines( m_Params.m_dApprox, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
-            return false ;
-        // eventuale aggiunta di punti per garantire max distanza
-         const double MIN_DIST = 1. ;
-         const double MAX_DIST = 50. ;
-         double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ;
-         if ( ! PL.AdjustForMaxSegmentLen( dDist))
-            return false ;
-        // porto nel riferimento delle superfici
-         PL.LocToLoc( frPocket, frSurf) ;
-        // porto i dati geometrici in locale alle superfici
-         Vector3d vtAxL = vtTool ;
-         vtAxL.ToLoc( frSurf) ;
-         Vector3d vtMoveL = vtAxL ;
-        // traslo della lunghezza utensile diminuita dell'affondamento
-         PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
-        // eseguo CAv
-         if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox))
-            return false ;
-        // contro-traslo della lunghezza utensile
-         PL.Translate( - vtAxL * m_TParams.m_dLen) ;
-        // riporto la polilinea nel riferimento della curva
-         PL.LocToLoc( frSurf, frPocket) ;
-        // elimino i punti allineati
-         PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
-        // creo una curva composita a partire dalla polilinea
-         PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ;
-         if ( IsNull( pCompo)  ||  ! pCompo->FromPolyLine( PL))
-            return false ;
-        // sostituisco la vecchia curva con la nuova
-         pMCrv.Set( pCompo) ;
-      }
-     // ciclo sulle curve elementari
-      int nMaxInd = pMCrv->GetCurveCount() - 1 ;
-      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
-        // curva corrente
-         const ICurve* pCrvC = pMCrv->GetCurve( i) ;
-        // copio la curva
-         PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
-         if ( IsNull( pCurve))
-            return false ;
-         pCurve->ToGlob( frPocket) ;
-        // se prima entit�
-         if ( i == 0 ) {
-           // dati inizio entit�
+           // dati inizio entità
             Point3d ptStart ;
             pCurve->GetStartPoint( ptStart) ;
             Vector3d vtStart ;
@@ -2132,7 +1729,409 @@ SurfFinishing::AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, cons
             if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
                dEndElev = dElev ;
             dEndElev -= ( ptP1 - ptEnd) * vtTool ;
-           // se non � ultimo tratto, aggiungo retrazione di collegamento
+           // se non è ultimo tratto, aggiungo retrazione di collegamento
+            if ( k < int( vpCrvs.size()) - 1) {
+               if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
+                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
+                  return false ;
+               }
+            }
+           // altrimenti aggiungo retrazione finale
+            else {
+               if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
+                  m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
+                  return false ;
+               }
+            }
+         }
+      }
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SurfFinishing::AddOneWay( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
+                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
+{
+  // recupero distanze di sicurezza
+   double dSafeZ = GetSafeZ() ;
+  // lunghezza di approccio/retrazione
+   double dAppr = m_Params.m_dStartPos ;
+
+  // calcolo lo one-way
+   double dPockRad = m_Params.m_dSideStep ;
+   double dPockRadOffs = m_TParams.m_dDiam / 2 - m_Params.m_dSideStep - m_Params.m_dOverlap ;
+   ICRVCOMPOPOVECTOR vpCrvs ;
+   if ( ! CalcPocketing( pSfrPock, dPockRad, dPockRadOffs, m_Params.m_dSideStep, m_Params.m_dSideAngle,
+                         POCKET_ONEWAY, false, false, true, false, P_INVALID, nullptr, vpCrvs)) {
+      m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
+      return false ;
+   }
+
+  // determino il riferimento di base della svuotatura
+   Frame3d frPocket ;
+   Point3d ptCen ; pSfrPock->GetCentroid( ptCen) ;
+   frPocket.Set( ptCen, vtTool) ;
+
+  // ciclo sulle curve risultanti
+   bool bStart = true ;
+   double dProgCoeff = 1. / max( int( vpCrvs.size()), 1) ;
+   for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) {
+      PtrOwner<ICurveComposite> pMCrv( Release( vpCrvs[k])) ;
+      pMCrv->ToLoc( frPocket) ;
+     // li correggo per non interferire con le superfici
+      if ( pCAvTlStm != nullptr) {
+        // approssimo la curva con una polilinea
+         PolyLine PL ;
+         if ( ! pMCrv->ApproxWithLines( LIN_TOL_STD, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
+            return false ;
+        // eventuale aggiunta di punti per garantire max distanza
+         const double MIN_DIST = 1. ;
+         const double MAX_DIST = 50. ;
+         double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ;
+         if ( ! PL.AdjustForMaxSegmentLen( dDist))
+            return false ;
+        // porto nel riferimento delle superfici
+         PL.LocToLoc( frPocket, frSurf) ;
+        // porto i dati geometrici in locale alle superfici
+         Vector3d vtAxL = vtTool ;
+         vtAxL.ToLoc( frSurf) ;
+         Vector3d vtMoveL = vtAxL ;
+        // traslo della lunghezza utensile diminuita dell'affondamento
+         PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
+        // eseguo CAv
+         if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox, ( k + 1) * dProgCoeff))
+            return false ;
+        // contro-traslo della lunghezza utensile
+         PL.Translate( - vtAxL * m_TParams.m_dLen) ;
+        // riporto la polilinea nel riferimento della curva
+         PL.LocToLoc( frSurf, frPocket) ;
+        // elimino i punti allineati
+         PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
+        // creo una curva composita a partire dalla polilinea
+         PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ;
+         if ( IsNull( pCompo)  ||  ! pCompo->FromPolyLine( PL))
+            return false ;
+        // sostituisco la vecchia curva con la nuova
+         pMCrv.Set( pCompo) ;
+      }
+     // ciclo sulle curve elementari
+      int nMaxInd = pMCrv->GetCurveCount() - 1 ;
+      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
+        // curva corrente
+         const ICurve* pCrvC = pMCrv->GetCurve( i) ;
+        // copio la curva
+         PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
+         if ( IsNull( pCurve))
+            return false ;
+         pCurve->ToGlob( frPocket) ;
+        // se prima entità
+         if ( i == 0 ) {
+           // dati inizio entità
+            Point3d ptStart ;
+            pCurve->GetStartPoint( ptStart) ;
+            Vector3d vtStart ;
+            pCurve->GetStartDir( vtStart) ;
+           // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto)
+            double dStartOnExtr = vtStart * vtTool ;
+            if ( dStartOnExtr > 0) {
+               vtStart -= dStartOnExtr * vtTool ;
+               vtStart.Normalize() ;
+            }
+           // determino normale della superficie sul punto iniziale
+            Vector3d vtNorm ;
+            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) {
+               Point3d ptEnd ;
+               pCurve->GetEndPoint( ptEnd) ;
+               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm))
+                  vtNorm = V_NULL ;
+            }
+           // determino inizio attacco
+            Point3d ptP1 ;
+            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1))
+               return false ;
+           // eventuale correzione inizio attacco per evitare interferenze
+            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1))
+               return false ;
+           // determino elevazione su inizio attacco
+            double dStElev ;
+            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
+               dStElev = dElev ;
+            dStElev -= ( ptP1 - ptStart) * vtTool ;
+           // se inizio, approccio globale al punto iniziale
+            if ( bStart) {
+               if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
+                  m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ;
+                  return false ;
+               }
+               bStart = false ;
+            }
+           // altrimenti, approccio di collegamento
+            else {
+               if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
+                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
+                  return false ;
+               }
+            }
+           // aggiungo attacco
+            SetFeed( GetStartFeed()) ;
+            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
+               m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ;
+               return false ;
+            }
+         }
+        // elaborazioni sulla curva corrente (sempre un segmento di retta)
+         ICurveLine* pLine = GetCurveLine( pCurve) ;
+         if ( pLine == nullptr)
+            return false ;
+         Point3d ptP3 = pLine->GetEnd() ;
+         Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
+         SetFeed( GetRightFeed( vtMove, vtTool)) ;
+         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
+            return false ;
+        // se ultima entità
+         if ( i == nMaxInd) {
+           // dati fine entità
+            Point3d ptEnd ;
+            pCurve->GetEndPoint( ptEnd) ;
+            Vector3d vtEnd ;
+            pCurve->GetEndDir( vtEnd) ;
+           // vettore tangente finale non deve scendere rispetto a estrusione
+            double dEndOnExtr = vtEnd * vtTool ;
+            if ( dEndOnExtr < 0) {
+               vtEnd -= dEndOnExtr * vtTool ;
+               vtEnd.Normalize() ;
+            }
+           // determino normale della superficie sul punto finale
+            Vector3d vtNorm ;
+            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
+               Point3d ptStart ;
+               pCurve->GetStartPoint( ptStart) ;
+               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm))
+                  vtNorm = V_NULL ;
+            }
+           // determino fine uscita
+            Point3d ptP1 ;
+            if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1))
+               return false ;
+           // eventuale correzione fine uscita per evitare interferenze
+            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1))
+               return false ;
+           // aggiungo uscita
+            SetFeed( GetEndFeed()) ;
+            if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) {
+               m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ;
+               return false ;
+            }
+           // determino elevazione su fine uscita
+            double dEndElev ;
+            if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
+               dEndElev = dElev ;
+            dEndElev -= ( ptP1 - ptEnd) * vtTool ;
+           // se non è ultimo tratto, aggiungo retrazione di collegamento
+            if ( k < int( vpCrvs.size()) - 1) {
+               if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
+                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
+                  return false ;
+               }
+            }
+           // altrimenti aggiungo retrazione finale
+            else {
+               if ( ! AddRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
+                  m_pMchMgr->SetLastError( 3115, "Error in SurfFinishing : Retract not computable") ;
+                  return false ;
+               }
+            }
+         }
+      }
+   }
+
+   return true ;
+}
+
+//----------------------------------------------------------------------------
+bool
+SurfFinishing::AddSpiral( ICAvToolSurfTm* pCAvTlStm, const Frame3d& frSurf, const ISurfFlatRegion* pSfrPock,
+                          const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs, bool bInVsOut)
+{  
+  // recupero distanze di sicurezza
+   double dSafeZ = GetSafeZ() ;
+  // lunghezza di approccio/retrazione
+   double dAppr = m_Params.m_dStartPos ;
+
+  // calcolo la spirale
+   double dPockRad = m_Params.m_dSideStep ;
+   double dPockRadOffs = m_TParams.m_dDiam / 2 - m_Params.m_dSideStep - m_Params.m_dOverlap ;
+   int nType = ( bInVsOut ? POCKET_SPIRALIN : POCKET_SPIRALOUT) ;
+   ICRVCOMPOPOVECTOR vpCrvs ;
+   if ( ! CalcPocketing( pSfrPock, dPockRad, dPockRadOffs, m_Params.m_dSideStep, m_Params.m_dSideAngle,
+                         nType, false, false, true, false, P_INVALID, nullptr, vpCrvs)) {
+      m_pMchMgr->SetLastError( 3125, "Error in SurfFinishing : CalcPocketing failed") ;
+      return false ;
+   }
+
+  // determino il riferimento di base della svuotatura
+   Frame3d frPocket ;
+   Point3d ptCen ; pSfrPock->GetCentroid( ptCen) ;
+   frPocket.Set( ptCen, vtTool) ;
+
+  // ciclo sulle curve risultanti
+   bool bStart = true ;
+   for ( int k = 0 ; k < int( vpCrvs.size()) ; ++ k) {
+      PtrOwner<ICurveComposite> pMCrv( Release( vpCrvs[k])) ;
+      pMCrv->ToLoc( frPocket) ;
+     // li correggo per non interferire con le superfici
+      if ( pCAvTlStm != nullptr) {
+        // approssimo la curva con una polilinea
+         PolyLine PL ;
+         if ( ! pMCrv->ApproxWithLines( m_Params.m_dApprox, ANG_TOL_STD_DEG, ICurve::APL_SPECIAL, PL))
+            return false ;
+        // eventuale aggiunta di punti per garantire max distanza
+         const double MIN_DIST = 1. ;
+         const double MAX_DIST = 50. ;
+         double dDist = Clamp( m_TParams.m_dDiam / 2, MIN_DIST, MAX_DIST) ;
+         if ( ! PL.AdjustForMaxSegmentLen( dDist))
+            return false ;
+        // porto nel riferimento delle superfici
+         PL.LocToLoc( frPocket, frSurf) ;
+        // porto i dati geometrici in locale alle superfici
+         Vector3d vtAxL = vtTool ;
+         vtAxL.ToLoc( frSurf) ;
+         Vector3d vtMoveL = vtAxL ;
+        // traslo della lunghezza utensile diminuita dell'affondamento
+         PL.Translate( vtAxL * ( m_TParams.m_dLen - dDepth)) ;
+        // eseguo CAv
+         if ( ! pCAvTlStm->TestPath( PL.GetUPointList(), vtAxL, vtMoveL, m_Params.m_dApprox))
+            return false ;
+        // contro-traslo della lunghezza utensile
+         PL.Translate( - vtAxL * m_TParams.m_dLen) ;
+        // riporto la polilinea nel riferimento della curva
+         PL.LocToLoc( frSurf, frPocket) ;
+        // elimino i punti allineati
+         PL.RemoveAlignedPoints( 0.8 * m_Params.m_dApprox) ;
+        // creo una curva composita a partire dalla polilinea
+         PtrOwner< ICurveComposite> pCompo( CreateCurveComposite()) ;
+         if ( IsNull( pCompo)  ||  ! pCompo->FromPolyLine( PL))
+            return false ;
+        // sostituisco la vecchia curva con la nuova
+         pMCrv.Set( pCompo) ;
+      }
+     // ciclo sulle curve elementari
+      int nMaxInd = pMCrv->GetCurveCount() - 1 ;
+      for ( int i = 0 ; i <= nMaxInd ; ++ i) {
+        // curva corrente
+         const ICurve* pCrvC = pMCrv->GetCurve( i) ;
+        // copio la curva
+         PtrOwner<ICurve> pCurve( pCrvC->Clone()) ;
+         if ( IsNull( pCurve))
+            return false ;
+         pCurve->ToGlob( frPocket) ;
+        // se prima entità
+         if ( i == 0 ) {
+           // dati inizio entità
+            Point3d ptStart ;
+            pCurve->GetStartPoint( ptStart) ;
+            Vector3d vtStart ;
+            pCurve->GetStartDir( vtStart) ;
+           // vettore tangente iniziale non deve salire rispetto a estrusione (poi si prende opposto)
+            double dStartOnExtr = vtStart * vtTool ;
+            if ( dStartOnExtr > 0) {
+               vtStart -= dStartOnExtr * vtTool ;
+               vtStart.Normalize() ;
+            }
+           // determino normale della superficie sul punto iniziale
+            Vector3d vtNorm ;
+            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm)) {
+               Point3d ptEnd ;
+               pCurve->GetEndPoint( ptEnd) ;
+               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm))
+                  vtNorm = V_NULL ;
+            }
+           // determino inizio attacco
+            Point3d ptP1 ;
+            if ( ! CalcLeadInStart( ptStart, vtStart, vtTool, vtNorm, ptP1))
+               return false ;
+           // eventuale correzione inizio attacco per evitare interferenze
+            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptStart, ptP1, vtTool, ptP1))
+               return false ;
+           // determino elevazione su inizio attacco
+            double dStElev ;
+            if ( ! GetElevation( m_nPhase, ptStart - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dStElev))
+               dStElev = dElev ;
+            dStElev -= ( ptP1 - ptStart) * vtTool ;
+           // se inizio, approccio globale al punto iniziale
+            if ( bStart) {
+               if ( ! AddApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
+                  m_pMchMgr->SetLastError( 3111, "Error in SurfFinishing : Approach not computable") ;
+                  return false ;
+               }
+               bStart = false ;
+            }
+           // altrimenti, approccio di collegamento
+            else {
+               if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dStElev, dAppr)) {
+                  m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
+                  return false ;
+               }
+            }
+           // aggiungo attacco
+            SetFeed( GetStartFeed()) ;
+            if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtTool, bSplitArcs)) {
+               m_pMchMgr->SetLastError( 3113, "Error in SurfFinishing : LeadIn not computable") ;
+               return false ;
+            }
+         }
+        // elaborazioni sulla curva corrente (sempre un segmento di retta)
+         ICurveLine* pLine = GetCurveLine( pCurve) ;
+         if ( pLine == nullptr)
+            return false ;
+         Point3d ptP3 = pLine->GetEnd() ;
+         Vector3d vtMove ; pLine->GetStartDir( vtMove) ;
+         SetFeed( GetRightFeed( vtMove, vtTool)) ;
+         if ( AddLinearMove( ptP3) == GDB_ID_NULL)
+            return false ;
+        // se ultima entità
+         if ( i == nMaxInd) {
+           // dati fine entità
+            Point3d ptEnd ;
+            pCurve->GetEndPoint( ptEnd) ;
+            Vector3d vtEnd ;
+            pCurve->GetEndDir( vtEnd) ;
+           // vettore tangente finale non deve scendere rispetto a estrusione
+            double dEndOnExtr = vtEnd * vtTool ;
+            if ( dEndOnExtr < 0) {
+               vtEnd -= dEndOnExtr * vtTool ;
+               vtEnd.Normalize() ;
+            }
+           // determino normale della superficie sul punto finale
+            Vector3d vtNorm ;
+            if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptEnd, vtTool, vtNorm)) {
+               Point3d ptStart ;
+               pCurve->GetStartPoint( ptStart) ;
+               if ( ! GetSurfaceNormalAtPoint( pCAvTlStm, frSurf, ptStart, vtTool, vtNorm))
+                  vtNorm = V_NULL ;
+            }
+           // determino fine uscita
+            Point3d ptP1 ;
+            if ( ! CalcLeadOutEnd( ptEnd, vtEnd, vtTool, vtNorm, ptP1))
+               return false ;
+           // eventuale correzione fine uscita per evitare interferenze
+            if ( ! GetLastGoodPoint( pCAvTlStm, frSurf, ptEnd, ptP1, vtTool, ptP1))
+               return false ;
+           // aggiungo uscita
+            SetFeed( GetEndFeed()) ;
+            if ( ! AddLeadOut( ptEnd, vtEnd, ptP1, vtTool, bSplitArcs)) {
+               m_pMchMgr->SetLastError( 3114, "Error in SurfFinishing : LeadOut not computable") ;
+               return false ;
+            }
+           // determino elevazione su fine uscita
+            double dEndElev ;
+            if ( ! GetElevation( m_nPhase, ptEnd - 10 * EPS_SMALL * vtTool, vtTool, GetRadiusForStartEndElevation(), vtTool, dEndElev))
+               dEndElev = dElev ;
+            dEndElev -= ( ptP1 - ptEnd) * vtTool ;
+           // se non è ultimo tratto, aggiungo retrazione di collegamento
             if ( false) {
                if ( ! AddLinkRetract( ptP1, vtTool, dSafeZ, dEndElev, dAppr)) {
                   m_pMchMgr->SetLastError( 3112, "Error in SurfFinishing : Link not computable") ;
@@ -2663,7 +2662,7 @@ SurfFinishing::CalcZConstProjectedLink( ICAvToolSurfTm* pCAvTlStm, const Frame3d
                                         const Point3d ptStart_forced, const Point3d ptEnd_forced,
                                         ICurveComposite* pCrv)
 {
-  /* funzione per proiettare una curva su una supericie trimesh passando per la silhouette */
+  // funzione per proiettare una curva su una supericie trimesh passando per la silhouette
   // controllo dei parametri
    if ( pCAvTlStm == nullptr  ||
         pCrv == nullptr  ||  ! pCrv->IsValid())
@@ -2709,9 +2708,6 @@ SurfFinishing::CalcZConstProjectedLink( ICAvToolSurfTm* pCAvTlStm, const Frame3d
    return true ;
 }
 
-//----------------------------------------------------------------------------
-
-
 //----------------------------------------------------------------------------
 bool
 SurfFinishing::AddZConst( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfr,
@@ -2915,7 +2911,7 @@ bool
 SurfFinishing::ApproxSilhouetteClosedPLForOptimal( PolyLine& PL, double dSampleTol, double dMaxLinTol, double dAngTol, double dLinFeaTol,
                                                    ICurveComposite* pCompoPL)
 {
-  /* approssimazione di una polyline di Silhouette per rimuovere Spikes di proiezione */
+  // approssimazione di una polyline di Silhouette per rimuovere Spikes di proiezione
   // controllo dei parametri
    if ( pCompoPL == nullptr)
       return false ;
@@ -3078,7 +3074,7 @@ SurfFinishing::GetSfrBySilhouette( ICAvParSilhouettesSurfTm* pCavParSilh, double
                                    double dSilTolSamp, double dSilTolLin,
                                    double dSilTolAng, ISurfFlatRegion* pSfrSil)
 {
-  /* funzione per resitutire una regione piana data la classe di calcolo per silhouette */
+  // funzione per resitutire una regione piana data la classe di calcolo per silhouette
   // controllo dei parametri
    if ( pSfrSil == nullptr)
       return false ;
@@ -3100,7 +3096,7 @@ SurfFinishing::GetSfrBySilhouette( ICAvParSilhouettesSurfTm* pCavParSilh, double
       if ( ! SfrMaker.AddCurve( Release( pSilCrv)))
          return false ;
    }
-  // definisco la reigone piana
+  // definisco la regione piana
    PtrOwner<ISurfFlatRegion> pSfrTmp( SfrMaker.GetSurf()) ;
    if ( ! IsNull( pSfrTmp)  &&  pSfrTmp->IsValid())
       pSfrSil->CopyFrom( pSfrTmp) ;
@@ -3113,13 +3109,11 @@ SurfFinishing::SplitStmTrianglesForSpiralAndZConst( const ISurfTriMesh* pStm, co
                                                     const Vector3d& vtTool, double dClippingAngle, double dTolerAngle,
                                                     StmFromTriangleSoup& TriaSoup, double& dMaxFrontTriaRad)
 {
-  /*
-  funzione per ciclare i triangoli di una TriMesh (*pStm) partendo da nT_start e terminando a nT_end
-  I triangoli che formano un angolo in valore assoluto con vtTool, maggiore di dClippingAngle 
-  vengono inseriti nella zuppa
-  dMaxFrontTriaRad è il raggio massimo dei triangoli con normale che si discosta da vtTool per
-  meno di dTolerAngle (triangoli frontalieri)
-  */
+  //Funzione per ciclare i triangoli di una TriMesh (*pStm) partendo da nT_start e terminando a nT_end
+  //I triangoli che formano un angolo in valore assoluto con vtTool, maggiore di dClippingAngle 
+  //vengono inseriti nella zuppa
+  //dMaxFrontTriaRad è il raggio massimo dei triangoli con normale che si discosta da vtTool per
+  //meno di dTolerAngle (triangoli frontalieri)
 
   // controllo della superficie
    if ( pStm == nullptr  ||  ! pStm->IsValid())
@@ -3195,9 +3189,9 @@ SurfFinishing::SplitStmInTwoSilSfrByClippingAngle( const SURFLOCALVECTOR& vSrfLo
       return false ;
 
   // parametri e costanti per il calcolo della regione
-   double dMaxRad = 100 * EPS_SMALL ; // raggio massimo della sfera che contiene i triangoli frontalieri
-   const double OFFS_TRIA_ANG_TOL = 2. ; // tolleranza di ricerca dei triangoli frontalieri
-   const double OFFS_CORR = 0. ; // offset correttivo regione piana ZConst
+   double dMaxRad = 100 * EPS_SMALL ;     // raggio massimo della sfera che contiene i triangoli frontalieri
+   const double OFFS_TRIA_ANG_TOL = 2. ;  // tolleranza di ricerca dei triangoli frontalieri
+   const double OFFS_CORR = 0. ;          // offset correttivo regione piana ZConst
 
   // creazione della zuppa di triangoli per la Zconst
    StmFromTriangleSoup StmSoup ;
@@ -3407,7 +3401,8 @@ bool
 SurfFinishing::AddOptimal( ICAvToolSurfTm* pCAvTlStm, const SURFLOCALVECTOR& vSrfLoc, const Frame3d& frSurf, const ISurfFlatRegion* pSfr,
                            const Vector3d& vtTool, double dDepth, double dElev, bool bSplitArcs)
 {
-   return true ; // per ora (Test)
+  // !!! per ora (Test) !!!
+   return true ;
 
   // controllo che la regione sia definita correttamente
    if ( pSfr == nullptr  ||  ! pSfr->IsValid())
@@ -3775,7 +3770,7 @@ SurfFinishing::AddApproach( const Point3d& ptP, const Vector3d& vtTool, double d
 bool
 SurfFinishing::AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
 {
-  // se sopra attacco c'� spazio per approccio
+  // se sopra attacco c'è spazio per approccio
    if ( ( dElev + dAppr) > 10 * EPS_SMALL) {
      // 1b -> punto appena sopra inizio
       Point3d ptP1b = ptP + vtTool * ( dElev + dAppr) ;
@@ -3803,7 +3798,7 @@ SurfFinishing::AddLinkApproach( const Point3d& ptP, const Vector3d& vtTool, doub
 bool
 SurfFinishing::AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
 {
-  // se sopra uscita c'� spazio per approccio
+  // se sopra uscita c'è spazio per approccio
    if ( ( dElev + dAppr) > 10 * EPS_SMALL) {
      // 4 -> movimento di risalita sopra il punto finale
       SetFeed( GetEndFeed()) ;
@@ -3818,7 +3813,7 @@ SurfFinishing::AddLinkRetract( const Point3d& ptP, const Vector3d& vtTool, doubl
 bool
 SurfFinishing::AddRetract( const Point3d& ptP, const Vector3d& vtTool, double dSafeZ, double dElev, double dAppr)
 {
-  // se sopra uscita c'� spazio per sicurezza o approccio
+  // se sopra uscita c'è spazio per sicurezza o approccio
    double dSafeDist = dSafeZ ;
    if ( dElev + max( dSafeDist, dAppr) > 10 * EPS_SMALL) {
       if ( dSafeDist < dAppr + 10 * EPS_SMALL) {
@@ -3888,7 +3883,7 @@ SurfFinishing::CalcLeadInStart( const Point3d& ptStart, const Vector3d& vtStart,
 bool
 SurfFinishing::AddLeadIn( const Point3d& ptP1, const Point3d& ptStart, const Vector3d& vtStart, const Vector3d& vtTool, bool bSplitArcs)
 {
-  // Se inizio e fine coincidono, non devo fare alcunch�
+  // Se inizio e fine coincidono, non devo fare alcunchè
    if ( AreSamePointApprox( ptP1, ptStart))
       return true ;
   // Assegno il tipo
@@ -3966,7 +3961,7 @@ SurfFinishing::CalcLeadOutEnd( const Point3d& ptEnd, const Vector3d& vtEnd, cons
 bool
 SurfFinishing::AddLeadOut( const Point3d& ptEnd, const Vector3d& vtEnd, const Point3d& ptP1, const Vector3d& vtTool, bool bSplitArcs)
 {
-  // Se inizio e fine coincidono, non devo fare alcunch�
+  // Se inizio e fine coincidono, non devo fare alcunchè
    if ( AreSamePointApprox( ptEnd, ptP1))
       return true ;
   // Assegno tipo e parametri

From 7d7e3209c0f9b5e0839e739caa55010b7e374f6b Mon Sep 17 00:00:00 2001
From: Dario Sassi <dario.sassi@egalware.com>
Date: Mon, 6 Jan 2025 18:18:00 +0100
Subject: [PATCH 4/4] =?UTF-8?q?EgtMachKernel=20:=20-=20aggiustamenti=20per?=
 =?UTF-8?q?=20modifiche=20a=20FromString=20(in=20caso=20di=20errore=20non?=
 =?UTF-8?q?=20inizializza=20pi=C3=B9=20a=200=20il=20valore=20di=20ritorno)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 EgtMachKernel.sln |  4 ++--
 Milling.cpp       |  2 +-
 Pocketing.cpp     |  1 +
 PocketingNT.cpp   |  1 +
 Sawing.cpp        | 16 ++++++++--------
 SimulatorMP.cpp   |  4 ++--
 6 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/EgtMachKernel.sln b/EgtMachKernel.sln
index 70e1d53..1171052 100644
--- a/EgtMachKernel.sln
+++ b/EgtMachKernel.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio 15
-VisualStudioVersion = 15.0.28307.645
+# Visual Studio Version 17
+VisualStudioVersion = 17.12.35527.113 d17.12
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "EgtMachKernel", "EgtMachKernel.vcxproj", "{0BD58222-92F3-48B2-B656-4497D1956874}"
 EndProject
diff --git a/Milling.cpp b/Milling.cpp
index e79d1d3..9f401af 100644
--- a/Milling.cpp
+++ b/Milling.cpp
@@ -1953,7 +1953,7 @@ Milling::ProcessPath( int nPathId, int nPvId, int nClId)
       return false ;
 
   // recupero eventuale flag di inizio forzato fuori dal grezzo
-   int nStartOutRaw ;
+   int nStartOutRaw = 0 ;
    FromString( ExtractInfo( m_Params.m_sUserNotes, "OutRaw="), nStartOutRaw) ;
    m_bStartOutRaw = (( nStartOutRaw & 1) != 0) ;
    m_bEndOutRaw = (( nStartOutRaw & 2) != 0) ;
diff --git a/Pocketing.cpp b/Pocketing.cpp
index 0728b88..545f8f1 100644
--- a/Pocketing.cpp
+++ b/Pocketing.cpp
@@ -1682,6 +1682,7 @@ Pocketing::ProcessPath( int nPathId, int nPvId, int nClId)
    m_bOpenOutRaw = ( FromString( ExtractInfo( m_Params.m_sUserNotes, "OpenOutRaw="), nOpenOutRaw)  &&  nOpenOutRaw != 0) ;
 
   // recupero eventuale minima lunghezza di attacco su lato aperto
+   m_dOpenMinSafe = 0 ;
    FromString( ExtractInfo( m_Params.m_sUserNotes, "OpenMinSafe="), m_dOpenMinSafe) ;
 
   // se richiesta anteprima
diff --git a/PocketingNT.cpp b/PocketingNT.cpp
index e6a2669..c274699 100644
--- a/PocketingNT.cpp
+++ b/PocketingNT.cpp
@@ -2171,6 +2171,7 @@ PocketingNT::ProcessPath( int nPathId, int nPvId, int nClId)
    m_bOpenOutRaw = ( FromString( ExtractInfo( m_Params.m_sUserNotes, "OpenOutRaw="), nOpenOutRaw)  &&  nOpenOutRaw != 0) ;
 
   // recupero eventuale minima lunghezza di attacco su lato aperto
+   m_dOpenMinSafe = 0 ;
    FromString( ExtractInfo( m_Params.m_sUserNotes, "OpenMinSafe="), m_dOpenMinSafe) ;
 
   // se richiesta anteprima
diff --git a/Sawing.cpp b/Sawing.cpp
index 3a7ee11..0807972 100644
--- a/Sawing.cpp
+++ b/Sawing.cpp
@@ -1868,10 +1868,10 @@ Sawing::ProcessLine( const ICurve* pCrvP, const ICurveLine* pLineC, const ICurve
       if ( ! sFsta.empty()) {
          string sLen, sPu ;
          SplitFirst( sFsta, ",", sLen, sPu) ;
-         FromString( sLen, FvVar.dLenStart) ;
-         FvVar.dLenStart = max( FvVar.dLenStart, 0.) ;
-         FromString( sPu, FvVar.dPuStart) ;
-         FvVar.dPuStart = max( FvVar.dPuStart, 0.) ;
+         if ( FromString( sLen, FvVar.dLenStart))
+            FvVar.dLenStart = max( FvVar.dLenStart, 0.) ;
+         if ( FromString( sPu, FvVar.dPuStart))
+            FvVar.dPuStart = max( FvVar.dPuStart, 0.) ;
       }
    }
    if ( pCrvN == nullptr) {
@@ -1879,10 +1879,10 @@ Sawing::ProcessLine( const ICurve* pCrvP, const ICurveLine* pLineC, const ICurve
       if ( ! sFend.empty()) {
          string sLen, sPu ;
          SplitFirst( sFend, ",", sLen, sPu) ;
-         FromString( sLen, FvVar.dLenEnd) ;
-         FvVar.dLenEnd = max( FvVar.dLenEnd, 0.) ;
-         FromString( sPu, FvVar.dPuEnd) ;
-         FvVar.dPuEnd = max( FvVar.dPuEnd, 0.) ;
+         if ( FromString( sLen, FvVar.dLenEnd))
+            FvVar.dLenEnd = max( FvVar.dLenEnd, 0.) ;
+         if ( FromString( sPu, FvVar.dPuEnd))
+            FvVar.dPuEnd = max( FvVar.dPuEnd, 0.) ;
       }
    }
 
diff --git a/SimulatorMP.cpp b/SimulatorMP.cpp
index 50414a1..f69542a 100644
--- a/SimulatorMP.cpp
+++ b/SimulatorMP.cpp
@@ -2619,11 +2619,11 @@ SimulatorMP::ExecCmdData( int& nStatus)
          bOk = m_pMachine->LuaSetGlobVar( CmdCurr.sPar, bVal) ;
       } break ;
       case 2 :
-      {  int nVal ; FromString( CmdCurr.sPar2, nVal) ;
+      {  int nVal = 0 ; FromString( CmdCurr.sPar2, nVal) ;
          bOk = m_pMachine->LuaSetGlobVar( CmdCurr.sPar, nVal) ;
       } break ;
       case 3 :
-      {  double dVal ; FromString( CmdCurr.sPar2, dVal) ;
+      {  double dVal = 0 ; FromString( CmdCurr.sPar2, dVal) ;
          bOk = m_pMachine->LuaSetGlobVar( CmdCurr.sPar, dVal) ;
       } break ;
       case 4 :