From ed677dfec6de2c80d5c5112609a884ee53d5d026 Mon Sep 17 00:00:00 2001
From: Riccardo Elitropi <riccardo.elitropi@egalware.com>
Date: Wed, 26 Jul 2023 11:45:43 +0200
Subject: [PATCH] EgtMachKernel : - migliorie varie.

---
 Pocketing.cpp | 523 +++++++++++++++++++++++---------------------------
 Pocketing.h   |   5 +-
 2 files changed, 242 insertions(+), 286 deletions(-)

diff --git a/Pocketing.cpp b/Pocketing.cpp
index d4874f9..5df1574 100644
--- a/Pocketing.cpp
+++ b/Pocketing.cpp
@@ -1342,7 +1342,7 @@ Pocketing::GetCurves( SelData Id, ICURVEPLIST& lstPC)
             pCrvCompo->ToGlob( frGlob) ;
            // imposto come TmpProp0 -> l'id della superificie
             pCrvCompo->SetTempProp( Id.nId, 0) ;
-           //imposto come TmpProp1 -> -1 ( non ho facce adiancenti )
+           //imposto come TmpProp1 -> -1 ( non ho facce adiancenti)
             pCrvCompo->SetTempProp( -1, 1) ;
            // sistemazioni varie
             AdjustCurveFromSurf( pCrvCompo, TOOL_ORTHO, FACE_CONT, 0) ;
@@ -1569,7 +1569,6 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
    int nProp0 = -1 ;
    int nProp1 = -1 ;
 
-
    while ( nPathId != GDB_ID_NULL) { // Scorro tutte le curve concatenate per creare la superficie da lavorare
 
       int nPi = m_pGeomDB->GetFirstInGroup( nPathId) ;
@@ -1603,7 +1602,7 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
          INTVECTOR vOpen ;
          m_pGeomDB->GetInfo( nPi, KEY_OPEN, vOpen) ;
          for ( int j : vOpen)
-            pCompoOriCrv->SetCurveTempProp( j, 1, 0) ; // alla sottocurva 
+            pCompoOriCrv->SetCurveTempProp( j, 1, 0) ; // alla sottocurva
       }
 
      // unisco le parti allineate (tranne inizio-fine se chiusa)
@@ -1636,9 +1635,6 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
       pCompoOriCrv->SetTempProp( nProp0, 0) ; // a tutta la curva ( id selezionato )
       pCompoOriCrv->SetTempProp( nProp1, 1) ; // a tutta la curva ( se Trimesh, faccia adiacente )
 
-      //int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompoOriCrv->Clone()) ;
-      //m_pGeomDB->SetMaterial( r, RED) ;
-
      // controllo che le curve siano complanari e con stessa estrusione (la prima come riferimento)
       Plane3d plAct ;
       pCompoOriCrv->IsFlat( plAct) ;
@@ -1670,7 +1666,7 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
       nPathId = m_pGeomDB->GetNextGroup( nPathId) ; // aggiorno il PathId con il successivo nel gruppo
    }
 
-   // creazione della superficie da lavorare completa ( dall'unione di tutte le curve concatenate)
+  // creazione della superficie da lavorare completa ( dall'unione di tutte le curve concatenate)
    PtrOwner<ISurfFlatRegion> pSrfPock( SrfByC.GetSurf()) ;
    if ( IsNull( pSrfPock)  ||  pSrfPock->GetChunkCount() == 0)
       return false ;
@@ -1804,9 +1800,8 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
 
   // verifiche per svuotature dal basso
    m_bAggrBottom = false ;
-   if ( ! VerifyPathFromBottom( pSrfPock, vtTool)) {
-      return false;
-   }
+   if ( ! VerifyPathFromBottom( pSrfPock, vtTool))
+      return false ;
 
   // recupero nome del path
    string sPathName = "P1" ;
@@ -1847,7 +1842,7 @@ Pocketing::ProcessPath( int nAuxId, int nPvId, int nClId)
      // assegno l'elevazione massima
       m_pGeomDB->SetInfo( nPxId, KEY_ELEV, dElev) ;
 
-      // Imposto dati comuni
+     // Imposto dati comuni
       SetPathId( nPxId) ;
       SetToolDir( vtTool) ;
 
@@ -2158,17 +2153,11 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
       if ( IsNull( pSrfChunk))
          return false ;
 
-      // --------------------------------------------------------------------------------------------------------
-      // 1) traslo il chunk c-esimo a seconda dello step e salvo la flat Region interna al grezzo
-      // ( evito di lavorare nel vuoto sempre la stessa faccia )
-      // 2) Proietto il Box del grezzo del semipiano positivo definito della Flat Region ottenuta in precedenza
-      //    allargando in tangenza i lati chiusi fino al bordo di tale proiezione
-      // ( evito di trascurare parti di grezzo nella tasche con normale non parallela alla faccia del grezzo )
-
       ISURFFRPOVECTOR vSrfSliced( nStep) ;
       vector<ICRVCOMPOPOVECTOR> vCrvOEWithFlags( nStep) ;
       BOOLVECTOR vbChangedPrec( nStep, false) ;
      // modifico le superifici in base alla geometria del grezzo
+      // RECUPERO DEL GREZZO -> INTERSEZIONE CON GREZZO -> PROIEZIONE CON GREZZO -> MODIFICA DEI LATI APERTI
       if ( ! GetParamsAtEachStep( vSrfSliced, vCrvOEWithFlags, vbChangedPrec, pSrfChunk,
                                   nStep, vtTool, dElev, dDepth, dStep))
          return false ;
@@ -2200,27 +2189,21 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
             if( IsNull( pSrfLeanInOut))
                return false ;
 
-           // ----------------------------------------------------------------------------------
-             // Dopo che il chunk c-esimo è stato intersecato con il grezzo e allargato grazie alla proiezione,
-             // salvo il bordo ( con i flag dei lati aperti ) per il caso del trapezio ottimizzato.
-             // tuttavia, nel caso di più Chunks, devo individuare la curva originaria relativa al chunk cc-esimo
-             // ... il chunk cc-esimo non può avere parti esterne alla sua curva originaria
-
              int nInd = 0 ; // indice del vettore delle curve esterne relativo al chunk cc-esimo
 
