From 4f64b1efc2ef24b0ac469b45c852a645d3325b06 Mon Sep 17 00:00:00 2001
From: Riccardo Elitropi <riccardo.elitropi@egalware.com>
Date: Tue, 30 Jan 2024 13:30:18 +0100
Subject: [PATCH] EgtMachKernel : - Entrate Helix e ZigZag ( codice di prova).

---
 Pocketing.cpp | 68 ++++++++++++++++++++++++++-------------------------
 1 file changed, 35 insertions(+), 33 deletions(-)

diff --git a/Pocketing.cpp b/Pocketing.cpp
index 71fd199..f997488 100644
--- a/Pocketing.cpp
+++ b/Pocketing.cpp
@@ -55,6 +55,7 @@
 #include "/EgtDev/Include/EGkStmFromCurves.h"
 #include "/EgtDev/Include/EGkStmFromTriangleSoup.h"
 #include <algorithm>
+#include <set>
 
 using namespace std ;
 
@@ -6311,9 +6312,6 @@ Pocketing::AddSpiralIn( ISURFFRPOVECTOR& vSfr, const vector<ICRVCOMPOPOVECTOR>&
             if ( bOutStart  &&  ! bOptimizedTrap) {
               // calcolo il punto fuori per il LeadIn
                Point3d ptOut = ptStart + vtMidOut * ( 0.5 * m_TParams.m_dDiam + max( dSafeZ, m_dOpenMinSafe)) ;
-               IGeoPoint3d* ptOUTTTTT( CreateGeoPoint3d()) ; ptOUTTTTT->Set( ptOut) ;
-               int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, ptOUTTTTT->Clone()) ;
-               m_pGeomDB->SetMaterial( b, BLUE) ;
                double dStElev ;
               // controllo l'elevazione
                bOutStart = ( ! GetElevation( m_nPhase, ptOut, vtTool, 0.5 * m_TParams.m_dDiam, vtTool, dStElev)  ||  dStElev < EPS_SMALL) ;
@@ -6842,7 +6840,7 @@ Pocketing::CalcLinkOnStep( const Point3d& ptS, const Point3d& ptE, const ISurfFl
    PtrOwner<ISurfFlatRegion> pSfrSafe( pSfr->CreateOffsetSurf( - 0.5 * m_TParams.m_dDiam - GetOffsR() + 5 * EPS_SMALL,
                                                                ICurve::OFF_FILLET)) ;
    if ( IsNull( pSfrSafe)  ||  ! pSfrSafe->IsValid()  ||
-        ! pSfrSafe->CalcMedialAxis( vCrvBisectors, Voronoi::WMAT_LEFT)  ||
+        ! pSfrSafe->CalcMedialAxis( vCrvBisectors, WMAT_IN)  ||
         vCrvBisectors.empty())
       return false ;
   
@@ -7341,7 +7339,8 @@ Pocketing::AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVEC
       ICRVCOMPOPOVECTOR vRCrv ;           // vettore delle curve dei percorsi di ritorno dello step precedente
       vector<Vector3d> vvtMidOut ;        // vettore dei versori delle direzioni di uscita dello step precedente
       INTVECTOR vnRegTot ;                // vettore dei numeri delle regioni formate dal primo Offset nello step precedente
-      BOOLVECTOR vbOptTrap ;
+      BOOLVECTOR vbOptTrap ;              // vettore di flag per casi ottimizzati
+      Point3d ptEndPath ;                 // punto finale del percorso di svuotatura attuale
    } ;
    SpiralData SDStepPrec ;                   // informazioni Spiral attuali
    int nOffs_act = 0 ;                       // Shift indice dei vettori causato da nReg
@@ -7357,6 +7356,7 @@ Pocketing::AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVEC
           SDStepCurr.vnRegTot = SDStepPrec.vnRegTot ;
           SDStepCurr.vvtMidOut = SDStepPrec.vvtMidOut ;
           SDStepCurr.vbOptTrap = SDStepPrec.vbOptTrap ;
+          SDStepCurr.ptEndPath = SDStepPrec.ptEndPath ;
       }
 
      // se superficie non valida, passo alla prossima
@@ -7368,6 +7368,9 @@ Pocketing::AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVEC
       if( IsNull( pSrfLeanInOut))
          return false ;
 
+     // punto finale dello step precedente
+      Point3d ptEndPrec = ( j == 1 ? P_INVALID : SDStepPrec.ptEndPath) ;
+
      // creo le entità per lo step corrente
       ICRVCOMPOPOVECTOR vMCrv, vRCrv ;
       BOOLVECTOR vbOut ;
