EgtMachKernel :

- correzioni e modifiche a CalcSpiral di Pocketing.

Pocketing.cpp

@@ -2888,13 +2888,13 @@ Pocketing::CalcSpiral( const ICurveComposite* pCompo, bool bSplitArcs,
   // ciclo di offset verso l'interno
    const int MAX_ITER = 100 ;
    int nIter = 0 ;
+   ICURVEPOVECTOR vOffs ;
    PtrOwner<ICurve> pOffs ;
-   const ICurve* pCurr = pCompo ;
-   double dCurrRad = GetCurveRadius( pCurr) ;
+   double dCurrRad = GetCurveRadius( pCompo) ;
    while ( nIter < MAX_ITER) {
      // calcolo
       OffsetCurve OffsCrv ;
-      if ( ! OffsCrv.Make( pCurr, - dOffs, ICurve::OFF_FILLET)) {
+      if ( ! OffsCrv.Make( ( nIter == 0 ? (ICurve*) pCompo : pOffs), - dOffs, ICurve::OFF_FILLET)) {
          m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
          return false ;
       }
@@ -2905,27 +2905,14 @@ Pocketing::CalcSpiral( const ICurveComposite* pCompo, bool bSplitArcs,
       bool bSmallRad = ( nIter == 0 ? dOffs < dTRad + GetOffsR() + EPS_ZERO : dOffs < dTRad + EPS_ZERO) ;
      // se completato step di offset, accodo la curva offsettata al percorso di lavoro 
       if ( ! IsNull( pOffs)  &&  ( bNextOk  ||  bSmallRad)) {
-         // verifico se aggiungere linea di congiunzione
-         if ( pMCrv->GetCurveCount() > 0) {
-            Point3d ptStart ;
-            pOffs->GetStartPoint( ptStart) ;
-           // aggiungo al percorso principale
-            pMCrv->AddLine( ptStart) ;
-           // copio nel percorso di ritorno
-            pRCrv->AddCurve( *pMCrv->GetLastCurve()) ;
-         }
-        // se richiesta percorrenza invertita
-         if ( m_Params.m_bInvert)
-            pOffs->Invert() ;
-        // aggiungo la curva
-         pMCrv->AddCurve( Release( pOffs)) ;
+        // inserisco l'offset nel vettore
+         vOffs.emplace_back( Release( pOffs)) ;
       }
      // se offset va bene
       if ( bNextOk) {
         // sistemo per prossimo step
          dCurrRad = dRad ;
          pOffs.Set( Release( pNextOffs)) ;
-         pCurr = Get( pOffs) ;
         // nuovo valore pari allo step
          dOffs = GetSideStep() ;
       }
@@ -2941,6 +2928,77 @@ Pocketing::CalcSpiral( const ICurveComposite* pCompo, bool bSplitArcs,
       ++ nIter ;
    }
 
+  // calcolo i collegamenti
+   ICURVEPOVECTOR vLinks( vOffs.size()) ;
+   for ( int i = 1 ; i < int( vOffs.size()) ; ++ i) {
+     // punti di inizio e fine 
+      Point3d ptStart ;
+      vOffs[i-1]->GetStartPoint( ptStart) ;
+      Point3d ptEnd ;
+      vOffs[i]->GetStartPoint( ptEnd) ;
+     // creo la retta che li unisce
+      PtrOwner<ICurveLine> pLine( CreateCurveLine()) ;
+      if ( IsNull( pLine)  ||  ! pLine->Set( ptStart, ptEnd))
+         return false ;
+     // la classifico rispetto al primo offset (il più esterno)
+      CRVCVECTOR ccClass ;
+      IntersCurveCurve intCC( *pLine, *vOffs[0]) ;
+      intCC.GetCurveClassification( 0, ccClass) ;
+     // se nessuno o un solo tratto e interno, la retta è il collegamento
+      if ( ccClass.empty()  ||  ( ccClass.size() == 1  &&  ccClass[0].nClass == CRVC_IN)) {
+         vLinks[i].Set( Release( pLine)) ;
+      }
+     // altrimenti combino i tratti interni di retta con tratti del primo offset
+      else {
+         PtrOwner<ICurveComposite> pCompo( CreateCurveComposite()) ;
+         if ( IsNull( pCompo))
+            return false ;
+         for ( int j = 0 ; j < int( ccClass.size()) ; ++ j) {
+            if ( ccClass[j].nClass == CRVC_IN  ||  ccClass[j].nClass == CRVC_ON_P  ||  ccClass[j].nClass == CRVC_ON_M)
+               pCompo->AddCurve( pLine->CopyParamRange( ccClass[j].dParS, ccClass[j].dParE)) ;
+            else if ( ccClass[j].nClass == CRVC_OUT) {
+               Point3d ptS ;
+               pLine->GetPointD1D2( ccClass[j].dParS, ICurve::FROM_PLUS, ptS) ;
+               double dOffS ;
+               vOffs[0]->GetParamAtPoint( ptS, dOffS) ;
+               Point3d ptE ;
+               pLine->GetPointD1D2( ccClass[j].dParE, ICurve::FROM_MINUS, ptE) ;
+               double dOffE ;
+               vOffs[0]->GetParamAtPoint( ptE, dOffE) ;
+              // recupero i due possibili percorsi e uso il più corto
+               PtrOwner<ICurve> pCrvA( vOffs[0]->CopyParamRange( dOffS, dOffE)) ;
+               PtrOwner<ICurve> pCrvB( vOffs[0]->CopyParamRange( dOffE, dOffS)) ;
+               double dLenA ; pCrvA->GetLength( dLenA) ;
+               double dLenB ; pCrvB->GetLength( dLenB) ;
+               if ( dLenA < dLenB) {
+                  pCompo->AddCurve( Release( pCrvA)) ;
+               }
+               else {
+                  pCrvB->Invert() ;
+                  pCompo->AddCurve( Release( pCrvB)) ;
+               }
+            }
+         }
+         vLinks[i].Set( Release( pCompo)) ;
+      }
+   }
+
+  // creo i percorsi di lavoro e di ritorno a partire dalla raccolta degli offset e dei collegamenti
+   for ( int i = 0 ; i < int( vOffs.size()) ; ++ i) {
+     // se collegamento da aggiungere
+      if ( ! IsNull( vLinks[i])) {
+        // accodo una copia nel percorso di ritorno
+         pRCrv->AddCurve( vLinks[i]->Clone()) ;
+        // accodo nel percorso di lavorazione
+         pMCrv->AddCurve( Release( vLinks[i])) ;
+      }
+     // se richiesta percorrenza invertita
+      if ( m_Params.m_bInvert)
+         vOffs[i]->Invert() ;
+     // aggiungo la curva
+      pMCrv->AddCurve( Release( vOffs[i])) ;
+   }
+
   // verifico il percorso di lavoro
    if ( pMCrv->GetCurveCount() == 0) {
       m_pMchMgr->SetLastError( 2413, "Error in Pocketing : Toolpath not computable") ;