-           // cerco la curva originale del chunk cc-esimo
-            if(( int)vCrvOEWithFlags[j-1].size() == 1)
+           // cerco la curva originale del chunk cc-esimo ( PER CASI OTTIMIZZATI)
+            if (( int)vCrvOEWithFlags[j-1].size() == 1)
                nInd = 0 ;
             else {
-               for( int k = 0 ; k < ( int)vCrvOEWithFlags[j-1].size() ; ++k) {
+               for ( int k = 0 ; k < ( int)vCrvOEWithFlags[j-1].size() ; ++k) {
                   CRVCVECTOR ccClass ;
-                  if( pSrfChunkFinal->GetCurveClassification( *vCrvOEWithFlags[j-1][k], EPS_SMALL, ccClass)) {
+                  if ( pSrfChunkFinal->GetCurveClassification( *vCrvOEWithFlags[j-1][k], EPS_SMALL, ccClass)) {
                      bool bIsThis = true ;
                      for( int kk = 0 ; kk < ( int)ccClass.size()  &&  bIsThis ; ++kk) {
                         if( ccClass[kk].nClass == CRVC_OUT)
                            bIsThis = false ;
                      }
-                     if( bIsThis) {
+                     if ( bIsThis) {
                         nInd = k ;
                         break ;
                      }
@@ -2229,7 +2212,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
             }
            // ------------------------------------------------------------------------------------
 
-           // determino il riferimento in base alla svuotatura ( per poter orientare il frame per m_dSideAngle )
+           // determino il riferimento in base alla svuotatura ( per poter orientare il frame per m_dSideAngle)
             Frame3d frPocket ;
             Point3d ptCen ; pSrfChunkFinal->GetCentroid( ptCen) ;
             frPocket.Set( ptCen, vtExtr) ;
@@ -2252,7 +2235,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
                return false ;
             if ( bOptimizedZigZag  && ! vpCrvs.empty()) {
                // se sono in un caso ottimizzato ...
-                nChunks = 1 ; // fisso il numero di chunk ad 1 per i bordi esterni ( che non verranno percorsi )
+                nChunks = 1 ; // fisso il numero di chunk ad 1 per i bordi esterni ( che non verranno percorsi)
                // verifico se attacco fuori dal grezzo
                 Point3d ptStart ;
                 vpCrvs[0]->GetStartPoint( ptStart) ;
@@ -2270,7 +2253,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
                    vpCrvs[0]->ExtendStartByLen( m_TParams.m_dDiam / 2 - dOptZigZagOffs + dSafeZ) ;
             }
 
-           // se non sono nel caso ottimizzato e ho un utensile che non lavora di testa 
+           // se non sono nel caso ottimizzato e ho un utensile che non lavora di testa
            // poichè ingresso non fuori dal pezzo ... -> errore
             if (( ! bOptimizedZigZag  ||  ! ( bOutRawLeadIn  ||  m_bOpenOutRaw))  &&  m_TParams.m_nType == TT_MILL_NOTIP) {
                if ( ! LeadInRawIsOk()) {
@@ -2292,8 +2275,8 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
 
            // effettuo un secondo Offset per ottenere le curve di contorno per ripulire la svuotatura a ZigZag
            // Questo offset serve per ricavare le curve che l'utensile dovrà percorrere dopo aver svuotato a ZigZag
-           // Curva esterna ( non percorsa nel caso a ZigZag )
-           // Curve interne ( le isole, queste vanno percorse anche nei casi ottimizzati )
+           // Curva esterna ( non percorsa nel caso a ZigZag ottimizzato)
+           // Curve interne ( le isole, queste vanno percorse anche nei casi ottimizzati)
            // Per le curve interne, questo Offset viene sempre fatto ( a prescindere dai casi ottimizzati )
             PtrOwner<ISurfFlatRegion> pSrfForCrv( CloneSurfFlatRegion( pSrfChunkFinal)) ;
             if ( ! pSrfForCrv->Offset( - dOffs, ICurve::OFF_FILLET)) {
@@ -2305,7 +2288,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
             int nChunksForCrv = pSrfForCrv->GetChunkCount() ;
 
            // Avendo effettuato due Offsets ( -dOffs-dExtra e -dOffs ) non è detto che il numero di Chunks tra le nuove
-           // superifici sia uguale... Inizio a scorre i chunks della superficie per le curve di contorno e, 
+           // superifici sia uguale... Inizio a scorre i chunks della superficie per le curve di contorno e,
            // per ognuna di esse, cerco il/i Chunck per il percorso a ZigZag contenuti.
             for ( int cfc = 0 ; cfc < nChunksForCrv ; ++ cfc) { // scorro i chunk della superificie per i bordi
                for ( int cfz = 0 ; cfz < nChunks ; ++ cfz) { // scorro i chunk della superificie per i percorsi ZigZag
@@ -2323,7 +2306,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
                            return false ;
                      }
                     // se la regione non è dentro alla curva esterna allora la ignoro
-                    // ( la ritroverò interna ad un'altra curva per i bordi successivamante o l'ho già considerata in precedenza )
+                    // ( la ritroverò interna ad un'altra curva per i bordi successivamante o l'ho già considerata in precedenza)
                      else
                         continue ;
                   }
@@ -2427,7 +2410,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
                               &&  ( int)vpCrvs.size() == 1  &&  bOptimizedZigZag)) {
                                  if ( ! AddLinkApproach( ptP1, vtTool, dSafeZ, dSafeAggrBottZ, dStElev, dAppr, bOutRawLeadIn || m_bOpenOutRaw)) {
                                     m_pMchMgr->SetLastError( 2418, "Error in Pocketing : Link not computable") ;
-                                    return false;
+                                    return false ;
                                  }
                               }
                      
@@ -2446,7 +2429,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
                         double dFeed = pCurve->GetTempProp( 0) / FEED_DIVISOR < dMinFeed - 50 * EPS_SMALL ?
                                        GetFeed() : pCurve->GetTempProp( 0) / FEED_DIVISOR ;
                         SetFeed( dFeed) ;
-                        DrawColoredCrvForFeedTest( pCurve, dFeed) ;
+                        //DrawColoredCrvForFeedTest( pCurve, dFeed) ;
                         if ( pCurve->GetType() == CRV_LINE) {
                            ICurveLine* pLine = GetCurveLine( pCurve) ;
                            Point3d ptP3 = pLine->GetEnd() ;
@@ -2518,16 +2501,13 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
                   continue ;
 
               // Una volta percorse le curve di ZigZag devo aggiungere le curve per il bordo
-
               // creo un vettore con tutti i loop formati, aggiustando i loro punti iniziali e portandoli nel frame della svuotatura
               // NB. se sono in un caso ottimizzato uso solo i loop interni
                ICRVCOMPOPOVECTOR vAllCrv ;
-               for ( int l = bOptimizedZigZag ? 1 : 0 ; l < pSrfForCrv->GetLoopCount( cfc) ; ++ l) {
+               for ( int l = bOptimizedZigZag ? 1 : 0 ; l < pSrfForCrv->GetLoopCount( cfc) ; ++ l)
                   vAllCrv.emplace_back( GetCurveComposite( pSrfForCrv->GetLoop( cfc, l))) ;
-               }
 
               // Sistemo i punti iniziali per i nuovi Chunks ------------------------------------------
-
                VCT3DVECTOR vVtMidOut(( int) vAllCrv.size(), V_NULL) ;
                BOOLVECTOR vbMidOut(( int) vAllCrv.size(), false) ;
                PNTVECTOR vPtStart(( int) vAllCrv.size(), Point3d( 0,0,0)) ;
@@ -2598,7 +2578,7 @@ Pocketing::AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
               // -------------------------------------------------------------------------------
 
               // ---------------------------- Disegno le curve di contorno ----------------------
-               for ( int u = 0 ; u < int( vAllCrv.size()) ; ++ u) { // percorro tutte le curve ( ordinate )
+               for ( int u = 0 ; u < int( vAllCrv.size()) ; ++ u) { // percorro tutte le curve ( ordinate)
 
                   // recupero la prima curva di offset disponibile 
                    PtrOwner<ICurveComposite> pOffs( CreateCurveComposite());
@@ -2946,11 +2926,10 @@ Pocketing::CalcZigZag( const ISurfFlatRegion* pSrfZigZag, ICRVCOMPOPOVECTOR& vpC
           if ( ! vpCrvs.back()->TrimEndAtParam( dUS_Link))
              vpCrvs.back()->Clear() ;
 
-          //AssignFeedZigZagLink( pCrvLink) ; // assegno la Feed al Link
           if ( ! AssignFeedZigZagOneWay( pCrvLink, true, vLineAbove, vLineUnder, vAddedLinks))
              return false ;
 
-          vpCrvs.back()->AddCurve( pCrvLink->Clone()) ; // aggiungo il Link
+          vpCrvs.back()->AddCurve( pCrvLink->Clone()) ;  // aggiungo il Link
           vpCrvs.back()->AddCurve( pSeg2->Clone()) ;     // aggiungo pSeg2
 
          // aggiorno il vettore dei Link ( nel caso sia un link tra due segmenti sullo stesso livello )
@@ -3229,7 +3208,6 @@ Pocketing::CalcZigZagLink( ICurveComposite* pCrv1, ICurveComposite* pCrv2, ICurv
    }
    else {
       // DEVO SMUSSARE LA CURVA FORMATA DA pCrv1 - pCrvLink ( da creare) - pCrv2
-
       pCrvH1->AddCurve( pCrv1->Clone()) ;
       pCrvH2->AddCurve( pCrv2->Clone()) ;
       pCrvTempLink->AddCurve( pCrvLink->Clone()) ;
@@ -3366,7 +3344,7 @@ Pocketing::OptimizedZigZag( ISurfFlatRegion* pSrf, const Vector3d& vtTool, doubl
    case 3 : // 3 lati CHIUSI
       ZigZagOptimizedThreeClosedEdges( pCrvPocket, vnInfoClosed, bOptimizedZigZag, bTwoOpposite, vtDir, dOffs) ;
       break ;
-   default : // nessuna ottimizzazione... 
+   default : // nessuna ottimizzazione...
       bOptimizedZigZag = false ;
       break ;
    }
@@ -3640,7 +3618,7 @@ Pocketing::ZigZagOptimizedTwoClosedEdges( ICurveComposite* pCrvPocket, const INT
 }
 
 //------------------------------------------------------------------
-bool 
+bool
 Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const INTVECTOR& vnClosedIds, bool& bOptimizedZigZag,
                                             bool& bOpposite, Vector3d& vtDir,double& dOffs)
 {
@@ -3693,7 +3671,6 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I
       pCrv3->GetStartDir( vtDir) ;
       bOpposite = true ;
    }
-   
 
   // aggiorno pCrvPocket con eventuale offset per regioni residue
    if ( ! ZigZagOptimizedComputeOffset( pCrvPocket, vtDir, 1, vnClosedIds, dOffs))
@@ -3740,7 +3717,6 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I
    // ricavo la Thickness
     double dThick ; pCrvPocket->GetThickness( dThick) ;
 
-
    // aggiusto offset
     dOffs = m_TParams.m_dDiam / 2 + 5 * EPS_SMALL ;
     double dMinOffs = max( 0., 0.5 * m_TParams.m_dDiam - m_Params.m_dSideStep) ;
@@ -3756,7 +3732,7 @@ Pocketing::ZigZagOptimizedThreeClosedEdges( ICurveComposite* pCrvPocket, const I
        if ( OffsCrv.GetCurveCount() > 1)
           return false ;
  
-      // aggiorno pCrvPocket 
+      // aggiorno pCrvPocket
        pCrvPocket->Clear() ;
        pCrvPocket->AddCurve( OffsCrv.GetCurve()) ;
        pCrvPocket->SetExtrusion( vtExtr) ;
@@ -3875,7 +3851,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
       ISURFFRPOVECTOR vSrfSliced( nStep) ;
       vector<ICRVCOMPOPOVECTOR> vCrvOEWithFlags( nStep) ;
       BOOLVECTOR vbChangedPrec( nStep, false) ;
-     for ( int j = 1 ; j <= nStep ; ++ j) {
+      for ( int j = 1 ; j <= nStep ; ++ j) {
         // controllo l'intersezione/proiezione tra la superificie e il grezzo
          PtrOwner<ICurveComposite> pCrvOPF( CreateCurveComposite()) ;
          Vector3d vtTrasl = -vtTool * ( dDepth - dElev + j * dStep) ;
@@ -3907,7 +3883,6 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
          }
       }
 
-
       Point3d ptP1 ;
       for ( int j = 1 ; j <= nStep ; ++ j) {
 
@@ -4042,19 +4017,6 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
         if ( ! OrderCurvesByLastPntOfPath( vAllCrv, ptStart, vPtStart, vVtMidOut, vbMidOut, vbForcedOutStart))
            return false ;
 
-        // -------------------------------------------------------------------------------
-
-        // coefficiente di riduzione feed di lavorazione di questa curva
-         //double dFeedRid = min( GetSideStep() / m_TParams.m_dDiam, 1.0) ;
-
-        // creo la superificie svuotata ( per Feed )
-         //PtrOwner<ISurfFlatRegion> pSrfRemoved( CreateSurfFlatRegion()) ;
-         //if ( IsNull( pSrfRemoved))
-         //   return false ;
-         //for ( int u = 0 ; u < vAllCrv.size() ; ++ u)
-         //   GetDynamicClearedRegion( pSrfRemoved, vAllCrv[u]) ;
-
-
         // ---------------------------- Disegno le curve di contorno ----------------------
          for ( int u = 0 ; u < int( vAllCrv.size()) ; ++ u) { // percorro tutte le curve ( ordinate )
 
@@ -4142,7 +4104,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
                double dMinFeed = GetFeed() * GetSideStep() / m_TParams.m_dDiam ;
                double dFeed = pCurve->GetTempProp( 0) / FEED_DIVISOR < dMinFeed - 50 * EPS_SMALL ?
                               GetFeed() : pCurve->GetTempProp( 0) / FEED_DIVISOR ;
-               DrawColoredCrvForFeedTest( pCurve, dFeed) ;
+               //DrawColoredCrvForFeedTest( pCurve, dFeed) ;
                SetFeed( dFeed) ;
                if ( pCurve->GetType() == CRV_LINE) {
                   ICurveLine* pLine = GetCurveLine( pCurve) ;
@@ -4330,7 +4292,7 @@ Pocketing::AddOneWay( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, c
                      //   int verde = m_pGeomDB->AddGeoObj(GDB_ID_NULL, GDB_ID_ROOT, pCrv_TestFeed->Clone()) ;
                      //   m_pGeomDB->SetMaterial( verde, GREEN) ;
                      //}
-                     SetFeed( dFeed) ;
+                     //SetFeed( dFeed) ;
                      //SetFeed( GetFeed()) ;
                      if ( AddLinearMove( ptE) == GDB_ID_NULL)
                         return false ;
@@ -4402,13 +4364,8 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
       if ( IsNull( pSrfChunk))
          return false ;
 
-     // --------------------------------------------------------------------------------------------------------
-     // 1) traslo il chunk c-esimo a seconda dello step e salvo la flat Region interna al grezzo
-     // ( evito di lavorare nel vuoto sempre la stessa faccia )
-     // 2) Proietto il Box del grezzo del semipiano positivo definito della Flat Region ottenuta in precedenza
-     //    allargando in tangenza i lati chiusi fino al bordo di tale proiezione
-     // ( evito di trascurare parti di grezzo nella tasche con normale non parallela alla faccia del grezzo )
-
+     // modifico le superifici in base alla geometria del grezzo
+      // RECUPERO DEL GREZZO -> INTERSEZIONE CON GREZZO -> PROIEZIONE CON GREZZO -> MODIFICA DEI LATI APERTI
       ISURFFRPOVECTOR vSrfSliced( nStep) ;
       vector<ICRVCOMPOPOVECTOR> vCrvOEWithFlags( nStep) ;
       BOOLVECTOR vbChangedPrec( nStep, false) ;
@@ -4417,7 +4374,6 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
                                   nStep, vtTool, dElev, dDepth, dStep))
          return false ;
 
-      return false ;
       Point3d ptP1 ; // per LeadIn
 
      // ciclo su tutti gli step
@@ -4438,7 +4394,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
            // il numero di chunk dopo aver intersecato e proiettato con/il grezzo può cambiare
            
            // essendo una svuotatura a spirale, facendo il primo offset del chunk cc-esimo potrei ottenere
-           // ulteriori chunks ( ad esempio se la superificie presenta delle parti molto strette )
+           // ulteriori chunks ( ad esempio se la superificie presenta delle parti molto strette)
            // MAX_REGS = 50 -> # massimo di Chunks nuovi accettati
             const int MAX_REGS = 50 ;
             int nReg = 0 ; // chunk nuovo corrente da svuotare
@@ -4474,12 +4430,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
          
                bool bOptimizedTrap = false ;
 
-              // ----------------------------------------------------------------------------------
-              // Dopo che il chunk c-esimo è stato intersecato con il grezzo e allargato grazie alla proiezione,
-              // salvo il bordo ( con i flag dei lati aperti ) per il caso del trapezio ottimizzato.
-              // tuttavia, nel caso di più Chunks, devo individuare la curva originaria relativa al chunk cc-esimo
-              // ... il chunk cc-esimo non può avere parti esterne alla sua curva originaria
-
+              // cerco la curva originale del chunk cc-esimo ( PER CASI OTTIMIZZATI)
                int nInd = 0 ; // indice del vettore delle curve esterne relativo al chunk cc-esimo
 
               // cerco la curva originale del chunk cc-esimo
@@ -4494,7 +4445,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
                            if ( ccClass[kk].nClass == CRVC_OUT)
                               bIsThis = false ;
                         }
-                        if( bIsThis) {
+                        if ( bIsThis) {
                            nInd = k ;
                            break ;
                         }
@@ -4502,7 +4453,6 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
                   }
                }
 
-
               // ------------------------------------------------------------------------------------
 
                Point3d ptStart ;    // punto iniziale del percorso
@@ -4510,10 +4460,6 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
                bool bMidOut ;       // ammissibilità entrata da fuori
                int nRegTot = nReg ;
 
-
-               //int k = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfChunkFinal->Clone()) ;
-               //m_pGeomDB->SetMaterial( k, WHITE) ;
-
               // calcolo il percorso di svuotatura
               if ( ! CalcSpiral( pSrfChunkFinal, nRegTot, ptStart, vtMidOut, bMidOut, bSplitArcs, pMCrv, pRCrv, vCrvOEWithFlags[j-1][nInd], bOptimizedTrap))
                   return false ;
@@ -4574,7 +4520,6 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
                bool bForcedOutStart = ( bMidOut &&  m_bOpenOutRaw) ;
          
               // se utensile che non lavora di testa e ingresso non fuori dal pezzo, errore
-               //if ( m_TParams.m_nType == TT_MILL_NOTIP  &&  ! bOutStart  &&  ! bForcedOutStart) {
                if ( m_TParams.m_nType == TT_MILL_NOTIP  &&  ! ( bOutStart  ||  bForcedOutStart)) {
                   if ( ! LeadInRawIsOk()) {
                      m_pMchMgr->SetLastError( 2431, "Error in Pocketing : LeadIn with Mill NoTip in material") ;
@@ -4585,7 +4530,7 @@ Pocketing::AddSpiralIn( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool,
                int nMaxInd = pMCrv->GetCurveCount() - 1 ;
                int nMaxRInd = pRCrv->GetCurveCount() - 1 ;
          
-              // se sono nel caso ottimizzato e ho attacco e uscita entrambi dentro/fuori dal grezzo, 
+              // se sono nel caso ottimizzato e ho attacco e uscita entrambi dentro/fuori dal grezzo,
               // ad ogni step pari inverto la direzione della curva solamente se ho un solo chunk e la superificie successiva
               // non è cambiata
                if ( bOptimizedTrap  &&  nOutsideRaw != 1  &&  j > 1  &&  vSrfSliced[j-2]->GetChunkCount() == 1  &&  ! vbChangedPrec[j-1]
@@ -4775,11 +4720,12 @@ Pocketing::AddSpiralOut( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool
       if ( IsNull( pSrfChunk))
          return false ;
 
-     // --------------------------------------------------------------------------------------------------------
+     // modifico le superifici in base alla geometria del grezzo
+      // RECUPERO DEL GREZZO -> INTERSEZIONE CON GREZZO -> PROIEZIONE CON GREZZO -> MODIFICA DEI LATI APERTI
       ISURFFRPOVECTOR vSrfSliced( nStep) ;
       vector<ICRVCOMPOPOVECTOR> vCrvOEWithFlags( nStep) ;
       BOOLVECTOR vbChangedPrec( nStep, false) ;
-     // modifico le superifici in base alla geometria del grezzo
+
       if ( ! GetParamsAtEachStep( vSrfSliced, vCrvOEWithFlags, vbChangedPrec, pSrfChunk,
                                   nStep, vtTool, dElev, dDepth, dStep))
          return false ;
@@ -4837,7 +4783,7 @@ Pocketing::AddSpiralOut( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool
 
                int nInd = 0 ;
 
-              // cerco la curva originale del chunk cc-esimo
+              // cerco la curva originale del chunk cc-esimo ( PER CASI OTTIMIZZATI)
                if (( int)vCrvOEWithFlags[j-1].size() == 1)
                   nInd = 0 ;
                else {
@@ -4980,7 +4926,7 @@ Pocketing::AddSpiralOut( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool
                   double dMinFeed = GetFeed() * GetSideStep() / m_TParams.m_dDiam ;
                   double dFeed = pCurve->GetTempProp( 0) / FEED_DIVISOR < dMinFeed - 50 * EPS_SMALL ?
                                  GetFeed() : pCurve->GetTempProp( 0) / FEED_DIVISOR ;
-                  DrawColoredCrvForFeedTest( pCurve, dFeed) ;
+                  //DrawColoredCrvForFeedTest( pCurve, dFeed) ;
                   SetFeed( dFeed) ;
                   if ( pCurve->GetType() == CRV_LINE) {
                      ICurveLine* pLine = GetCurveLine( pCurve) ;
@@ -5164,8 +5110,8 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
      // salvo la regione
       pSrfPrec.Set( pSrfAct->Clone()) ;
       if ( ! pSrfAct->Offset( - dOffs, ICurve::OFF_FILLET)) {
-        int nbadOffs = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfPrec->Clone()) ;
-        m_pGeomDB->Save( nbadOffs, "C:\\Users\\riccardo.elitropi\\Desktop\\Err_offs" + ToString( nbadOffs) + "__m" + ToString( dOffs) + ".nge") ;
+        //int nbadOffs = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfPrec->Clone()) ;
+        //m_pGeomDB->Save( nbadOffs, "C:\\Users\\riccardo.elitropi\\Desktop\\Err_offs" + ToString( nbadOffs) + "__m" + ToString( dOffs) + ".nge") ;
         return false ;
       }
 
@@ -5228,7 +5174,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
       dOffR = dTRad + GetOffsR() ;
    else
       dOffR = dOffs ;
-   
+
    if ( SetBetterPtStartForSubChunks( vOffs[0], pSrfToWork, ptStart, vtMidOut, bMidOut, dOffR))
       vOffs[0]->GetStartPoint( ptNewStart) ;
    else 
@@ -5299,7 +5245,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
          vOffs[nClosestInd].Set( ptoCCHelp) ;
       }
 
-         // 2) cambio il suo punto iniziale ... 
+         // 2) cambio il suo punto iniziale ...
       double dU ;
       Point3d ptNE( ptHelp.x, ptHelp.y, ptHelp.z) ;
       if ( ! vOffs[i + 1]->GetParamAtPoint( ptNE, dU))
@@ -5307,7 +5253,7 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
       vOffs[i + 1]->ChangeStartPoint( dU) ;
 
         // 2.1) Accorcio la curva per velocizzare ...
-      if(( int)vOffs.size() > 1) { // accorcio se ho almeno due Offset
+      if (( int)vOffs.size() > 1) { // accorcio se ho almeno due Offset
         // copio le curve i e i+1 nel caso non riesca a tagliarle ...
          double dUNS, dUNE ;
          PtrOwner<ICurveComposite> pCrvTest( CreateCurveComposite()) ; // possibile collegamento tra la curva i ed i+1
@@ -5340,18 +5286,17 @@ Pocketing::CalcSpiral( const ISurfFlatRegion* pSrfPock, int& nReg, Point3d& ptSt
         // imposto il nuovo punto inziale della curva successiva
          vOffs[i+1]->ChangeStartPoint( dUNE) ;
          PtrOwner<ICurveComposite> pCrvNewOffS( CloneCurveComposite( vOffs[i])) ;
-         if( dUNS > EPS_SMALL) { // se parametro di trim sufficientemente grande 
+         if ( dUNS > EPS_SMALL) { // se parametro di trim sufficientemente grande 
             pCrvNewOffS.Set( GetCurveComposite( vOffs[i]->CopyParamRange( 0, dUNS))) ;
            // sostituisco la curva i-esima con quella tagliata
             vOffs[i]->Clear() ;
             vOffs[i].Set( pCrvNewOffS) ;
          }
-         // aggiorno il collegamento
+        // aggiorno il collegamento
          vLinks[i + 1].Set( pCrvTest) ;
       }
    }
 
-
   // copio il vettore degli Offset per settare poi la Feed
    ICRVCOMPOPOVECTOR vOffsFeed ; vOffsFeed.reserve(( int)vOffs.size()) ;
    for ( int i = 0 ; i < ( int)vOffs.size()  ; ++ i)
@@ -5542,15 +5487,15 @@ Pocketing::ModifyCurveToSmoothed( ICurveComposite* pCrv, double dRightPer, doubl
          }
 
       }
-      if ( IsNull( pCrvArc)  ||  ! pCrvArc->IsValid()) { // se ancora non riesco... salto l'arco
-         vCrvArcs.emplace_back( CreateCurveArc()) ;    // arco nullo
-         vArcsToJump.push_back( i) ;                   // da scartare
+      if ( IsNull( pCrvArc)  ||  ! pCrvArc->IsValid()) {    // se ancora non riesco... salto l'arco
+         vCrvArcs.emplace_back( CreateCurveArc()) ;         // arco nullo
+         vArcsToJump.push_back( i) ;                        // da scartare
          continue ;
       }
 
      // se ho creato l'arco lo memorizzo
-      vCrvArcs.emplace_back( Release( pCrvArc)) ;      // arco valido
-      vArcsToJump.push_back( -1) ;                     // da considerare
+      vCrvArcs.emplace_back( Release( pCrvArc)) ;           // arco valido
+      vArcsToJump.push_back( -1) ;                          // da considerare
    }
 
   // creo la curva che restituirò
@@ -5628,7 +5573,7 @@ Pocketing::ModifyCurveToSmoothed( ICurveComposite* pCrv, double dRightPer, doubl
          return false ;
    }
 
-  // ripristino il punto inziale  se la curva è chiusa 
+  // ripristino il punto inziale  se la curva è chiusa
    double dNewDU ;
    if ( ! pCrv->IsClosed()) {
       if ( ! pCrvCO_temp->GetParamAtPoint( ptArcHelp, dNewDU))
@@ -5680,7 +5625,6 @@ Pocketing::CutCurveToConnect( ICurveComposite* pCrvS, ICurveComposite* pCrvE, IC
          dLenPercE = 0 ;
    }
 
-
    double dLStepS = dLenPercS * dLenS ;
    double dLStepE = dLenPercE * dLenE ;
    dLenE = 0 ;
@@ -5772,7 +5716,7 @@ Pocketing::RemoveExtraParts( ISurfFlatRegion* pSrfToCut, ICRVCOMPOPOVECTOR& vOff
       int nOptFlag = 0 ;
 
      // ricavo il flag
-     // ptGoTo è il centroide, pCrvPath è la curva da seguire per svuotare la regione ( nel caso non basi il centroide )
+     // ptGoTo è il centroide, pCrvPath è la curva da seguire per svuotare la regione ( nel caso non bastasse il centroide)
       if ( ! RemoveExtraPartByMedialAxis( pSrfChunkToCut, vOffsFirstCurve, nOptFlag, ptGoTo, pCrvPath)  || 
          nOptFlag == 0)
          continue ;
@@ -5783,7 +5727,7 @@ Pocketing::RemoveExtraParts( ISurfFlatRegion* pSrfToCut, ICRVCOMPOPOVECTOR& vOff
             continue ;
 
      // una volta trovata la curva di medial Axis ( se la regione non si svuota semplicemente passando per il
-     // centroide, controllo in quale direzione è più conveniente percorrerla ... ( I = Inverso )
+     // centroide, controllo in quale direzione è più conveniente percorrerla ... ( I = Inverso)
       PtrOwner<ICurveComposite> pCrvH1( CreateCurveComposite()) ;
       PtrOwner<ICurveComposite> pCrvH2( CreateCurveComposite()) ;
       PtrOwner<ICurveComposite> pCrvH1I( CreateCurveComposite()) ;
@@ -5802,12 +5746,12 @@ Pocketing::RemoveExtraParts( ISurfFlatRegion* pSrfToCut, ICRVCOMPOPOVECTOR& vOff
             continue ;
 
       // A) SE IL PUNTO PIU' VICINO E' SU UN ESTREMO DELL'OFFSET... -> Cerco un punto sui collegamenti
-      // ( controllo solo i punti trovati sugli offset mediante Medial Axis non invertiti )
+      // ( controllo solo i punti trovati sugli offset mediante Medial Axis non invertiti)
       if ( IsNull( pCrvH1)  ||  IsNull( pCrvH2)  ||  pCrvH1->GetCurveCount() == 0  ||  pCrvH2->GetCurveCount() == 0) {
          bool bFound, bFoundI ; int nIndexL, nIndexLI ;
          if ( ! CutLinkToClosestPoint( vLinks, vOffs, ptGoTo, pCrvH1, pCrvH2, bFound, nIndexL))
             continue ;
-         if( nOptFlag == 2) { // nel caso curva di Medial Axis, controllo anche nel caso invertito
+         if ( nOptFlag == 2) { // nel caso curva di Medial Axis, controllo anche nel caso invertito
             if ( ! CutLinkToClosestPoint( vLinks, vOffs, ptGoToI, pCrvH1I, pCrvH2I, bFoundI, nIndexLI))
                continue ;
          }
@@ -5882,7 +5826,6 @@ Pocketing::RemoveExtraParts( ISurfFlatRegion* pSrfToCut, ICRVCOMPOPOVECTOR& vOff
             if ( ! GetNewCurvetWithPath( pCrvH1I, pCrvH2I, pCrvPathI, vOffsFirstCurve, vOffsClosedCurves, ptCrvNewOffsI))
                bSuccI = false ;
 
-
             int nC = 0 ; // se entrambi i percorsi sono validi allora li confronto
             if ( bSucc && bSuccI) {
                if ( ChoosePath( ptCrvNewOffs, ptCrvNewOffsI, 0, 0.5, 5 * 1000 * EPS_SMALL, nC)  &&  nC == 1) {
@@ -5983,7 +5926,7 @@ Pocketing::ChoosePath( const ICurveComposite* pCrv1, const ICurveComposite* pCrv
    }
    
   // ------------- rotazioni --------------
-   double dRot1 = 0 ; double dRot2 = 0 ; 
+   double dRot1 = 0 ; double dRot2 = 0 ;
    if ( ! GetCurveWeightInfo( pCrv1, dMaxLen, dRot1, dSmallArcs1, dSmallLines1)  ||
       ! GetCurveWeightInfo( pCrv2, dMaxLen, dRot2, dSmallArcs2, dSmallLines2))
       return false ;
@@ -5991,7 +5934,7 @@ Pocketing::ChoosePath( const ICurveComposite* pCrv1, const ICurveComposite* pCrv
    double CR1, CR2 ; // rapporto tra la somma de rotazione degli angoli correnti e quella massima
 
    if ( dRot1 == 0  &&  dRot2 == 0) {
-      CR1 = 0 ; 
+      CR1 = 0 ;
       CR2 = 0 ;
    }
    else {
@@ -6009,7 +5952,7 @@ Pocketing::ChoosePath( const ICurveComposite* pCrv1, const ICurveComposite* pCrv
 }
 
 //---------------------------------------------------------------------------
-bool 
+bool
 Pocketing::CutOffsetToClosestPoint( ICRVCOMPOPOVECTOR& vCurves, const Point3d& ptFocus,
                                      ICurveComposite* pCrv1, ICurveComposite* pCrv2, int& nIndex)
 {
@@ -6083,7 +6026,7 @@ Pocketing::CutLinkToClosestPoint( ICURVEPOVECTOR& vCurves, ICRVCOMPOPOVECTOR& vO
    for ( int j = 0 ; j < int( vCurves.size()) ; ++ j) {
      
      // escludo i links nulli ...
-      if( IsNull( vCurves[j]))
+      if ( IsNull( vCurves[j]))
          continue ;
 
      // distanza minima tra link e curva
@@ -6100,7 +6043,7 @@ Pocketing::CutLinkToClosestPoint( ICURVEPOVECTOR& vCurves, ICRVCOMPOPOVECTOR& vO
    }
 
   // se non ho trovato nulla, esco
-   if( nIndex < 0)
+   if ( nIndex < 0)
       return false ;
 
   // ricavo le due curve ( il link viene spezzato in due sottocurve mediante il punto trovato )
@@ -6190,7 +6133,7 @@ Pocketing::GetNewCurvetWithCentroid( const ICurveComposite* pCrvH1, const ICurve
 
      // creo i due Biarchi
       if ( ! CalcBoundedSmootedLink( ptS, vtTanS, ptE, vtTanS, 0.5, VFirstOff, pPath1)  
-         || ! CalcBoundedSmootedLink( ptE, vtTanS, ptS, vtTanS, 0.5, VFirstOff, pPath2))
+           || ! CalcBoundedSmootedLink( ptE, vtTanS, ptS, vtTanS, 0.5, VFirstOff, pPath2))
          return false ;
 
      // Assegno la Feed a queste nuove curve
@@ -6235,7 +6178,7 @@ Pocketing::GetNewCurvetWithPath( const ICurveComposite* pCrvH1,  const ICurveCom
          ! pCrvH2->GetStartDir( vtTanS))
          return false ;
    }
-   else { 
+   else {
       if ( ! pCrvH1->GetEndPoint( ptS)  ||
          ! pCrvH1->GetEndDir( vtTanS))
          return false ;
@@ -6338,7 +6281,7 @@ Pocketing::ManageSmoothAndAutoInters( ICurveComposite* pCrv, ICurveComposite* pC
   // check AutoIntersezioni...
    SelfIntersCurve SICrv( *pCrv) ;
    if ( SICrv.GetCrossOrOverlapIntersCount() > 0) { // se ci sono autointersezioni
-      
+
       Vector3d vTanE ; Point3d ptHS ;
       pCrvPath->GetEndDir( vTanE) ;
       pCrvPath->GetEndPoint( ptHS) ;
@@ -6379,7 +6322,6 @@ Pocketing::ManageSmoothAndAutoInters( ICurveComposite* pCrv, ICurveComposite* pC
          pPath2->GetParamAtPoint( ptELine1, dUS) ;
          PtrOwner<ICurveComposite> pNewPath2( GetCurveComposite( pPath2->CopyParamRange( dUS, dUE))) ;
 
-
        // creo la curva formata dai due segmenti ma smussati tra loro...
          PtrOwner<ICurveComposite> pCrvTwoSeg( CreateCurveComposite()) ;
          if ( ! pCrvTwoSeg->AddCurve( pCrvPath->Clone())  ||
@@ -6661,12 +6603,6 @@ Pocketing::RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRV
          if ( ! CalcBoundedLink( ptEOriginal, ptSOriginal, vOffsFirstCurve, pCrvCoBackLink))
             return false ;
 
-  // creo un percorso chiuso ...
-   //PtrOwner<ICurveComposite> pCrvPathClosed( CloneCurveComposite( pCrvPath)) ;
-   //if ( IsNull( pCrvPathClosed))
-   //   return false ;
-   //pCrvPathClosed->AddCurve( pCrvCoBackLink->Clone()) ; // percorso chiuso con tutti i medial Axis Collegati
-
   // se ho trovato dei centroidi li unisco nei punti più vicini a questo percorso
    for ( int i = 0 ; i < int( vPtCentroid.size()) ; ++ i) {
 
@@ -6680,10 +6616,10 @@ Pocketing::RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRV
          return false ;
 
       PtrOwner<ICurveComposite> pCrvA( GetCurveComposite( pCrvPath->CopyParamRange( 0, dU))) ;
-      if( IsNull( pCrvA))
+      if ( IsNull( pCrvA))
          return false ;
       PtrOwner<ICurveComposite> pCrvB( GetCurveComposite( pCrvPath->CopyParamRange( dU, pCrvPath->GetCurveCount()))) ;
-      if( IsNull( pCrvB))
+      if ( IsNull( pCrvB))
          return false ;
 
      // 3) prendo il vettore tangente al percorso nel punto trovato nel pCrvPath
@@ -6710,7 +6646,7 @@ Pocketing::RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRV
    // la curva resitituita è una curva aperta che ha come primo punto il punto iniziale del primo medialAxis
    // la curva restituita collega tutti i medial Axis tra di loro
    // la curva restitutita collega tutti i centroidi con delle circonferenze
-   // la curva restituita ha come punto finale l'ultimo punto dell'ultimo medial Axis 
+   // la curva restituita ha come punto finale l'ultimo punto dell'ultimo medial Axis
 
    return true ;
 }
@@ -6718,7 +6654,7 @@ Pocketing::RemoveExtraPartByMedialAxis( const ISurfFlatRegion* pChunkToCut, ICRV
 //----------------------------------------------------------------------------
 bool
 Pocketing::CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCOMPOPOVECTOR& vOffIslands, ICurveComposite* pCrvLink)
-{  
+{
    pCrvLink->Clear() ;
 
   // recupero il vettore estrusione dal bordo esterno offsettato della superficie
@@ -6729,7 +6665,7 @@ Pocketing::CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCO
    Frame3d frLoc ;
    frLoc.Set( ORIG, vtExtr) ;
 
-  // non serve collegare (può capitare nel tagliare percorsi con isole complesse)
+  // non serve collegare ( può capitare nel tagliare percorsi con isole complesse)
    if ( AreSamePointApprox( ptStart, ptEnd))
       return true ;
 
@@ -6804,7 +6740,7 @@ Pocketing::CalcBoundedLink( const Point3d& ptStart, const Point3d& ptEnd, ICRVCO
       pCompo->AddCurve( pCompoHelp->Clone()) ;
 
    }
-   
+
   // riporto pCompo nel sistema di riferimento originale
    if ( ! pCompo->LocToLoc( frLoc, GLOB_FRM))
       return false ;
@@ -6984,7 +6920,7 @@ Pocketing::ModifyBiArc( ICurve* pBiArcLink, double dToll, ICurveComposite* pNewB
 }
 
 //------------------------------------------------------------------------------
-bool 
+bool
 Pocketing::CutCurveByOffsets( ICurveComposite* pCurve, ICRVCOMPOPOVECTOR& vOffs) {
 
   // controllo parametri ingresso
@@ -7135,8 +7071,8 @@ Pocketing::CalcBoundedLinkWithBiArcs( const Point3d& ptStart, const Vector3d& vt
       vtDir2.GetAngleXY( X_AX, dAng2) ;
 
       pCompo->AddCurve( GetBiArc( ptStart, -dAngStart, ptMinDist1, -dAng1, 0.5)) ;     // primo biarco
-      pCompo->AddCurve( pCrvBound->CopyParamRange( dPar1, dPar2)) ;                 // tratto di pCrvBound
-      pCompo->AddCurve( GetBiArc( ptMinDist2, -dAng2, ptEnd, -dAngEnd, 0.5)) ;      // secondo biarco
+      pCompo->AddCurve( pCrvBound->CopyParamRange( dPar1, dPar2)) ;                    // tratto di pCrvBound
+      pCompo->AddCurve( GetBiArc( ptMinDist2, -dAng2, ptEnd, -dAngEnd, 0.5)) ;         // secondo biarco
 
       pCrvLink->AddCurve( Release( pCompo)) ;
    }
@@ -7793,7 +7729,7 @@ Pocketing::ComputeTrapezoidSpiralLeadInLeadOut( ICurveComposite* pCompo, const V
       Vector3d vtNorm ;
       //if ( ! CalcDistanceFromRawSurface( m_nPhase, ptP, vtDirP, dDist, vtNorm))
       //   return false ;
-      if( ! GetSignedDistFromStmRaw( m_nPhase, ptP, vtDirP, dDist, vtNorm))
+      if ( ! GetSignedDistFromStmRaw( m_nPhase, ptP, vtDirP, dDist, vtNorm))
          return false ;
       if ( abs( dDist) < EPS_SMALL) {
          ptP -= vtDirP ;
@@ -7981,7 +7917,7 @@ bool
 Pocketing::AddEpicycles( ICurveComposite* pCompo, ICurveComposite * pCrv, ICurveComposite * pCrvBound)
 {
    if ( m_Params.m_bInvert)
-      pCompo->Invert() ;    // oriento la curva in senso antiorario 
+      pCompo->Invert() ;    // oriento la curva in senso antiorario
 
    OffsetCurve OffsCrv ;
    double dOffs = m_Params.m_dEpicyclesRad ;
@@ -8492,9 +8428,6 @@ Pocketing::GetParamOnOpenSide( const ICurveComposite* pCompo, const ICRVCOMPOPOV
                                     Point3d& ptMid, Vector3d& vtMidOrt)
 {
 
-   //int Y = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCompo->Clone()) ;
-   //m_pGeomDB->SetMaterial( Y, YELLOW) ;
-
   // recupero il vettore estrusione
    Vector3d vtExtr = Z_AX ;
    pCompo->GetExtrusion( vtExtr) ;
@@ -8650,57 +8583,59 @@ Pocketing::AdjustContourWithOpenEdges( ICurveComposite* pCompo, ICRVCOMPOPOVECTO
          }
          int nCrv_offs = OffsCrv.GetCurveCount() ;
          if ( nCrv_offs == 0) {
-             // determino la curva ad amo
-               Point3d ptEnd ; vpCrvs[i-1]->GetEndPoint( ptEnd) ;
-               Vector3d vtTg ; vpCrvs[i-1]->GetEndDir( vtTg) ;
-               Vector3d vtOrt = vtTg ; vtOrt.Rotate( vtExtr, 0, -1) ;
-               Point3d ptArc = ptEnd + ( 1.05 * dTool_Diam + 2 * dOffR ) * vtOrt ;
-               //Point3d ptLine = ptArc - 5 * dDiam * vtTg ;
-               PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
-               if ( IsNull( pCrvArc))
-                  return false ;
-               pCrvArc->SetExtrusion( vtExtr) ;
-               pCrvArc->Set2PVN( ptEnd, ptArc, vtTg, vtExtr) ;
-               PtrOwner<ICurveComposite> pJCrv( CreateCurveComposite()) ;
-               if ( IsNull( pJCrv))
-                  return false ;
-               pJCrv->AddCurve( Release( pCrvArc)) ;
-              // determino la curva ad amo
-               vpCrvs[i+1]->GetStartDir( vtTg) ;
-               vtOrt = vtTg ; vtOrt.Rotate( vtExtr, 0, -1) ;
-               ptArc = ptStart + ( 1.05 * dTool_Diam + 2 * dOffR ) * vtOrt ;
-               Point3d ptLine = ptArc + 5 * ( 1.05 * dTool_Diam + 2 * dOffR ) * vtTg ;
-               PtrOwner<ICurveComposite> pJCrv1( CreateCurveComposite()) ;
-               if ( IsNull( pJCrv1))
-                  return false ;
-               pJCrv1->SetExtrusion( vtExtr) ;
-               pJCrv1->AddPoint( ptLine) ;
-               pJCrv1->AddLine( ptArc) ;
-               pJCrv1->AddArcTg( ptStart) ;
+            if ( i == 0)
+               continue ;
+           // determino la curva ad amo
+            Point3d ptEnd ; vpCrvs[i-1]->GetEndPoint( ptEnd) ;
+            Vector3d vtTg ; vpCrvs[i-1]->GetEndDir( vtTg) ;
+            Vector3d vtOrt = vtTg ; vtOrt.Rotate( vtExtr, 0, -1) ;
+            Point3d ptArc = ptEnd + ( 1.1 * dTool_Diam + 2 * dOffR ) * vtOrt ;
+            //Point3d ptLine = ptArc - 5 * dDiam * vtTg ;
+            PtrOwner<ICurveArc> pCrvArc( CreateCurveArc()) ;
+            if ( IsNull( pCrvArc))
+               return false ;
+            pCrvArc->SetExtrusion( vtExtr) ;
+            pCrvArc->Set2PVN( ptEnd, ptArc, vtTg, vtExtr) ;
+            PtrOwner<ICurveComposite> pJCrv( CreateCurveComposite()) ;
+            if ( IsNull( pJCrv))
+               return false ;
+            pJCrv->AddCurve( Release( pCrvArc)) ;
+           // determino la curva ad amo
+            vpCrvs[i+1]->GetStartDir( vtTg) ;
+            vtOrt = vtTg ; vtOrt.Rotate( vtExtr, 0, -1) ;
+            ptArc = ptStart + ( 1.05 * dTool_Diam + 2 * dOffR ) * vtOrt ;
+            Point3d ptLine = ptArc + 5 * ( 1.05 * dTool_Diam + 2 * dOffR ) * vtTg ;
+            PtrOwner<ICurveComposite> pJCrv1( CreateCurveComposite()) ;
+            if ( IsNull( pJCrv1))
+               return false ;
+            pJCrv1->SetExtrusion( vtExtr) ;
+            pJCrv1->AddPoint( ptLine) ;
+            pJCrv1->AddLine( ptArc) ;
+            pJCrv1->AddArcTg( ptStart) ;
 
-               pJCrv->ToLoc( frPocket) ;
-               pJCrv1->ToLoc( frPocket) ;
-               IntersCurveCurve intCC( *pJCrv, *pJCrv1) ;
-               pJCrv->ToGlob( frPocket) ;
-               pJCrv1->ToGlob( frPocket) ;
+            pJCrv->ToLoc( frPocket) ;
+            pJCrv1->ToLoc( frPocket) ;
+            IntersCurveCurve intCC( *pJCrv, *pJCrv1) ;
+            pJCrv->ToGlob( frPocket) ;
+            pJCrv1->ToGlob( frPocket) ;
 
-               IntCrvCrvInfo aInfo ;
-               if ( intCC.GetIntersCount() > 0) {
-                     if ( intCC.GetIntCrvCrvInfo( 0, aInfo)) {
-                        PtrOwner<ICurveComposite> pCrvFinal( CreateCurveComposite()) ;
-                        PtrOwner<ICurve> PJ_Cut( pJCrv->CopyParamRange( 0, aInfo.IciA[0].dU)) ;
-                        PtrOwner<ICurve> PJ1_Cut( pJCrv1->CopyParamRange( 0, aInfo.IciB[0].dU)) ;
-                        PJ1_Cut->Invert() ;
-                        pCrvFinal->AddCurve( Release( PJ_Cut)) ;
-                        pCrvFinal->AddCurve( Release( PJ1_Cut)) ;
-                        for ( int u = 0 ; u < pCrvFinal->GetCurveCount() ; ++ u)
-                           pCrvFinal->SetCurveTempProp( u, 0, 0) ;
-                        vpCrvs[i].Set( Release( pCrvFinal)) ;
-                        vpCrvs[i]->SetTempProp( 0) ;
-                     }
-               }
-               else
-                  continue ;
+            IntCrvCrvInfo aInfo ;
+            if ( intCC.GetIntersCount() > 0) {
+                  if ( intCC.GetIntCrvCrvInfo( 0, aInfo)) {
+                     PtrOwner<ICurveComposite> pCrvFinal( CreateCurveComposite()) ;
+                     PtrOwner<ICurve> PJ_Cut( pJCrv->CopyParamRange( 0, aInfo.IciA[0].dU)) ;
+                     PtrOwner<ICurve> PJ1_Cut( pJCrv1->CopyParamRange( 0, aInfo.IciB[0].dU)) ;
+                     PJ1_Cut->Invert() ;
+                     pCrvFinal->AddCurve( Release( PJ_Cut)) ;
+                     pCrvFinal->AddCurve( Release( PJ1_Cut)) ;
+                     for ( int u = 0 ; u < pCrvFinal->GetCurveCount() ; ++ u)
+                        pCrvFinal->SetCurveTempProp( u, 0, 0) ;
+                     vpCrvs[i].Set( Release( pCrvFinal)) ;
+                     vpCrvs[i]->SetTempProp( 0) ;
+                  }
+            }
+            else
+               continue ;
          }
          PtrOwner<ICurve> pCrvlonger( OffsCrv.GetLongerCurve()) ;
          //int W = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvlonger->Clone()) ;
@@ -8996,8 +8931,6 @@ Pocketing::AdjustPathOutsideRawForOpenEdges( const ICurveComposite* pCompo, cons
                   return false ;
                if ( ! pCrvCurrPartIn_->TrimStartEndAtParam( ccClass[i].dParS, ccClass[i].dParE))
                   pCrvCurrPartIn_->Clear() ;
-               //PtrOwner<ICurveComposite> pCrvCurrPartIn( GetCurveComposite( pCrvCurr->CopyParamRange( ccClass[i].dParS,
-               //                                                                                       ccClass[i].dParE))) ;
                if ( IsNull( pCrvCurrPartIn_)  ||  ! pCrvCurrPartIn_->IsValid())
                   continue ;
 
@@ -9061,11 +8994,11 @@ Pocketing::AdjustPathOutsideRawForOpenEdges( const ICurveComposite* pCompo, cons
                         PtrOwner<ICurveComposite> pCrvExtBorder( CreateCurveComposite()) ;
                         if ( IsNull( pCrvExtBorder))
                            return false ;
-                        pCrvExtBorder->AddCurve( Release( pArcS)) ;                // primo tratto lineare
-                        pCrvExtBorder->AddCurve( Release( pCompoPartInOffs)) ;     // tratto di offset
-                        pCrvExtBorder->AddCurve( Release( pArcE)) ;                // secondo tratto lineare
-                        pCrvCurrPartIn->Invert() ;                                 // inversione del tratto interno
-                        pCrvExtBorder->AddCurve( pCrvCurrPartIn->Clone()) ;       // aggiunta del tratto interno
+                        pCrvExtBorder->AddCurve( Release( pArcS)) ;                 // primo tratto lineare
+                        pCrvExtBorder->AddCurve( Release( pCompoPartInOffs)) ;      // tratto di offset
+                        pCrvExtBorder->AddCurve( Release( pArcE)) ;                 // secondo tratto lineare
+                        pCrvCurrPartIn->Invert() ;                                  // inversione del tratto interno
+                        pCrvExtBorder->AddCurve( pCrvCurrPartIn->Clone()) ;         // aggiunta del tratto interno
 
                         //int rrr = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pCrvExtBorder->Clone()) ;
                         //m_pGeomDB->SetMaterial( rrr, RED) ;
@@ -9114,10 +9047,10 @@ Pocketing::AdjustPathOutsideRawForOpenEdges( const ICurveComposite* pCompo, cons
 
    }
 
-   if ( bInVsOut) {
+   //if ( bInVsOut) {
       //int P = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmRaw->Clone()) ;        //
       //m_pGeomDB->SetMaterial( P, LIME) ;
-   }
+   //}
 
 
    PtrOwner<ISurfFlatRegion> pSrfInc_toDraw1( CloneSurfFlatRegion( pSfrInc)) ;
@@ -9442,7 +9375,6 @@ bool
 Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, const double& dRawSecLen,
                             ICRVCOMPOPOVECTOR& vCrvOEFlags, bool& bChanged, int nStep, double dStep, double dAreaToll)
 {
-
   // controllo dei parametri
    if ( pSrf == nullptr  ||  dAreaToll < EPS_SMALL)
       return false ;
@@ -9470,7 +9402,7 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, const doubl
             return false ;
          if ( pSrf == nullptr  ||  pSrf->GetChunkCount() == 0  ||  ! pSrf->IsValid())
             return true ;
-         PtrOwner<ISurfFlatRegion> pSrf_toDraw( CloneSurfFlatRegion( pSrf)) ;
+         /*PtrOwner<ISurfFlatRegion> pSrf_toDraw( CloneSurfFlatRegion( pSrf)) ;
          pSrf_toDraw->Translate( vtTrasl) ;
          int a = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_toDraw->Clone()) ;
          m_pGeomDB->SetMaterial( a, AQUA) ;
@@ -9487,11 +9419,9 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, const doubl
                      m_pGeomDB->SetMaterial( aaa, Color( 1.0, 0.5, 0.0)) ;
                }
             }
-         }
+         }*/
       }
 
-      return true ;
-
      // 2) PROIEZIONE CON GREZZO
       if ( m_bProjectRaw) {
         // recupero la Trimesh di partenza
@@ -9519,7 +9449,6 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, const doubl
          }*/
       }
    }
-   //return true ;
 
   // salvo una copia della superficie attuale
    PtrOwner<ISurfFlatRegion> pSrf_noOpenEdge( CloneSurfFlatRegion( pSrf)) ;
@@ -9530,10 +9459,9 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, const doubl
    if ( ! ModifySurfByOpenEdge( pSrf, vCrvOEFlags, vtTrasl, pStmRaw))
       return false ;
 
-   PtrOwner<ISurfFlatRegion> pSrf_toDraw( CloneSurfFlatRegion( pSrf)) ;
-   pSrf_toDraw->Translate( vtTrasl) ;
+   //PtrOwner<ISurfFlatRegion> pSrf_toDraw( CloneSurfFlatRegion( pSrf)) ;
+   //pSrf_toDraw->Translate( vtTrasl) ;
    //m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_toDraw->Clone()) ;
-
    /*for ( int c = 0 ; c < pSrf->GetChunkCount() ; ++ c) {
       for ( int l = 0 ; l < pSrf->GetLoopCount( c) ; ++ l) {
          const ICurveComposite* pCrvCompo( GetCurveComposite( pSrf->GetLoop( c, l))) ;
@@ -9544,7 +9472,6 @@ Pocketing::AdaptSfrWithRaw( ISurfFlatRegion* pSrf, Vector3d vtTrasl, const doubl
          }
       }
    }*/
-
    //PtrOwner<ISurfFlatRegion> pSrf_toDraw( CloneSurfFlatRegion( pSrf)) ;
    //pSrf_toDraw->Translate( vtTrasl) ;
    //int p = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_toDraw->Clone()) ;
@@ -9637,10 +9564,10 @@ Pocketing::AdjustFakeOpenEdges( ICurveComposite* pCrvCompo, const ISurfFlatRegio
       }
    }
 
-   if ( bFromProj) {
+   //if ( bFromProj) {
       //for ( int i = 0 ; i < vCrvExtProj.size() ; ++ i)
       //m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvExtProj[i]->Clone()) ;
-   }
+   //}
   //-------------------------------------------------------------------------------------------------------------
 
   // ---------------- CREAZIONE DELLA VERA A PROPRIA REGIONE DI INCIDENZA, COME SOMMA DELLE
@@ -9674,10 +9601,10 @@ Pocketing::AdjustFakeOpenEdges( ICurveComposite* pCrvCompo, const ISurfFlatRegio
       pSrf_ind0->Invert() ;
    pSrf_Proj->Add( *pSrf_ind0) ;
 
-   if ( bFromProj) {
+   //if ( bFromProj) {
       //int ooo = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_Proj->Clone()) ;
       //m_pGeomDB->SetMaterial( ooo, Color( 0.0, 1.0, 0.0, 0.3)) ;
-   }
+   //}
   // ===============================================================================================================
 
   // Clono la superificie originaria, portandola allo step corrente
@@ -9686,11 +9613,11 @@ Pocketing::AdjustFakeOpenEdges( ICurveComposite* pCrvCompo, const ISurfFlatRegio
       return false ;
    pSrfOrig_clone->Translate( vtTrasl) ;
 
-   if ( bFromProj) {
+   //if ( bFromProj) {
       //int oooo = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfOrig_clone->Clone()) ;
       //m_pGeomDB->SetMaterial( oooo, Color( 0.0, 0.0, 0.0, 0.3)) ;
-   }
-   
+   //}
+
   // ho cambiato un lato aperto in chiuso ?
    bool bLoopL_isChanged = false ;
    const int MAX_TRY = 10 ;
@@ -9780,10 +9707,10 @@ Pocketing::AdjustFakeOpenEdges( ICurveComposite* pCrvCompo, const ISurfFlatRegio
                          double dUEnd ;       // parametro relativo finale
 
                          PtrOwner<ICurve> CIAO( pCrv_tOpen_Offs->CopyParamRange( ccClass[j].dParS,  ccClass[j].dParE)) ;
-                         if ( bFromProj) {
+                         //if ( bFromProj) {
                             //int YEs = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, CIAO->Clone()) ;
                             //m_pGeomDB->SetMaterial( YEs, Color( 0.95, 0.0, 0.63, 1.0)) ;
-                         }
+                         //}
 
                        // ------------------------------ PARAMETRO FINALE -----------------------------------
                        // se non sono su un raccordo ...
@@ -9845,7 +9772,7 @@ Pocketing::AdjustFakeOpenEdges( ICurveComposite* pCrvCompo, const ISurfFlatRegio
                        // controllo...
                         if ( dUStart > dUEnd)
                            swap( dUStart, dUEnd) ;
-                         
+
                        // tratto precente
                         PtrOwner<ICurveComposite> pCrv_Bef( CloneCurveComposite( pCrvCompo_Clone_Trasl)) ;
                        // tratto successivo
@@ -9993,28 +9920,19 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
       for ( int i = 0 ; i < ( int)vCrvIsl.size() ; ++ i) {
          bSomeOpen = false ;
          nProp0 = -1 ;
-         int nCrvOpen = 0 ;
          PtrOwner<ICurveComposite> pCrvIsl( GetCurveComposite( vCrvIsl[i]->Clone())) ;
          for ( int u = 0 ; u < pCrvIsl->GetCurveCount() ; ++ u) {
-            if ( pCrvIsl->GetCurveTempProp( u, nProp0, 0)  &&  nProp0 == 1) {
+            if ( pCrvIsl->GetCurveTempProp( u, nProp0, 0)  &&  nProp0 == 1)
                bSomeOpen = true ;
-               ++ nCrvOpen ;
-            }
          }
          if ( bSomeOpen) { // se trovo dei lati aperti
            // 5.1) se l'isola è tutta aperta e trascurabile la talgo
-            if ( nCrvOpen == pCrvIsl->GetCurveCount()) {
-               // 5.1.1) Offsetto l'isola e controllo se sparisce
-               OffsetCurve OffsCrv ;
-               if ( ! OffsCrv.Make( pCrvIsl, m_dDiam_Prec > 0 ? m_dDiam_Prec + m_dOffsetR_Prec : m_TParams.m_dDiam,
-                                    ICurve::OFF_FILLET)) {
-                  m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
-                  return false ;
-               }
-              // nel caso l'Offset sparisca, allora passo all'isola successiva
-               if ( OffsCrv.GetCurveCount() == 0)
-                  continue ;
-            }
+            bool bRemove = false ;
+            if ( ! CheckForRemovingIsland( pCrvIsl, m_dDiam_Prec > 0 ? m_dDiam_Prec + m_dOffsetR_Prec : m_TParams.m_dDiam,
+                                           bRemove))
+               return false ;
+            if ( bRemove) // se si può trascurare passo alla successiva
+               continue ;
            // 5.2) sistemo la superificie
             ICRVCOMPOPOVECTOR vCrvNULL ;
             if ( ! AdjustContourWithOpenEdges( pCrvIsl, vCrvNULL, m_dDiam_Prec > 0 ? m_dDiam_Prec : m_TParams.m_dDiam,
@@ -10043,15 +9961,10 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
          pSrfFinal->Add( *pSrfHelp_) ;
    }
 
-   //int bb = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrfFinal->Clone()) ;
-   //m_pGeomDB->SetMaterial( bb, BLACK) ;
-   //for ( int is = 0 ; is < ( int)vCrvToTIsl.size() ; ++ is) {
-   //   int bb = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, vCrvToTIsl[is]->Clone()) ;
-   //   m_pGeomDB->SetMaterial( bb, WHITE) ;
-   //}
-
   // ora che ho la superificie finale, questa potrebbe contenere più isole rispetto a quelle originarie
-  // devo togliere le isole che non fanno overlap con nessun isola originaria
+  // ( Se la superficie, dopo intersezione e proeizione, è formata da c-Chunks e questi una volta allargati presso
+  //   i lati aperti dalla funzione AdjustContourWithOpenEdges si sono uniti -> possono esseresi formate ulteriori isole
+  //   aperte...) => devo togliere le isole opportune )
    SurfFlatRegionByContours pSrf_noFakeIslands ;
    for ( int c = 0 ; c < pSrfFinal->GetChunkCount() ; ++ c) {
      // aggiungo il bordo esterno
@@ -10061,8 +9974,9 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
          PtrOwner<ICurveComposite> pCrvCompo( CreateCurveComposite()) ;
          if ( IsNull( pCrvCompo))
             return false ;
-         bool bIsRealIsland = false ;
          pCrvCompo->AddCurve( pCrv->Clone()) ;
+         bool bIsRealIsland = false ;
+        // se l'isola attuale ha una curva che fa overlap con una delle isole originarie allora la tengo ...
          for ( int is = 0 ; is < ( int)vCrvToTIsl.size()  &&  !bIsRealIsland ; ++ is) {
             for ( int u = 0 ; u < pCrvCompo->GetCurveCount()  &&  !bIsRealIsland ; ++ u) {
                const ICurve* pCrv_u = pCrvCompo->GetCurve( u) ;
@@ -10073,8 +9987,22 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
                   bIsRealIsland = true ;
             }
          }
+        // ... ( quindi la inserisco)
          if ( bIsRealIsland)
             pSrf_noFakeIslands.AddCurve( Release( pCrv)) ;
+        // altrimenti controllo se è necessaria
+         else {
+            bool bRemove = false ;
+            PtrOwner<ICurveComposite> pCrvBorder( CreateCurveComposite()) ;
+            if ( IsNull( pCrvBorder))
+               return false ;
+            pCrvBorder->AddCurve( Release( pCrv)) ;
+            if ( ! CheckForRemovingIsland( pCrvBorder, m_dDiam_Prec > 0 ? m_dDiam_Prec + m_dOffsetR_Prec : m_TParams.m_dDiam,
+                                           bRemove))
+               return false ;
+            if ( ! bRemove)
+               pSrf_noFakeIslands.AddCurve( Release( pCrvBorder)) ;
+         }
       }
    }
 
@@ -10089,6 +10017,39 @@ Pocketing::ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvO
 
 }
 
+bool
+Pocketing::CheckForRemovingIsland( ICurveComposite* pCrvIslandBorder, double dOffs, bool bRemove)
+{
+  // controllo dei parametri
+  // NB. La curva dell'isola gira in senso orario, quindi l'offset va fatto in positivo
+   if ( pCrvIslandBorder == nullptr  ||  ! pCrvIslandBorder->IsValid()  ||  dOffs < EPS_SMALL)
+      return false ;
+   bRemove = false ;
+
+  // controllo se l'isola è tutta aperta
+   for ( int u = 0 ; u < pCrvIslandBorder->GetCurveCount() ; ++ u) {
+      const ICurve* pCrv_u = pCrvIslandBorder->GetCurve( u) ;
+      if ( pCrv_u == nullptr)
+         return false ;
+      int nTmpProp0 = pCrv_u->GetTempProp( 0) ;
+     // se trovo una sottocurva che non è aperta, esco
+      if ( nTmpProp0 != 1)
+         return true ;
+   }
+
+  // tutte le curva sono aperte, effettuo un offset per vedere se l'isola è da tenere
+   OffsetCurve OffsCrv ;
+   if ( ! OffsCrv.Make( pCrvIslandBorder, dOffs, ICurve::OFF_FILLET)) {
+      m_pMchMgr->SetLastError( 2412, "Error in Pocketing : Offset not computable") ;
+      return false ;
+   }
+  // nel caso l'Offset sparisca, all'ora l'isola non è necessaria
+   if ( OffsCrv.GetCurveCount() == 0)
+      bRemove = true ;
+
+   return true ;
+}
+
 
 
 //----------------------------------------------------------------------------
@@ -10117,7 +10078,7 @@ Pocketing::IntersSurfWithRaw( ISurfFlatRegion* pSfrPock, const ISurfTriMesh* pSt
       return false ;
   // traslo la superificie da svuotare a seconda dello step e la taglio con il grezzo
    if ( ! pStm->Translate( vtTrasl)  ||
-      //! m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStm->Clone())  ||  ! m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmRaw->Clone())  ||
+      ! m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStm->Clone())  ||  ! m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pStmRaw->Clone())  ||
       ! pStm->CutWithOtherSurf( *pStmRaw, bInVsOut, true)) {
       pStm.Set( pStmCopy) ;
      // nel caso il taglio non sia riuscito, allungo leggermente il vettore di traslazione e riprovo
@@ -10658,7 +10619,8 @@ Pocketing::OptimizeChunkOneWay( ISurfFlatRegion* pSrfOrig, ISURFFRPOVECTOR& vSrf
 
 //----------------------------------------------------------------------------
 bool
-Pocketing::AssignContourToPath( const ICRVCOMPOPOVECTOR& vpCrvs, const Frame3d frPocket, const ISurfFlatRegion* pSrfOffs, ICRVCOMPOPOVECTOR& vAllCrv)
+Pocketing::AssignContourToPath( const ICRVCOMPOPOVECTOR& vpCrvs, const Frame3d frPocket, const ISurfFlatRegion* pSrfOffs,
+                                ICRVCOMPOPOVECTOR& vAllCrv)
 {
   // controllo dei parametri
    if (( int) vpCrvs.size() == 0  ||  pSrfOffs == nullptr  ||  pSrfOffs->GetChunkCount() == 0)
@@ -10704,7 +10666,6 @@ Pocketing::OrderCurvesByLastPntOfPath( ICRVCOMPOPOVECTOR& vCrv, Point3d ptEnd, P
          }
       }
       if ( nIndexSwitch != i + 1) {
-
         // scambio le curve
          PtrOwner<ICurveComposite> pCrvClosest( vCrv[nIndexSwitch]->Clone()) ;
          vCrv[nIndexSwitch].Set( vCrv[i+1]) ;
@@ -10735,7 +10696,7 @@ Pocketing::OrderCurvesByLastPntOfPath( ICRVCOMPOPOVECTOR& vCrv, Point3d ptEnd, P
 
 //----------------------------------------------------------------------------
 bool
-Pocketing::ProjectEdgesOnSelFace( const ISurfFlatRegion* pSfrFacet, const ISurfTriMesh* pStmOrig, INTVECTOR& vId , 
+Pocketing::ProjectEdgesOnSelFace( const ISurfFlatRegion* pSfrFacet, const ISurfTriMesh* pStmOrig, INTVECTOR& vId ,
                                   int nFacet, ISurfFlatRegion* pSfrProj)
 {
   // controllo parametri
@@ -11800,7 +11761,6 @@ Pocketing::GetParamForPtStartOnEdge( const ICurve* pCrvCheck, const ICurveCompos
               // Devo essere sicuro di essere su una curva di Offset interno, altrimenti potrebbe essere valido
               // il punto trovato, però facendo poi il primo offeset tale punto potrebbe diventare un punto
               // di convergenza tra più chunks...
-               //Vector3d vtPerpIn ;
                PtrOwner<ICurveComposite> pCompoClone( CloneCurveComposite( pCompo)) ;
                if ( IsNull( pCompoClone))
                   return false ;
@@ -11833,24 +11793,22 @@ Pocketing::GetParamForPtStartOnEdge( const ICurve* pCrvCheck, const ICurveCompos
 
 
             if ( intCC.GetCurveClassification( 0, EPS_SMALL, ccClass)) {
-               //if (( int)ccClass.size() == 3  &&  ccClass[1].nClass == CRVC_IN) {
-                 // se ho solo due intersezioni, controllo di non intersecare isole
-                  bool bOk = true ;
-                  for ( int j = 0 ; j < ( int)vCrvNoInters.size()  &&  bOk ; ++ j) {
+              // se ho solo due intersezioni, controllo di non intersecare isole
+               bool bOk = true ;
+               for ( int j = 0 ; j < ( int)vCrvNoInters.size()  &&  bOk ; ++ j) {
 
-                     IntersCurveCurve intCCI( *vCrvNoInters[j], *pCrvToolShape) ;
-                     if ( intCCI.GetCurveClassification( 0, EPS_SMALL, ccClass)) {
-                        if (( int)ccClass.size() > 1)
-                           bOk = false ;
-                     }
-                     else
-                        return false ;
+                  IntersCurveCurve intCCI( *vCrvNoInters[j], *pCrvToolShape) ;
+                  if ( intCCI.GetCurveClassification( 0, EPS_SMALL, ccClass)) {
+                     if (( int)ccClass.size() > 1)
+                        bOk = false ;
                   }
-                  if ( bOk) {
-                     dPar = dParT ;
-                     return true ;
-                  }
-               //}
+                  else
+                     return false ;
+               }
+               if ( bOk) {
+                  dPar = dParT ;
+                  return true ;
+               }
             }
             else
                return false ;
@@ -12396,11 +12354,11 @@ Pocketing::CheckIfOffsetIsNecessary( const ICurveComposite* pCrvOffs, const doub
          return true ;
 
      // controllo se richista ottimizzazione per Offsets mediante centroidi e medial Axis
-      if( ! m_bOptOffsetCM  ||  OffsCrv.GetCurveCount() > 1)
+      if ( ! m_bOptOffsetCM  ||  OffsCrv.GetCurveCount() > 1)
          return true ;
 
       PtrOwner<ICurve> pCrvOffLonger( OffsCrv.GetLongerCurve()) ;
-      if( IsNull( pCrvOffLonger)  ||  ! pCrvOffLonger->IsValid())
+      if ( IsNull( pCrvOffLonger)  ||  ! pCrvOffLonger->IsValid())
          return true ;
 
      // Immagine del tool con centro nel centroide della zona da svuotare
@@ -12419,18 +12377,16 @@ Pocketing::CheckIfOffsetIsNecessary( const ICurveComposite* pCrvOffs, const doub
          return true ;
       }
 
-      // <- secondo test
-
       PolyLine pl ;
       if ( ! pCrvOffLonger->ApproxWithLines( 100 * EPS_SMALL, ANG_TOL_STD_DEG, ICurve::APL_STD, pl))
          return true ;
       Vector3d vtX ;
       double dLen = 0 ; double dHeight = 0 ;
-      if( ! pl.GetMinAreaRectangleXY( ptC, vtX, dLen, dHeight))
+      if ( ! pl.GetMinAreaRectangleXY( ptC, vtX, dLen, dHeight))
          return true ;
 
       Frame3d frLoc ; frLoc.Set( ptC, vtN, vtX) ;
-      if( ! frLoc.IsValid())
+      if ( ! frLoc.IsValid())
          return true ;
       BBox3d bBox ;
       frLoc.Invert() ;
@@ -12438,7 +12394,7 @@ Pocketing::CheckIfOffsetIsNecessary( const ICurveComposite* pCrvOffs, const doub
       double dDimX = bBox.GetDimX() ;
       double dDimY = bBox.GetDimY() ;
 
-      if( dDimX < m_TParams.m_dDiam - 100 * EPS_SMALL  ||
+      if ( dDimX < m_TParams.m_dDiam - 100 * EPS_SMALL  ||
          dDimY < m_TParams.m_dDiam - 100 * EPS_SMALL) {
          bInsert = false ;
          return true ;
@@ -12511,7 +12467,6 @@ Pocketing::AssignFeedZigZagOneWay( ICurveComposite* pCompo, const bool bIsLink,
    if ( !m_bAssignFeed)
       return AssignDefaultFeed( pCompo) ;
 
-
   // inzialmente setto la feed Minima alla curva
    for ( int u = 0 ;  u < pCompo->GetCurveCount() ; ++ u)
       pCompo->SetCurveTempProp( u, FEED_DIVISOR * GetMinFeed(), 0) ;
@@ -13153,8 +13108,8 @@ Pocketing::GetNewSrfByAnotherPocketing( ISurfFlatRegion* pSrf, ISurfFlatRegion*
       PtrOwner<ISurfFlatRegion> pSrf_Sub( CloneSurfFlatRegion( pSrf)) ;
       if ( IsNull( pSrf_Sub)  ||  ! pSrf_Sub->IsValid())
          return false ;
-      int Y = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_Sub->Clone()) ;
-      m_pGeomDB->SetMaterial( Y, YELLOW) ;
+      //int Y = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_Sub->Clone()) ;
+      //m_pGeomDB->SetMaterial( Y, YELLOW) ;
      // effettuo un Offset verso l'interno ( curve esterne che percorre il centro del Tool)
       if ( pSrf_Sub->Offset( - m_dDiam_Prec / 2 - m_dOffsetR_Prec - 5 * EPS_SMALL, ICurve::OFF_FILLET)) {
         // se la superificie sparisce o trovo un chunk non valido, la risvuoto tutta per sicurezza...
@@ -13168,11 +13123,11 @@ Pocketing::GetNewSrfByAnotherPocketing( ISurfFlatRegion* pSrf, ISurfFlatRegion*
             return false ;
          }
 
-         int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_Sub->Clone()) ;
-         m_pGeomDB->SetMaterial( r, RED) ;
+         //int r = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_Sub->Clone()) ;
+         //m_pGeomDB->SetMaterial( r, RED) ;
 
-         int v = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_noOpenEdge->Clone()) ;
-         m_pGeomDB->SetMaterial( v, GREEN) ;
+         //int v = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_noOpenEdge->Clone()) ;
+         //m_pGeomDB->SetMaterial( v, GREEN) ;
 
          PtrOwner<ISurfFlatRegion> pSrf_clone( CloneSurfFlatRegion( pSrf_noOpenEdge)) ;
          if ( pSrf_clone->Subtract( *pSrf_Sub)) {
@@ -13182,8 +13137,8 @@ Pocketing::GetNewSrfByAnotherPocketing( ISurfFlatRegion* pSrf, ISurfFlatRegion*
                return true ;
             }
 
-            int l = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_clone->Clone()) ;
-            m_pGeomDB->SetMaterial( l, LIME) ;
+            //int l = m_pGeomDB->AddGeoObj( GDB_ID_NULL, GDB_ID_ROOT, pSrf_clone->Clone()) ;
+            //m_pGeomDB->SetMaterial( l, LIME) ;
 
            // ricavo la curva esterna originale
             PtrOwner<ICurveComposite> pCrvExt_orig( GetCurveComposite( pSrf->GetLoop( 0, 0))) ;
diff --git a/Pocketing.h b/Pocketing.h
index 74b12a9..5cc3afb 100644
--- a/Pocketing.h
+++ b/Pocketing.h
@@ -146,7 +146,8 @@ class Pocketing : public Machining
                                double& dPar) ;
       bool ModifySurfByOpenEdge( ISurfFlatRegion* pSrf, ICRVCOMPOPOVECTOR& vCrvOEFlags, const Vector3d& vtTrasl, ISurfTriMesh* pStmRaw = nullptr) ;
       bool GetNewSrfByAnotherPocketing( ISurfFlatRegion* pSrf, ISurfFlatRegion* pSrf_noOpenEdge, const Vector3d& vtTrasl) ;
-     // ===================================================================
+      bool CheckForRemovingIsland( ICurveComposite* pCrvIslandBorder, double dOffs, bool bRemove) ;
+      // ===================================================================
 
      // ============================ ZigZag ===============================
       bool AddZigZag( const ISurfFlatRegion* pSrfPock, const Vector3d& vtTool, const Vector3d& vtExtr, double dDepth, double dElev, 
@@ -334,7 +335,7 @@ class Pocketing : public Machining
       bool          m_bOpenOutRaw ;           // flag forzatura lati aperti sempre fuori dal grezzo
       double        m_dOpenMinSafe ;          // minima distanza di sicurezza di attacco su lato aperto
       bool          m_bIntersRaw = true ;     // flag per intersezione con grezzo
-      bool          m_bProjectRaw = true ;    // flag di proiezione del grezzo
+      bool          m_bProjectRaw = true ;   // flag di proiezione del grezzo
       double        m_dMaxLenRawProj = 100 ;  // lunghezza massima per contatto di proiezione
       bool          m_bOptOffset = true ;     // flag per ottimizzazione numero di Offset necessari
       bool          m_bOptOffsetCM = false ;  // flag per ottimizzazione numero di Offset necessari con centroidi e medial Axis