@@ -7436,9 +7439,9 @@ Pocketing::AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVEC
 
                 nRegTot = nReg ;
                // calcolo il percorso di svuotatura
-                //if ( ! CalcSpiral( pSrfChunk, nRegTot, ptStart, vtMidOut, bMidOut, bSplitArcs, pMCrv, pRCrv,
-                //                   vCrvOrig[j-1][nInd], vbChangedPrec[j-1], bOptimizedTrap))
-                //   return false ;
+                if ( ! CalcSpiral( pSrfChunk, nRegTot, ptStart, ptEndPrec, vtMidOut, bMidOut, bSplitArcs, pMCrv, pRCrv,
+                                   vCrvOrig[j-1][nInd], j == 1 ? true : vbChangedPrec[j-1], bOptimizedTrap))
+                   return false ;
 
                // se terminate le regioni...
                 if ( pMCrv->GetCurveCount() == 0)
@@ -7465,6 +7468,9 @@ Pocketing::AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVEC
                SDStepCurr.vvtMidOut.push_back( vtMidOut) ;
               // memorizzo caso ottimizzato
                SDStepCurr.vbOptTrap.push_back( bOptimizedTrap) ;
+              // sovrascrivo sempre il punto finale ( lo aggiorno in caso di più chunks)
+               Point3d ptEnd ; pMCrv->GetEndPoint( ptEnd) ;
+               SDStepCurr.ptEndPath = ptEnd ;
             }
 
             // se il tool non è cilindrico...
@@ -7587,6 +7593,8 @@ Pocketing::AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVEC
             if ( IsNull( pCurve))
                return false ;
 
+            m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCurve->Clone()) ;
+
            // se prima curva del percorso
             if ( u == 0) {
               // ricavo il punto inziale
@@ -7627,10 +7635,10 @@ Pocketing::AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVEC
                   }
                  // aggiungo attacco
                   SetFeed( GetStartFeed()) ;
-                  //if ( ! AddLeadIn( ptP1, ptStart, vtStart, vtExtr, pSrfLeanInOut, vRCrv[i], !m_Params.m_bInvert, bSplitArcs, vbOut[i])) {
-                  //   m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ;
-                  //   return false ;
-                  //}
+                  if ( ! AddLeadIn( vMCrv[i], ptP1, ptStart, vtStart, V_INVALID, vtExtr, pSrfLeanInOut, vRCrv[i], !m_Params.m_bInvert, bSplitArcs, vbOut[i])) {
+                     m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ;
+                     return false ;
+                  }
                }
               // ... se devo aggiungere l'uscita del percorso precedente e calcolare l'entrata
               // per il percorso attuale
@@ -7640,9 +7648,15 @@ Pocketing::AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVEC
                   Point3d ptCurr ; GetCurrPos( ptCurr) ;
                  // ricavo il punto che devo raggiungere
                   Point3d ptDest ; vMCrv[i]->GetStartPoint( ptDest) ;
+                 // modifico il punto di destinazione a seconda del tipo di attacco per tangenza
+                  Vector3d vtEnd = vtStart ;
+                  if ( ! vbOut[i]) {
+                     if ( ! SetLeadInPointStart( ptCurr, vtTool, !m_Params.m_bInvert, vtStart, ptDest))
+                        return false ;
+                  }
                  // calcolo il percorso di ritorno del percorso attuale
                   if ( IsNull( pRCrv)  ||
-                       ! CalcLinkOnStep( ptCurr, ptDest, vSfr[j-2], vSrfLimit[j-2], pRCrv)) {
+                       ! CalcLinkOnStep( ptCurr, ptDest, vSfr[j-2], ! SDStepCurr.vbOptTrap[i] ? vSrfLimit[j-2] : CreateSurfFlatRegion(), pRCrv)) {
                      m_pMchMgr->SetLastError( 2441, "Error in Pocketing : Return path not computable") ;
                      return false ;
                   }
@@ -7654,10 +7668,10 @@ Pocketing::AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVEC
                   Point3d ptAbove ; GetCurrPos( ptAbove) ;
                  // aggiungo attacco ( solo collegamento )
                   SetFeed( GetStartFeed()) ;
-                  //if ( ! AddLeadIn( ptAbove, ptStart, vtStart, vtExtr, pSrfLeanInOut, vRCrv[i], !m_Params.m_bInvert, bSplitArcs, vbOut[i])) {
-                  //   m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ;
-                  //   return false ;
-                  //}
+                  if ( ! AddLeadIn( vMCrv[i], ptAbove, ptStart, vtStart, vtEnd, vtExtr, pSrfLeanInOut, vRCrv[i], !m_Params.m_bInvert, bSplitArcs, vbOut[i])) {
+                     m_pMchMgr->SetLastError( 2415, "Error in Pocketing : LeadIn not computable") ;
+                     return false ;
+                  }
                }
             }
 
@@ -7713,9 +7727,10 @@ Pocketing::AddSpiralOut( ISURFFRPOVECTOR& vSfr, const std::vector<ICRVCOMPOPOVEC
       SDStepPrec.vnRegTot = SDStepCurr.vnRegTot ;
       SDStepPrec.vvtMidOut = SDStepCurr.vvtMidOut ;
       SDStepPrec.vbOptTrap = SDStepCurr.vbOptTrap ;
+      SDStepPrec.ptEndPath = SDStepCurr.ptEndPath ;
    }
 
-   return true ;
+    return true ;
 }
 
 //----------------------------------------------------------------------------
@@ -7827,7 +7842,6 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
    double dOffsPrec = 0. ;
    while ( nIter < MAX_ITER) {
      // ricavo la regione piana da VRONI
-      m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfAct->Clone()) ;
       PtrOwner<ISurfFlatRegion> pSfrOffsVR( pSrfAct->CreateOffsetSurf( - dOffs, ICurve::OFF_FILLET)) ;
       if ( IsNull( pSfrOffsVR))
          return false ;
@@ -10326,8 +10340,9 @@ Pocketing::AddLeadIn( const ICurveComposite* pCrvCompo, const Point3d& ptP1, con
       Point3d ptCen = ptP1 + vtCen * dRad ;
       double dDeltaN = ( ptStart - ptP1) * vtN ;
       double dExtraAng = 0. ;
-      if ( vtEnd.IsValid())
+      if ( vtEnd.IsValid()) {
          vtEnd.GetAngle( vtStart, dExtraAng) ;
+      }
       double dAngCen = ( bAtLeft ? dExtraAng : - dExtraAng) +
                        ceil( - dDeltaN / ( m_Params.m_dLiElev + 20 * EPS_SMALL)) * ( bAtLeft ? ANG_FULL : - ANG_FULL) ;
      // verifico se fattibile
@@ -10372,9 +10387,6 @@ Pocketing::AddLeadIn( const ICurveComposite* pCrvCompo, const Point3d& ptP1, con
       }
      // per sicurezza...
       pCrvCompoFirstOffs->Close() ;
-      m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvCompoFirstOffs->Clone()) ;
-      IGeoPoint3d* ptSSSS( CreateGeoPoint3d()) ; ptSSSS->Set( ptStart) ;
-      m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, ptSSSS->Clone()) ;
      // la traslo della quantità richiesta ( il percorso a ZigZag incomincia sopra al piano di pocketing)
       pCrvCompoFirstOffs->Translate( - vtN * dDeltaN) ;
       double dLen, dUA, dUB ;
@@ -10390,10 +10402,6 @@ Pocketing::AddLeadIn( const ICurveComposite* pCrvCompo, const Point3d& ptP1, con
 
         // inverto la curva sinistra
          pCrvB->Invert() ;
-         int A = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvA->Clone()) ;
-         m_pGeomDB->SetMaterial( A, RED) ;
-         int B = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvB->Clone()) ;
-         m_pGeomDB->SetMaterial( B, BLUE) ;
 
         // traslo MAX_NUM_PT punti della curva lungo -vtN e creo quindi le curve per lo ZigZag
          const int MAX_NUM_PT = 100 ;
@@ -11807,12 +11815,6 @@ Pocketing::SetBetterPtStartForSubChunks( ICurveComposite* pCrvOffsAct, const ISu
    if ( bSomeOpen) // se ho dei lati aperti, cerco un parametro ideale per entrare
       bMidOut = GetParamOnOpenSide( pCrv, vOtherCrv, frPocket, ptStart, vtMidOut) ;
    if ( bMidOut) { // se ho trovato e valido, allora imposto il punto inziale trovato
-      if ( ptEndPrec.IsValid()) {
-         IGeoPoint3d* ptE( CreateGeoPoint3d()) ; ptE->Set( ptEndPrec) ;
-         m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, ptE->Clone()) ;
-      }
-      int b = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrv->Clone()) ;
-      m_pGeomDB->SetMaterial( b, BLUE) ;
       const double LEN_OUT = 5 ;
       double dPar ; int nFlag ;
       bMidOut = ( DistPointCurve( ptStart + LEN_OUT * vtMidOut, *pCrv).GetParamAtMinDistPoint( 0, dPar, nFlag)